Tarefa

Dado um caractere imprimível sem espaço em branco, faça uma representação quadrada de 3x3 dessa entrada. Por exemplo, se a entrada for #, a saída será:

###
# #
###

Regras

• O formato de saída é rigoroso, embora uma nova linha à direita seja permitida. Isso significa que o espaço no meio é necessário e também que os dois caracteres de nova linha que separam as três linhas são necessários.

Casos de teste

Entrada: #

Saída:

###
# #
###

Entrada: A

Saída:

AAA
A A
AAA

Entrada: 0

Saída:

000
0 0
000

Pontuação

Este é o código-golf . A resposta mais curta em bytes vence.

Carvão , 5 3 bytes

Ｂ³Ｓ

Experimente online! Editar: economizou 40% graças a @carusocomputing. Explicação:

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

Cenoura , 11 bytes

###
# #
###

Experimente online!

O programa está no modo de #sinal de intercalação, onde s são substituídos pela entrada.

Python 2 , 32 bytes

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

Experimente online!
Para s='a': o meio s+'\n \n'+sgera a\n \nae s.joinentrega (negrito s são os que adiciona), porque aceita uma sequência como iterável e, em seguida, é cercada pelos dois caracteres ausentesaa\na a\naaa.join.join

MATL , 5 bytes

3Y6*c

Experimente online!

Explicação

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

Experimente 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                   |

Idéia original usando 30 como um número binário (inacabado, alguém tenta isso em outro idioma):

05AB1E , 12 bytes

30bûTIð«‡3ô»

Experimente online!

Python 3.6 , 33 bytes

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

Experimente online!

RPL (Lisp polonês reverso) , 60 caracteres

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

(Observe que "→" é um caractere único na HP48 e calculadoras compatíveis)

Representaria visualmente o que você deseja, tendo três itens na pilha:

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

Se você insistir em devolvê-lo como uma sequência, será necessário adicionar os caracteres da nova linha e combinar as seqüências, deixadas como exercício para o próximo testador.

Explicação:

• →STR: Transforma o último objeto da pilha em uma sequência. (Portanto, a entrada pode ser qualquer coisa, por exemplo, um número.)
• 1 4: Empurre o número 1e 4para a pilha.
• START [...] NEXT: Como um loop for, mas sem acesso à variável do contador. Pega dois números da pilha (aqui, apenas pressionamos 1e 4) e executa o código [...]nos tempos correspondentes (aqui, quatro vezes).
• DUP: Duplique a última entrada na pilha.
• " ": Empurre a string (ou seja, a string com um espaço em branco) para a pilha.
• +: Pegue dois objetos da pilha e devolva-os juntos, para seqüências de caracteres: Concatenated.
• 4: Empurre o número 4para a pilha.
• ROLLD: Pega o último elemento (aqui: 4que acabamos de enviar) da pilha e rola o próximo elemento o mais abaixo possível, conforme especifica o número que acabamos de tirar da pilha.
• SWAP: Troca os dois últimos elementos da pilha.
• 2: Empurre 2para a pilha.
• PICK: Pega um elemento (aqui: O 2que acabamos de enviar para a pilha), interpreta como um número n e copia o enésimo elemento da pilha.

JavaScript, 28 bytes

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

Tente

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>

Gelatina , 8 bytes

1 byte graças a Erik, o Outgolfer.

