Aufgabe

Erstellen Sie bei einem druckbaren Nicht-Whitespace-Zeichen eine 3x3-Quadrat-Darstellung dieser Eingabe. Wenn zum Beispiel die Eingabe ist #, dann ist die Ausgabe:

###
# #
###

Regeln

• Das Ausgabeformat ist streng, obwohl ein abschließender Zeilenumbruch zulässig ist. Dies bedeutet, dass das Leerzeichen in der Mitte und die zwei Zeilenumbrüche zwischen den drei Zeilen erforderlich sind.

Testfälle

Eingang: #

Ausgabe:

###
# #
###

Eingang: A

Ausgabe:

AAA
A A
AAA

Eingang: 0

Ausgabe:

000
0 0
000

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Kohle , 5 3 Bytes

Ｂ³Ｓ

Probieren Sie es online! Bearbeiten: 40% gespart dank @carusocomputing. Erläuterung:

Ｂ   Draw a box
³   3×3 (second dimension is implicit if omitted)
Ｓ   Using the input character

Karotte , 11 Bytes

###
# #
###

Probieren Sie es online!

Das Programm befindet sich im Caret-Modus, wobei #s durch die Eingabe ersetzt werden.

Python 2 , 32 Bytes

lambda s:s+s.join(s+'\n \n'+s)+s

Probieren Sie es online!
Denn s='a': die Mitte s+'\n \n'+serzeugt a\n \naund s.joindreht es ein (fettgedruckte sind diejenigen, die es hinzufügen), weil sie eine Zeichenfolge als Iterationszeichen akzeptiert und dann mit den beiden fehlenden Zeichen umgeben istaa\na a\naaa.join.join

MATL , 5 Bytes

3Y6*c

Probieren Sie es online!

Erläuterung

3Y6   % Push predefined literal: [true true true; true false true; true true true]
*     % Implicitly input a character. Multiply element-wise by its code point
c     % Convert to char. Implicitly display. Char 0 is displayed as space

05AB1E , 8 Bytes

4×ð«û3ô»

Probieren Sie es online!

INPUT    # ['R']                 | Implicit Input: 'R'
---------#-----------------------+-------------------------------
4×       # ['RRRR']              | Repeat string 4 times.     
  ð      # ['RRRR',' ']          | Push space onto top of stack.
   «     # ['RRRR ']             | Concatenate last 2 items.
    û    # ['RRRR RRRR']         | Palindromize.
     3ô  # [['RRR','R R','RRR']] | Split into 3 pieces.
       » # ['RRR\nR R\nRRR']     | Join with newlines
---------#-----------------------+-------------------------------
OUTPUT   # RRR                   | Implicitly print the top
         # R R                   | of the stack on exit.
         # RRR                   |

Ursprüngliche Idee, 30 als Binärzahl zu verwenden (unvollendet, jemand anderes versucht dies in einer anderen Sprache):

05AB1E , 12 Bytes

30bûTIð«‡3ô»

Probieren Sie es online!

Python 3.6 , 33 Bytes

lambda c:f'{3*c}\n{c} {c}\n{3*c}'

Probieren Sie es online!

RPL (Reverse Polish Lisp) , 60 Zeichen

→STR 1 4 START DUP NEXT " " + SWAP + 4 ROLLD + + SWAP 2 PICK

(Beachten Sie, dass "→" auf dem HP48 und kompatiblen Rechnern ein einzelnes Zeichen ist.)

Stellt visuell dar, was Sie möchten, indem Sie drei Elemente auf dem Stapel haben:

3.: "###"
2.: "# #"
1.: "###"

Wenn Sie darauf bestehen, es als eine Zeichenfolge zurückzugeben, müssen Sie auch die Zeilenumbrüche hinzufügen und die Zeichenfolgen kombinieren, die Sie als Übung dem nächsten Tester überlassen haben.

Erläuterung:

• →STR: Machen Sie das letzte Objekt im Stapel zu einer Zeichenfolge. (Die Eingabe kann also alles sein, zB eine Zahl.)
• 1 4: Schieben Sie die Nummer 1und 4auf den Stapel.
• START [...] NEXT: Wie eine for-Schleife, jedoch ohne Zugriff auf die Zählervariable. Nimmt zwei Zahlen aus dem Stapel (hier haben wir nur geschoben 1und 4) und führt den Code [...]der entsprechenden Zeiten (hier vier Mal).
• DUP: Dupliziere den letzten Eintrag im Stapel.
• " ": Schieben Sie die Zeichenfolge (dh die Zeichenfolge mit einem Leerzeichen) auf den Stapel.
• +: Nehmen Sie zwei Objekte aus dem Stapel und geben Sie sie addiert für Zeichenfolgen zurück: Verkettet.
• 4: Schieben Sie die Nummer 4auf den Stapel.
• ROLLD: Nimmt das letzte Element (hier: 4das wir gerade verschoben haben) vom Stapel und rollt das nächste Element so weit nach unten, wie es die Zahl angibt, die wir gerade vom Stapel genommen haben.
• SWAP: Vertauscht die beiden letzten Stapelelemente.
• 2: 2Zum Stapel schieben.
• PICK: Nimmt ein Element (hier: Das, was 2wir gerade in den Stapel geschoben haben), interpretiert es als Zahl n und kopiert das n-te Element aus dem Stapel.

