Tente fazer um quadrado!

20

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.

code-golf  string  ascii-art 
— Luc H
fonte
2
O fato de o tamanho ser fixo permite alguma otimização. As respostas do desafio vinculado provavelmente não serão competitivas aqui. Portanto, não acho que seja uma duplicata.
— Luis Mendo
12
Fui eu quem votou mal, por ser um desafio simples e chato. Normalmente sou fã de desafios fáceis, pois eles são um bom lugar para os novos jogadores começarem, mas isso parece fácil demais.
— Shaggy
32
@ YoungCoder É uma razão perfeitamente válida para rebaixar um desafio.
— Assistente de trigo
2
@ Shagy: Em termos de dificuldade, há dificuldade para escrever o programa e dificuldade para jogar golfe no programa. Este programa é fácil de escrever, mas não tenho tanta certeza de que seja fácil jogar golfe nele.
5
Na minha opinião, este é um bom desafio para as pessoas que estão apenas começando no golfe com código. É bom ter uma mistura de dificuldades. Sobrecarregar qualquer tipo será em detrimento de alguma parte da comunidade. Então, estou feliz que este desafio tenha sido escrito.
— Isaacg 13/05

Respostas:

30

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
— Neil
fonte
3
Eu sinto que isso é batota ...> _>
— HyperNeutrino
14
Então, é claro, Ｂ³Ｓpara enganar a porcaria viva disso.
— Magic Octopus Urn
11
Por que isso seria trapaça? @carusocomputing e neil seu anwser parece certo para mim
— Luc H
11
@Youngcoder "trapaça" como em "parece barato" não como em "trapaça literal"; o código possui um built-in para "imprimir uma caixa de dimensões n usando caracteres s", o código mais curto para esse desafio é: 1. Leia a entrada. 2. Defina a dimensão. 3. Caixa de impressão. A resposta para esse desafio logicamente não será inferior a 2 bytes se a entrada estiver implícita.
— Magic Octopus Urn
2
@carusocomputing Ah, a ironia - o comportamento implícito do quadrado me incomodou na minha resposta ao Visualize o algoritmo euclidiano novamente .
— 1111 Neil
19

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

— Cajado
fonte
Como isso adiciona os caracteres à linha do meio? Você poderia explicar a resposta, por favor?
— Notts90
11
@ Notts90 adicionou uma explicação c:
— Rod
obrigado eu não sabia que .join poderia iterar uma string.
— Notts90
Isso funciona também em Python 3. BTW muito legal. (Além disso, usando o mesmo método 3*c+c.join('\n \n')+3*cempata em 32).
— Jonathan Allan
15

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
— Luis Mendo
fonte
11
aquilo foi rápido! não esperava que um byte de 5 bytes chegasse tão rápido.
— Luc H
2
Linguagens de código-golfe, você sabe ... ¯ \ _ (ツ) _ / ¯
— Luis Mendo
11
Claro, porque por que você não teria um literal predefinido para [true true true; verdadeiro falso verdadeiro; verdadeiro verdadeiro verdadeiro]
— PunPun1000
11
@ PunPun1000 Isso é realmente muito usado (juntamente com convolução) como é o padrão 8-conectividade máscara ( neighboorhood Moore )
— Luis Mendo
3
@LuisMendo Isso é incrível, aprender algo novo por aqui todos os dias, não é sempre sobre golfe código
— PunPun1000
13

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!

— Urna de polvo mágico
fonte
— Oliver Ni
11

Python 3.6 , 33 bytes

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

Experimente online!

— Jonathan Allan
fonte
Sem problemas. Parece que está na verdade 3.6.1 sendo executado; se você tentar import syse depois sys.versionna repl, ele retornará 3.6.1 em vez de 3.5.2. Não faço ideia por que diz 3.5.2 no topo, parece que eles cometeram um erro lá!
— Numbermaniac #
2
Ah, haha, um caso de "nem sempre acredite no que lê" - obrigado!
— Jonathan Allan
9

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.

Entrada (pode ser qualquer coisa, não precisa ser uma string) Código inserido Resultado

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.
— Golar Ramblar
fonte
7

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>
Expandir snippet

— Shaggy
fonte
Eu acho que você pode salvar um byte ou dois armazenando o resultado de c+'\n'+cforma temporária.
— 1111 Neil
Não importa, calculei mal, ainda são 28 bytes.
— 1111 Neil
@ Neil: Sim, existem algumas opções para atribuir itens a uma variável, mas todas elas têm 28 bytes ou mais.
— Shaggy
6

Gelatina , 8 bytes

1 byte graças a Erik, o Outgolfer.

x4,`Ks3Y

Experimente online!

— Freira Furada
fonte
Fiquei me perguntando como fazer isso ... Eu tinha x4µ©;⁶;®œs3Y12 bytes porque não conseguia descobrir como evitar que a repetição multiplique todo o meu passo intermediário, mas é legal!
— HyperNeutrino
11
Você sabe, há um construto Kpara fazer j⁶. Ah, e é rápido `converter uma díade em mônada usando o mesmo argumento dos dois lados.
— Erik the Outgolfer
5

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!

— PunPun1000
fonte
5

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
— Erik, o Outgolfer
fonte
4

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
)))
— DJMcMayhem
fonte
3

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).

— Luis Mendo
fonte
3

Ruby , 27 25 bytes

Economizou 2 bytes graças ao Level River St

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

Experimente online!

— Alex
fonte
quando você está fazendo anwsers como esta, inclua também o rodapé como código porque ele não funciona sem
— Luc H
@ YoungCoder esta é uma função anônima. você pode atribuí-lo a uma variável ( f=...) e depois chamá-lo com #f.call(...)
— Cyoce
11
Você pode usar uma nova linha literal entre aspas, em vez de "\n"economizar 1 byte. Melhor ainda, $/que é uma variável especial definida como nova linha por padrão - economizando 2 bytes.
— Level River St
1 byte a menos que a trsolução. bom trabalho
— Cyoce
3

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 '+'):

+++
+ +
+++
— Zack C.
fonte
3

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!

— Oliver Ni
fonte
Oooo ... Inteligente, nunca penso em como o palindromize funciona em novas linhas.
— Magic Octopus Urn
ж¹ðJûpor 6 bytes.
— Magic Octopus Urn
3

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
— cromática
fonte
Bem-vindo ao PPCG!
— Stephen
2

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

— Martyav
fonte
2

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("#");
— CHENGLIANG YE
fonte
Você precisa qualificar totalmente o ConsoleieSystem.Console..
— TheLethalCoder
2

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!

— algmyr
fonte
Tenho certeza de que isso é o mais curto possível. Boa resposta!
— DJMcMayhem
2

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.

— Dan Howell
fonte
Bem-vindo ao Codegolf.stackexchange, embora pareça que você tem tudo sob controle, leia o centro de ajuda e a lista de perguntas frequentes. Bom primeiro post
— Rohan Jhunjhunwala 20/05
Você pode fornecer um hexdump do seu código?
— CalculadoraFeline
Os bytes hexadecimais estão na primeira coluna, mas se você quiser um hexdump "puro", eu o adicionei.
— Dan Howell
2

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)}

— Cyoce
fonte
Funcionaria :trtão bem quanto :gsubaqui?
— Jordânia
@ Jordan sim, obrigado!
— Cyoce 25/05
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.