¡Intenta hacer un cuadrado!

20

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.

code-golf  string  ascii-art 
— Luc H
fuente
2
El hecho de que el tamaño sea fijo permite cierta optimización. Las respuestas del desafío vinculado probablemente no serán competitivas aquí. Así que no creo que sea un duplicado
— Luis Mendo
12
Yo fui quien votó en contra, por ser un desafío simple y aburrido. Normalmente soy fanático de los desafíos fáciles, ya que son un buen lugar para que los nuevos golfistas comiencen, pero esto se siente demasiado fácil.
— Shaggy
32
@Ayoungcoder Es una razón perfectamente válida para rechazar un desafío.
— Wheat Wizard
2
@ Shaggy: en términos de dificultad, hay dificultades para escribir el programa y dificultades para jugar golf. Este programa es fácil de escribir, pero no estoy tan seguro de que sea fácil jugarlo.
55
En mi opinión, este es un buen desafío para las personas que recién comienzan con el golf de código. Es bueno tener una mezcla de dificultades. La sobrecarga en cualquier tipo será en detrimento de alguna parte de la comunidad. Entonces, me alegro de que este desafío haya sido escrito.
— isaacg

Respuestas:

30

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
— Neil
fuente
3
Siento que esto es trampa ...> _>
— HyperNeutrino
14
Luego, por supuesto, Ｂ³Ｓpara engañar a la mierda viva de esto.
— Urna mágica de pulpo
1
¿Por qué esto sería trampa? @carusocomputing y Neil su respuesta me parece correcto
— Luc H
1
@Ayoungcoder "hacer trampa" como en "parece barato" no como en "trampa literal"; el código tiene una función integrada para "imprimir una caja de dimensiones n usando el carácter s", el código más corto para este desafío es: 1. Leer la entrada. 2. Definir dimensión. 3. Cuadro de impresión. La respuesta a este desafío lógicamente no será inferior a 2 bytes si la entrada es implícita.
— Magic Octopus Urn
2
@carusocomputing Ah, la ironía: el comportamiento cuadrado implícito me molestó en mi respuesta para visualizar el algoritmo euclidiano nuevamente .
— Neil
19

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

— Barra
fuente
¿Cómo agrega esto los caracteres a la línea media? ¿Podría explicar la respuesta por favor?
— Notts90
1
@ Notts90 agregó una explicación c:
— Rod
gracias no sabía .join podría iterar una cadena.
— Notts90
Esto también funciona en Python 3. Muy guay por cierto. (Además, usando el mismo método 3*c+c.join('\n \n')+3*cempata a los 32.)
— Jonathan Allan
15

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
— Luis Mendo
fuente
1
¡eso fue rápido! no esperaba que llegara un byte de 5 tan rápido.
— Luc H
2
Idiomas de golf de código, ya sabes ... ¯ \ _ (ツ) _ / ¯
— Luis Mendo
11
Por supuesto, porque ¿por qué no tendrías un literal predefinido para [true true true; verdadero falso verdadero; true true true]
— PunPun1000
11
@ PunPun1000 Eso realmente se usa mucho (junto con convolución) ya que es la máscara de conectividad estándar 8 ( vecindario de Moore )
— Luis Mendo
3
@LuisMendo Eso es increíble, aprende algo nuevo aquí todos los días, no siempre sobre golf de código
— PunPun1000
13

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!

— Urna de pulpo mágico
fuente
— Oliver Ni
11

Python 3.6 , 33 bytes

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

Pruébalo en línea!

— Jonathan Allan
fuente
No hay problema. Parece que en realidad se está ejecutando 3.6.1; si intenta import sysy luego sys.versionen la respuesta, devuelve 3.6.1 en lugar de 3.5.2. No tengo idea de por qué dice 3.5.2 en la parte superior, ¡parece que se han equivocado allí!
— numbermaniac
2
Oh, jaja, un caso de "no siempre creas lo que lees" - ¡gracias!
— Jonathan Allan
9

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.

Entrada (puede ser cualquier cosa, no necesita ser una cadena) Código ingresado Resultado

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

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

— Lanudo
fuente
Creo que puede guardar un byte o dos almacenando el resultado de c+'\n'+cforma temporal.
— Neil
No importa, conté mal, todavía son 28 bytes.
— Neil
@Neil: Sí, hay un par de opciones para asignar cosas a una variable, pero todas tienen 28 bytes o más.
— Shaggy
6

Jalea , 8 bytes

1 byte gracias a Erik the Outgolfer.

x4,`Ks3Y

Pruébalo en línea!

— Monja permeable
fuente
Me preguntaba cómo hacer esto ... Tenía x4µ©;⁶;®œs3Y12 bytes porque no sabía cómo evitar que la repetición multiplicara todo mi paso intermedio, ¡pero bueno!
— HyperNeutrino
1
Ya sabes, hay un lugar Kpara hacer j⁶. Ah, y hay una forma rápida `de convertir una díada en una mónada usando el mismo argumento en ambos lados.
— Erik the Outgolfer
5

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!

— PunPun1000
fuente
5

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
— Erik el Outgolfer
fuente
4

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

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

— Luis Mendo
fuente
3

Rubí , 27 25 bytes

Guardado 2 bytes gracias a Level River St

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

Pruébalo en línea!

— Alex
fuente
cuando esté haciendo respuestas como esta, incluya también el pie de página como código porque no funciona sin él
— Luc H
@Ayoungcoder esta es una función anónima. puede asignarlo a una variable ( f=...) y luego llamarlo conf.call(...)
— Cyoce
1
Puede usar una nueva línea literal entre comillas en lugar de "\n"ahorrar 1 byte. Mejor uso, $/que es una variable especial establecida en nueva línea por defecto, ahorrando 2 bytes.
— Level River St
1 byte menos que la trsolución. buen trabajo
— Cyoce
3

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

+++
+ +
+++
— Zack C.
fuente
3

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!

— Oliver Ni
fuente
Oooo ... Inteligente, nunca pienso en cómo funciona palindromize en las nuevas líneas.
— Urna mágica del pulpo
ж¹ðJûpor 6 bytes.
— Urna de pulpo mágico
3

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
— cromático
fuente
Bienvenido a PPCG!
— Stephen
2

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

— Martyav
fuente
2

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("#");
— CHENGLIANG YE
fuente
ConsoleSystem.Console..
— Debe
2

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!

— algmyr
fuente
Estoy bastante seguro de que esto es lo más corto posible. ¡Buena respuesta!
— DJMcMayhem
2

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.

— Dan Howell
fuente
Bienvenido a Codegolf.stackexchange, aunque parece que tienes todo bajo control, lee el centro de ayuda y la lista de preguntas frecuentes. Buen primer post
— Rohan Jhunjhunwala
¿Puedes proporcionar un hexdump de tu código?
— CalculatorFeline
Los bytes hexadecimales están en la primera columna, pero si quieres un hexdump "puro", lo he agregado.
— Dan Howell
2

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

— Cyoce
fuente
¿ :trFuncionaría tan bien como :gsubaquí?
— Jordan
@ Jordan sí, gracias!
— Cyoce
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.