JavaScript, 28 Byte

c=>c+c+c+`
${c} ${c}
`+c+c+c

Versuch es

f=
c=>c+c+c+`
${c} ${c}
`+c+c+c
o.innerText=f(i.value="#")
i.oninput=_=>o.innerText=f(i.value)

<input id=i maxlength=1><pre id=o>

Gelee , 8 Bytes

1 Byte danke an Erik den Outgolfer.

x4,`Ks3Y

Probieren Sie es online!

Java 7, 56 55 Bytes

-1 Danke an Leaky Nun für den Hinweis auf den Raum, den ich verpasst habe

String a(char s){return"...\n. .\n...".replace('.',s);}

Ersetzt einfach die Punkte durch das angegebene Zeichen für die Eingabe #:

...       ###
. .  =>   # #
...       ###

Probieren Sie es online!

PHP, 32 Bytes

<?=strtr("000
0 0
000",0,$argn);

Probieren Sie es online!

sed, 28 18 bytes

s:.:&&&\n& &\n&&&:

Probieren Sie es online!

Brain-Flak , 76 70 + 1 = 71 Bytes

Benötigt die -cFlagge

(((((((({})))<((([])[]{}<>)<>)>)<(<>({})({}){}()()<>)>)<([]()()())>)))

Probieren Sie es online!

Pyth, 7 Bytes

jc3.[9d

Versuchen Sie dies online.

Erläuterung:

jc3.[9d Expects quoted input.
  3     3
     9  9
      d ' '
        Q (eval'd input) as implicit argument
   .[   Pad B on both sides with C until its length is a multiple of A
 c      Split B to chunks of length A, last chunk may be shorter
j       Join A on newlines

Brain-Flak , 61 , 59 Bytes

(((((((({})))<([][][]())>)<(([][][]()){})>)<([]()()())>)))

Probieren Sie es online!

Dies sind 58 Byte Code- +1Byte für das -cFlag, das die ASCII-Eingabe und -Ausgabe ermöglicht.

Erläuterung:

(((
   (
    (
     (

      #Duplicate the input 3 times
      ((({})))

#Push 10 (newline)
<([][][]())>

     #Push the input again
     )

#Push 32 (space)
<(([][][]()){})>

    #Push the input again
    )

#Push 10 (newline)
<([]()()())>)

#Push input 3 times
)))

C (gcc) , 49 47 Bytes

2 Bytes gespart dank 2501!

j;f(i){for(j=12;j;)putchar(--j%4?j-6?i:32:10);}

Probieren Sie es online! hat einen nachgestellten Zeilenumbruch

Python 3 , 34 Bytes

lambda s:s*3+"\n"+s+" "+s+"\n"+s*3

Probieren Sie es online!

Oktave , 36 Bytes

x=repmat(input(0),3);x(5)=32;disp(x)

Probieren Sie es online!

Erläuterung

Dadurch wird eine 3x3-Zeichenmatrix erstellt, in der das Eingabezeichen wiederholt wird, und der fünfte Eintrag in der Hauptreihenfolge der Spalten (dh in der Mitte) wird auf 32(ASCII für Leerzeichen) gesetzt.

Pyke , 5 Bytes

dQA.X

Probieren Sie es online!

Ruby , 27 25 Bytes

2 Bytes gespart dank Level River St

->x{[s=x*3,x+" "+x,s]*$/}

Probieren Sie es online!

Brainfuck, 40 Bytes

+++++[->++<<++++++>],...>.<.<++.>.>.<...

Probieren Sie es online! Benötigt eine Implementierung, die links von der Startposition zugreifen kann.

Siehe auch: Gravitons Brainfuck-Antwort, die einen anderen Ansatz hat (aber länger ist).

Erläuterung:

Brainfuck kann mit seinem begrenzten Befehlssatz eine Menge cooler Tricks machen. Leider verwendet diese Antwort keine von ihnen, da es (in Form von Bytes) billiger ist, nur alles fest zu codieren.

+++++[->++<<++++++>]                         Sets the cells to |5*6|>0<|5*2|
,                   Takes input character into the middle cell | 30|>#<| 10|
...                                Print the top of the square | 30|>#<| 10| ###
>.                                   Print a newline character | 30| # |>10|    \n
<.                               Print another input character | 30|>#<| 10| #
<++.                  Add 30+2 for a space character and print |>32| # | 10|  _
>.                   And just print the 5 remaining characters | 32|>#<| 10|   #
>.                                                             | 32| # |>10|    \n
<...                                                           | 32|>#<| 10| ###

# = Eingabezeichen, _ = Leerzeichen (ASCII 32), \ n = Newline (ASCII 10)

Ergebnisse in dieser schönen Box (für Eingabe '+'):

+++
+ +
+++

05AB1E , 7 6 Bytes

-1 Byte dank Carusocomputing.

ж¹ðJû

Erläuterung:

         # Implicit input                  # ['R']
 Ð       # Repeat string three times       # ['R', 'R', 'R']
  ¶      # Push newline character          # ['R', 'R', 'R', '\n']
   ¹     # Push first input                # ['R', 'R', 'R', '\n', 'R']
    ð    # Push space                      # ['R', 'R', 'R', '\n', 'R', ' ']
     J   # Join stack                      # ['RRR\nR ']
      û  # Palindromize ("abc" -> "abcba") # ['RRR\nR R\nRRR']
         # Implicit output                 # []

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Pyth , 11 Bytes

jc++K*z4dK3

Probieren Sie es online!

Erläuterung:

jc++K*z4dK3    expects a single char as input

j              joins on new line
 c        3    chops array into 3 sized pieces
  +            joins +K*z4d and K
   +           joins K*z4 and d
    K          initialize variable K as *z4
     *z4       duplicate the input 4 times
        d      variable initialized to string " "
         K     calls variable K, in this case *z4

> <> , 24 23 Bytes

i:o:o:oao:o84*o:a0!.<o$

Probieren Sie es online!

Swift3, 50 Bytes

[1,2,3].map{$0==2 ? print(c+" "+c) : print(c+c+c)}

Hierbei wird der ternäre Operator verwendet, um je nach Zeile unterschiedliche Zeichenfolgen zu drucken.

Probieren Sie es online aus

V , 8 Bytes

x3p2Ùlr 

Probieren Sie es online!

C #, 50 Bytes

a=>Console.Write(a+a+a+"\n"+a+" "+a+"\n"+a+a+a);

Testfall:

var f = new Action<string>(
a=>Console.Write(a+a+a+"\n"+a+" "+a+"\n"+a+a+a);
);
f("#");

Vim, 9 Tastenanschläge

Vorausgesetzt, das Eingabezeichen ist in einem Puffer vorhanden, macht vim dies unkompliziert

x3pY2plr<space>

Wahrscheinlich gibt es hier einige Magic Vim-Befehle (es scheint immer welche zu geben), daher sind Verbesserungsvorschläge willkommen. Nur ein Tastendruck hinter V!

Z80- oder 8080-Baugruppe, 21 Byte Maschinencode

Angenommen, ein speicherzugeordnetes E / A-Gerät:

              Z80 8080
3A xx xx ld a, (Eingabe) lda-Eingabe; Eingabezeichen holen
11 0A 20 ld de, 200ah lxi d, 200ah; Leerzeichen & Zeilenumbruch
21 yy yy ld hl, Ausgabe lxi h, Ausgabe; Ausgabeadresse abrufen
77 ld (hl), a mov m, a; Ausgabezeichen * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
73 ld (hl), e mov m, e; Ausgabe Newline
77 ld (hl), a mov m, a; Ausgabezeichen
72 ld (hl), dmovm, d; Ausgaberaum
77 ld (hl), a mov m, a; Ausgabezeichen
73 ld (hl), e mov m, e; Ausgabe Newline
77 ld (hl), a mov m, a; Ausgabezeichen * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
76 halt hlt; oder C9 ret

Kein Dolmetscher nötig!

Hexdump:

0000: 3A 00 FF 11 0A 20 21 01 FF 77 77 77 73 77 72 77
0010: 73 77 77 77 76

Dabei ist die Eingabeadresse auf FF00h und die Ausgabeadresse auf FF01h abgebildet. Die tatsächlichen Adressen hängen von der tatsächlichen Hardware ab. Dies setzt natürlich voraus, dass die E / A speicherabgebildet ist. Wenn es sich um eine E / A-Zuordnung handelt, werden mehrere zusätzliche Bytes benötigt, da die E / A-Anweisungen für Z80 und 8080 jeweils aus zwei Bytes bestehen. Dies setzt auch voraus, dass das Ausgabegerät 0Ah als Zeilenumbruch interpretiert und keinen CR (0Dh) benötigt, der dem Programm zusätzliche 4 Bytes hinzufügt.

J-Uby , 22 20 Bytes

-2 Bytes dank @Jordan

:tr&"...
. .
..."&?.

Erläuterung

String#trist Rubys zeichenweise Ersetzungsmethode. Das erste &bindet :tran "...\n. .\n..."und das zweite trifft teilweise '.'auf es zu. Tatsächlich ist dies->s{"...\n. .\n...".tr('.',s)}