x4,`Ks3Y

Experimente online!

Java 7, 56 55 bytes

-1 Obrigado a Leaky Nun por apontar o espaço que eu perdi

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

Simplesmente substitui os períodos pelo caractere fornecido, para a entrada #:

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

Experimente online!

PHP, 32 bytes

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

Experimente online!

sed, 28 18 bytes

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

Experimente online!

Flacidez cerebral , 76 70 + 1 = 71 bytes

Requer a -cbandeira

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

Experimente online!

Pitão, 7 bytes

jc3.[9d

Experimente isso online.

Explicação:

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

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

Experimente online!

São 58 bytes de +1byte de código para o -csinalizador que habilita a entrada e saída ASCII.

Explicação:

(((
   (
    (
     (

      #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

Economizou 2 bytes graças a 2501!

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

Experimente online! tem uma nova linha à direita

Python 3 , 34 bytes

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

Experimente online!

Oitava , 36 bytes

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

Experimente online!

Explicação

Isso cria uma matriz de caracteres 3x3 com o caractere de entrada repetido e define sua quinta entrada na ordem principal da coluna (ou seja, seu centro) como 32(ASCII para espaço).

Pyke , 5 bytes

dQA.X

Experimente online!

Ruby , 27 25 bytes

Economizou 2 bytes graças ao Level River St

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

Experimente online!

Brainfuck, 40 bytes

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

Experimente online! Requer uma implementação que possa acessar à esquerda da posição inicial.

Veja também: Resposta do cérebro de Graviton, que adota uma abordagem diferente (mas é mais longa).

Explicação:

O Brainfuck pode fazer muitos truques legais com seu conjunto de instruções limitado. Infelizmente, esta resposta não usa nenhuma delas, porque é mais barato (em termos de bytes) codificar apenas tudo.

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

# = caractere de entrada, _ = espaço (ASCII 32), \ n = nova linha (ASCII 10)

Resultados nesta linda caixa (para entrada '+'):

+++
+ +
+++

05AB1E , 7 6 bytes

-1 byte graças à carusocomputação.

ж¹ðJû

Explicação:

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

Usa a codificação CP-1252 . Experimente online!

Pitão , 11 bytes

jc++K*z4dK3

Experimente online!

Explicação:

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$

Experimente online!

Swift3, 50 bytes

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

Isso usa o operador ternário para imprimir seqüências diferentes, dependendo da linha.

Experimente online

V , 8 bytes

x3p2Ùlr 

Experimente online!

C #, 50 bytes

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

Caso de teste:

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

Vim, 9 pressionamentos de teclas

Assumindo que o char de entrada esteja presente em um buffer, o vim torna isso simples

x3pY2plr<space>

Provavelmente existem alguns comandos de uso do magic vim aqui (sempre parece haver alguns), portanto sugestões de melhoria são bem-vindas. Apenas um pressionamento de tecla atrás de V!

Montagem Z80 ou 8080, código de máquina de 21 bytes

Suponha um dispositivo de E / S mapeado para memória:

              Z80 8080
3A xx xx ld a, entrada lda (entrada); obter caractere de entrada
11 0A 20 ld de 200ah lxi d, 200ah; espaço e nova linha
21 aa aa aa ld hl, saída lxi h, saída; obter endereço de saída
77 ld (hl), a mov m, a; caractere de saída * 3
77 ld (hl), um mov m, um
77 ld (hl), um mov m, um
73 ld (hl), e mov m, e; nova linha de saída
77 ld (hl), a mov m, a; caractere de saída
72 ld (hl), d mov m, d; espaço de saída
77 ld (hl), a mov m, a; caractere de saída
73 ld (hl), e mov m, e; nova linha de saída
77 ld (hl), a mov m, a; caractere de saída * 3
77 ld (hl), um mov m, um
77 ld (hl), um mov m, um
76 hlt; ou C9 ret

Não é necessário nenhum intérprete!

Hexdump:

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

onde o endereço de entrada está em FF00h e o endereço de saída é mapeado em FF01h. Os endereços reais dependerão do hardware real. Obviamente, isso pressupõe que a E / S esteja mapeada na memória. Se for E / S mapeada, levaria vários bytes extras, porque as instruções de E / S Z80 e 8080 têm dois bytes cada. Isso também pressupõe que o dispositivo de saída interpreta 0Ah como uma nova linha e não requer um CR (0Dh) que adicionaria 4 bytes extras ao programa.

J-uby , 22 20 bytes

-2 bytes graças a @Jordan

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

Explicação

String#tré o método de substituição de caracteres do Ruby. Os primeiros &se liga :tra "...\n. .\n...", e o segundo se aplica parcialmente '.'a ele. Efetivamente, isso é->s{"...\n. .\n...".tr('.',s)}