Tarea

Dado un carácter imprimible que no sea un espacio en blanco, haga una representación cuadrada de 3x3 de esa entrada. Por ejemplo, si la entrada es #, entonces la salida es:

###
# #
###

Reglas

• El formato de salida es estricto, aunque se permite una nueva línea final. Significa que se requiere el espacio en el medio, y también que se requieren los dos caracteres de nueva línea que separan las tres líneas.

Casos de prueba

Entrada: #

Salida:

###
# #
###

Entrada: A

Salida:

AAA
A A
AAA

Entrada: 0

Salida:

000
0 0
000

Tanteo

Este es el código de golf . La respuesta más corta en bytes gana.

Carbón , 5 3 bytes

Ｂ³Ｓ

Pruébalo en línea! Editar: Ahorró 40% gracias a @carusocomputing. Explicación:

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

Zanahoria , 11 bytes

###
# #
###

Pruébalo en línea!

El programa está en modo intercalación, donde #se reemplazan los s con la entrada.

Python 2 , 32 bytes

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

Pruébalo en línea!
Para s='a': el medio s+'\n \n'+sgenera a\n \nay lo s.joinconvierte (las negrillas son las que agregan), porque acepta una cadena como iterable, luego se rodea con los dos caracteres faltantesaa\na a\naaa.join.join

MATL , 5 bytes

3Y6*c

Pruébalo en línea!

Explicación

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ô»

Pruébalo en línea!

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                   |

Idea original usando 30 como número binario (sin terminar, alguien más intente esto en otro idioma):

05AB1E , 12 bytes

30bûTIð«‡3ô»

Pruébalo en línea!

Python 3.6 , 33 bytes

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

Pruébalo en línea!

RPL (Reverse Polish Lisp) , 60 caracteres

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

(Tenga en cuenta que "→" es un solo carácter en la HP48 y las calculadoras compatibles)

Representaría visualmente lo que quieres al tener tres elementos en la pila:

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

Si insiste en devolverlo como una cadena, también debe agregar los caracteres de nueva línea y combinar las cadenas, dejadas como ejercicio para el probador siguiente.

Explicación:

• →STR: Convierte el último objeto de la pila en una cadena. (Por lo tanto, la entrada puede ser cualquier cosa, por ejemplo, un número).
• 1 4: Empuje el número 1y 4hacia la pila.
• START [...] NEXT: Como un bucle for pero sin acceso a la variable de contador. Toma dos números de la pila (aquí, solo hemos presionado 1y 4) y ejecuta el código [...]las veces correspondientes (aquí, cuatro veces).
• DUP: Duplica la última entrada en la pila.
• " ": Empuje la cadena (es decir, la cadena con un espacio en blanco) a la pila.
• +: Tome dos objetos de la pila y devuélvalos agregados, para cadenas: Concatenados
• 4: Empuja el número 4a la pila.
• ROLLD: Toma el último elemento (aquí: 4que acabamos de empujar) de la pila y tira el siguiente elemento tan abajo de la pila como lo especifica el número que acabamos de tomar de la pila.
• SWAP: Intercambia los dos últimos elementos de la pila.
• 2: Empujar 2a la pila.
• PICK: Toma un elemento (aquí: el 2que acabamos de empujar a la pila), lo interpreta como un número n y copia el enésimo elemento de la pila.

JavaScript, 28 bytes

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

Intentalo

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>

Jalea , 8 bytes

1 byte gracias a Erik the Outgolfer.

x4,`Ks3Y

Pruébalo en línea!

Java 7, 56 55 bytes

-1 Gracias a Leaky Nun por señalar el espacio que perdí

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

Simplemente reemplaza los puntos con el carácter dado, para la entrada #:

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

Pruébalo en línea!

PHP, 32 bytes

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

Pruébalo en línea!

sed, 28 18 bytes

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

Pruébalo en línea!

Brain-Flak , 76 70 + 1 = 71 bytes

Requiere la -cbandera

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

Pruébalo en línea!

Pyth, 7 bytes

jc3.[9d

Prueba esto en línea.

Explicación:

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

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

Pruébalo en línea!

Esto es 58 bytes de +1byte de código para el -cindicador que permite la entrada y salida ASCII.

Explicación:

(((
   (
    (
     (

      #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

¡Ahorró 2 bytes gracias a 2501!

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

Pruébalo en línea! tiene una nueva línea al final

Python 3 , 34 bytes

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

Pruébalo en línea!

Octava , 36 bytes

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

Pruébalo en línea!

Explicación

Esto crea una matriz de caracteres 3x3 con el carácter de entrada repetido y establece su quinta entrada en orden de columna principal (es decir, su centro) en 32(ASCII para el espacio).

Pyke , 5 bytes

dQA.X

Pruébalo en línea!

Rubí , 27 25 bytes

Guardado 2 bytes gracias a Level River St

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

Pruébalo en línea!

Brainfuck, 40 bytes

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

Pruébalo en línea! Requiere una implementación que pueda acceder a la izquierda de la posición inicial.

Ver también: la respuesta mental de Graviton que tiene un enfoque diferente (pero es más largo).

Explicación:

Brainfuck puede hacer muchos trucos geniales con su conjunto de instrucciones limitado. Desafortunadamente, esta respuesta no usa ninguno de ellos, porque es más barato (en términos de bytes) simplemente codificar todo.

+++++[->++<<++++++>]                         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| ###

# = carácter de entrada, _ = espacio (ASCII 32), \ n = nueva línea (ASCII 10)

Resultados en este hermoso cuadro (para la entrada '+'):

+++
+ +
+++

05AB1E , 7 6 bytes

-1 byte gracias a carusocomputing.

ж¹ðJû

Explicación:

         # 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                 # []

Utiliza la codificación CP-1252 . Pruébalo en línea!

Pyth , 11 bytes

jc++K*z4dK3

Pruébalo en línea!

Explicación:

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$

Pruébalo en línea!

Swift3, 50 bytes

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

Esto usa el operador ternario para imprimir diferentes cadenas, dependiendo de la fila.

Pruébalo en línea

V , 8 bytes

x3p2Ùlr 

Pruébalo en línea!

C #, 50 bytes

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

Caso de prueba:

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

Vim, 9 pulsaciones de teclas

Suponiendo que la entrada char está presente en un búfer, vim hace que esto sea sencillo

x3pY2plr<space>

Probablemente hay algunos comandos mágicos vim de uso aquí (siempre parece haber algunos), por lo que las sugerencias de mejora son bienvenidas. ¡Solo una pulsación de tecla detrás de V!

Conjunto Z80 u 8080, código de máquina de 21 bytes

Suponga que un dispositivo de E / S mapeado en memoria:

              Z80 8080
3A xx xx ld a, (entrada) entrada lda; obtener el carácter de entrada
11 0A 20 ld de, 200ah lxi d, 200ah; espacio y nueva línea
21 aa aa ld hl, salida lxi h, salida; obtener dirección de salida
77 ld (hl), a mov m, a; carácter de salida * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
73 ld (hl), e mov m, e; salida nueva línea
77 ld (hl), a mov m, a; carácter de salida
72 ld (hl), d mov m, d; espacio de salida
77 ld (hl), a mov m, a; carácter de salida
73 ld (hl), e mov m, e; salida nueva línea
77 ld (hl), a mov m, a; carácter de salida * 3
77 ld (hl), a mov m, a
77 ld (hl), a mov m, a
76 alto alto; o C9 ret

¡No se necesita intérprete!

Hexdump:

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

donde la dirección de entrada está en FF00h y la dirección de salida está asignada en FF01h. Las direcciones reales dependerán del hardware real. Por supuesto, esto supone que la E / S está mapeada en memoria. Si se asigna E / S, tomaría varios bytes adicionales porque las instrucciones de E / S Z80 y 8080 son dos bytes cada una. Esto también supone que el dispositivo de salida interpreta 0Ah como una nueva línea y no requiere un CR (0Dh) que agregaría 4 bytes adicionales al programa.

J-uby , 22 20 bytes

-2 bytes gracias a @Jordan

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

Explicación

String#tres el método de reemplazo de caracteres de Ruby. El primero& une :tra "...\n. .\n...", y el segundo se aplica parcialmente '.'a él. Efectivamente, esto es->s{"...\n. .\n...".tr('.',s)}