¡Intenta hacer un cubo!


16

Basado en esto: ¡Hazme un cuadrado!

Necesita dar salida a esto:

  ####
 # # #
###  #
# # #
####

Donde "#" se reemplaza con la entrada.

Si ingresa "A", debería obtener

  AAAA
 A A A
AAA  A
A A A
AAAA

Si ingresa "&", debería obtener

  &&&&
 & & &
&&&  &
& & &
&&&&

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.


55
Bueno, esto es algo similar, aunque al menos no es una respuesta de 3 bytes en Carbón esta vez ...
Neil

1
¿Pueden las dos últimas líneas tener espacios iniciales y el resultado puede tener nuevas líneas iniciales?
dzaima

3
B³S‖O↗Sin embargo, es muy posible que esté cerca de una respuesta de 10 bytes en el carbón ... Simplemente no conozco el idioma lo suficientemente bien como para hacerlo, realmente debe haber una página como esta, pero para el carbón.
Urna de pulpo mágico

55
@AAlex Sandbox
xnor

66
No veo cómo se trata de un imbécil de la plaza
Luis Mendo

Respuestas:


19

Zanahoria , 31 bytes

  ####
 # # #
###  #
# # #
####

#s son reemplazados por la entrada.

Básicamente un puerto de esta respuesta , a este problema.


40
parece que le llevó horas jugar golf ...
Cyoce

@KritixiLithos 200 rep porque hiciste un lenguaje genial, esto no parece justo xD
Stephen

13

05AB1E , 16 15 bytes

ð‚•nxвΛ•2вèJ6ô»

Pruébalo en línea!

Explicación

ð‚                # push the list [<input>,<space>]
  •nxвΛ•          # push the number 816342339
        2в        # convert to list of base 2 digits
          è       # index into the the 2-char string with this list
           J      # join to string
            6ô    # split into pieces of length 6
              »   # join on newlines

1
¿Puede codificar la nueva línea dentro de la lista / número para guardar los últimos 3 bytes?
Rod

@ Rod Eso sería un número mucho mayor, 6 bytes como mínimo, más un byte adicional o dos para incluir la nueva línea en la lista ...
ETHproductions

@ Rod: Podrías hacer algo como esto . Desafortunadamente eso resulta un poco más largo. Buena idea sin embargo.
Emigna

1
•nxвΛ•bTRð¹ì‡6ô»... los ritmos tuyos transliteran ligeramente, solo debido a los requisitos de pedido; Si pudiera encontrar una manera de tomar implícitamente la entrada y generar la cadena 01en 1 byte, esta sería una solución de 13/14 bytes.
Magic Octopus Urn

1
@carusocomputing •nxвΛ•bT𹫇6ô»o ð«T•nxвΛ•br‡6ô»tiene la misma longitud.
Emigna

10

Cubix , 62 bytes

./v<.o;.@?/;w.w;i:::::NrSs::SrSuUS::sN::rS:r:srNr:SrSsNs:::SSv

Pruébalo en línea! y mira al intérprete!

Esto cabe en un cubo de 4:

        . / v <
        . o ; .
        @ ? / ;
        . . w ;
i : : : : : N r S s : : S r S u
U S : : s N : : r S : r : s r N
r : S r S s N s : : : S S v . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

No soy muy bueno manipulando la dirección del puntero de instrucciones, por lo que continuaré intentando jugar golf. Tanto esto como mi respuesta aquí se basan en el "¡Hola, mundo!" programa de ejemplo que utiliza ./v.o;@?/(en un cubo de 3) para imprimir y reventar los caracteres en la pila de forma recursiva, de modo que el resto del código simplemente empuja los caracteres hacia la pila en el orden correcto.

Ahora he hecho un cubo sobre un cubo, así puedo descansar tranquilo (y hacer mi trabajo real).


9

SOGL , 13 10 bytes

Βū&⁵'r⁹‘6n

Explicación:

Βū&⁵'r⁹‘    push "  ŗŗŗŗ ŗ ŗ ŗŗŗŗ  ŗŗ ŗ ŗ ŗŗŗŗ", where "ŗ" is replaced with input
        6n  split into lines of length 6

1
¿Cómo es esto sentado a 0? Probablemente debido a la falta de un TIO ._. +1
Urna de pulpo mágico

Creo que habrá (ojalá) la mayoría de las actualizaciones de actualización más 1 y luego pensaré en algo en línea
dzaima

66
¿Hijo de un idioma de golf?
ETHproductions

@ETHproductions lol
dzaima

Lenguaje de golf orientado a cuerdas
a'_ '23 de

9

MATL , 13 10 bytes

Gracias a Conor O'Brien por eliminar 3 bytes y por mostrarme que no se pueden imprimir en Octave.

El código contiene caracteres no imprimibles. Pruébalo en línea!

Explicación

'....'   % Push 5-char string (contains unprintables). Each char encodes a row
         % of the desired pattern
B        % Convert to binary. Gives a 5×6 binary matrix with the pattern
*        % Implicit input. Multiply element-wise (converts input to ASCII code)
c        % Convert to char. Implicitly display. Char 0 is shown as space

Puede hacer estos 10 bytes si está de acuerdo con los no imprimibles. Pruébalo en línea!
Conor O'Brien

@ ConorO'Brien Hola, gracias! No estaba seguro de que Octave estuviera bien con esos ... ¿cómo los escribiste?
Luis Mendo

Bueno, honestamente tomé los números, los convertí en hexadecimal y luego lo hice echo 0f15392a3c|xxd -r -p|clip. En windows, clipes el portapapeles. Luego los acabo de pegar: P (si estás en una línea de comando, también lo está ^O^U)
Conor O'Brien

@ ConorO'Brien Eso está muy por encima de mi cabeza. Realmente deberías publicar eso como tu respuesta
Luis Mendo

Utiliza la misma táctica que la tuya, simplemente eliminando la necesidad del módulo 64 usando los valores directamente.
Conor O'Brien


6

Japt , 20 bytes

"OUyj|"®c ¤Åd0S1U +R

¡Pruébalo en línea!

No está mal para un idioma sin compresión incorporada (bueno, excepto la compresión de cadenas de letras minúsculas) ...

Explicación

En binario, los cinco caracteres en la cadena son:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

Corta la inicial 1de cada uno, y obtienes el patrón para el cubo.

"OUyj|"®   c ¤  Å  d0S1U +R
"OUyj|"mZ{Zc s2 s1 d0S1U +R}  // Expanded
                              // Implicit: U = input string
"OUyj|"mZ{                 }  // Replace each character Z in this string with this function:
          Zc                  //   Take the char-code of Z.
             s2               //   Convert to a binary string.
                s1            //   Slice off the first character (always a "1").
                   d0S1U      //   Replace "0"s with spaces and "1"s with the input.
                         +R   //   Append a newline.
                              // Implicit: output result of last expression

Intenté un enfoque basado en plantillas ( llse puede comprimir), pero es 11 bytes más largo.
Lucas

Agradable. ¡Había reducido a 23 bytes antes de darme cuenta de que había hecho una bola!
Shaggy

6

LOLCODE, 202 170 bytes

I HAS A c
GIMMEH c
VISIBLE"  "AN c AN c AN c AN c AN":) "AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN"  "AN c AN":)"AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN c

En LOLCODE, no mucho para jugar golf ...

Esto establece la variable cen la entrada y crea una cadena concatenada gigante que incluye :)nuevas líneas. Eso es todo.


expected HAI at: I tio.run/nexus/…
eush77

Además, se VISIBLEconcatena implícitamente, por lo que puede eliminar SMOOSH tio.run/nexus/lolcode#@@/…
eush77

Para su primera cosa, hay algunos intérpretes que no requieren HAI o KTHXBYE, por ejemplo, REPL.it. A tu segunda cosa, ¡gracias!
OldBunny2800

5

Sed, 40 caracteres

s/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/

Casi haciendo trampa ya que la descripción del desafío lo contenía casi literalmente.

Ejecución de muestra:

bash-4.4$ sed 's/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/' <<< 'C'
  CCCC
 C C C
CCC  C
C C C
CCCC

Pruébalo en línea!



5

Conjunto Z80, código de máquina de 37 bytes

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

; ¡NO INGRESE UN ESPACIO o entrará en espacios de impresión de bucle infinito y nuevas líneas!

3A xx xx ld a, (entrada); obtener el carácter de entrada
11 0A 20 ld de, 200ah; espacio y nueva línea
21 aa aa ld hl, salida; obtener dirección de salida
4F ld c, a; poner carácter en c
lazo:
72 ld (hl), d; espacio de salida * 2 | carácter de salida * 2
72 ld (hl), d
77 ld (hl), a; carácter de salida | carácter de salida
71 ld (hl), c; carácter de salida * 2 | espacio de salida * 2
71 ld (hl), c
77 ld (hl), a; carácter de salida | carácter de salida
73 ld (hl), e; salida nueva línea | salida nueva línea
72 ld (hl), d; espacio de salida | carácter de salida
71 ld (hl), c; carácter de salida | espacio de salida
72 ld (hl), d; espacio de salida | carácter de salida
71 ld (hl), c; carácter de salida | espacio de salida
72 ld (hl), d; espacio de salida | carácter de salida
B9 cp c; establecer cero bandera primera vez | claro segunda vez
20 06 jr nz, fin; saltar al final
77 ld (hl), a; carácter de salida
73 ld (hl), e; salida nueva línea
4A ld c, d; poner espacio en c
57 dd, a; poner carácter en d
28 FB jr z, bucle; bucle a la segunda vez
final:
73 ld (hl), e; salida nueva línea
77 ld (hl), a; carácter de salida * 4
77 ld (hl), a
77 ld (hl), a
77 ld (hl), a
76 alto; o C9 ret

4

V , 27 bytes

4äl2>>Äyvho3pÄÙ3älWx<<3Îd^

Pruébalo en línea!

Hexdump:

00000000: 34e4 6c32 3e3e c479 7668 6f1b 3370 c4d9  4.l2>>.yvho.3p..
00000010: 33e4 6c57 783c 3c33 ce64 5e              3.lWx<<3.d^

Estoy bastante seguro de que puede reemplazar o<esc>con soloï
Kritixi Lithos

4

PHP, 72 bytes

Hice este solo por diversión, ya que ya hay una mejor respuesta de PHP.

for($i=0;$i<27;)echo('00'.decbin(64349871))[$i]?$argn:' ',++$i%6?'':'
';

El cubo se dibuja obteniendo el valor binario de 64349871, concatenado por '00'.
Esto devuelve lo siguiente:

0011110101011110011010101111

Cada sexto carácter, estoy generando una nueva línea, lo que resulta en esto:

001111
010101
111001
101010
1111

Y, en lugar de mostrar 0, muestra un espacio, que se verá así:

  1111
 1 1 1
111  1
1 1 1 
1111

4

Carbón , 17 16 bytes

SβGH7+↗→³β→G↓↙³β

Pruébalo en línea! El enlace es a la versión detallada del código. Más largo de lo que quería, porque el "cubo" es un poco más ancho que alto o profundo. Afortunadamente, algunos de los caracteres multidireccionales funcionan con PolygonHollow, lo que me ahorra 3 bytes. Editar: guardado un byte adicional usando + en lugar de T ↑. Explicación:

Sβ          Input the character
GH7+↗→³β    Draw the left half. 7 becomes ←↙ and + becomes →↓←↑.
→           Move right one character.
G↓↙³β       Draw the right half.

En el momento del desafío, la qvariable no funcionaba en modo detallado, de lo contrario podría haber creado esta versión de 14 bytes:

GH7+↗→³θ→G↓↙³θ

Pruébalo en línea!


3

Apilado , 31 bytes

' '\+$'9*<'#.2 tb[6 dpad]map#

Pruébalo en línea!

Aquí hay un hexdump:

λ xxd try-to-make-a-cube.stk
00000000: 2720 275c 2b24 270f 1539 2a3c 2723 2e32  ' '\+$'..9*<'#.2
00000010: 2074 625b 3620 6470 6164 5d6d 6170 23     tb[6 dpad]map#

Esto convierte una matriz de caracteres en binario, rellena cada fila a la longitud 6y la indexa de acuerdo con la cadena' ' input +



2

JS (ES6), 64 60 52 bytes

i=>`  ####
 # # #
###  #
# # #
####`.replace(/#/g,i)

¿Se puede mejorar esto?

i=>`  ${y=i+i+i+i}
 # # #
###  #
# # #
${y}`.replace(/#/g,i)

1
y=i+i+i+ies más corto quey=i.repeat(4)
Stephen

2
... y ####es aún más corto.
Arnauld

1
En realidad, todo es más corto sin plantillas: Fiddle
Stephen

1

C (gcc) , 90 84 bytes

i;v;f(g){for(i=32;i--;)putchar((v="####*@#@#@#*#@@###*#@#@#@*####@@"[i])&1?g:v-32);}

Pruébalo en línea! Define una función fque toma un personaje g. Lástima que codificar la tabla directamente es más corto ...

Versión anterior, 90 bytes

(Todavía estoy tratando de jugar golf)

Tratando de tener solo uno putchar, pero idk. Hay no imprimibles, así que aquí está el hexdump:

λ xxd try-to-make-a-cube.c
00000000: 693b 6a3b 6628 6729 7b63 6861 722a 6b3d  i;j;f(g){char*k=
00000010: 220f 1539 2a3c 223b 666f 7228 693d 303b  "..9*<";for(i=0;
00000020: 693c 353b 7075 7463 6861 7228 3130 292c  i<5;putchar(10),
00000030: 692b 2b29 666f 7228 6a3d 3332 3b6a 3b6a  i++)for(j=32;j;j
00000040: 2f3d 3229 7075 7463 6861 7228 6b5b 695d  /=2)putchar(k[i]
00000050: 266a 3f67 3a33 3229 3b7d                 &j?g:32);}

Esto codifica el cubo en una tabla de búsqueda binaria, donde un 1bit representa la entrada y un 0bit representa un espacio. Pruébalo en línea!


Puede reducir algunos bytes para 81 bytes .
Gastropner

El no imprimible se puede exprimir a 73 bytes .
Gastropner

1

Brain-Flak , 217 bytes

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

Pruébalo en línea!

Waaaaay demasiado tiempo.


1

Swift - 82 bytes + Foundation (18 bytes)?

var f={"  ####\n # # #\n###  #\n# # #\n####".replacingOccurrences(of:"#",with:$0)}

De forma predeterminada, los proyectos Xcode-Swift sí lo tienen Whole-Module Optimization, por lo que import Foundationno es necesario para esta sencilla función tipo lambda. Sin embargo, ejecutarlo en entornos en línea lo requiere, lo que puede agregar 18 bytes.

¡Echale un vistazo!



0

CJam, 23 bytes

"pjFUC"{i2b(;}%rS+ff=N*

Siento que todavía puedo jugar golf esto.

"pjFUC" e# String literal:          │ "pjFUC"
{       e# For each:                │ 'p
  i     e#   Get code point:        │ 112
  2b    e#   To binary:             │ [1 1 1 0 0 0 0]
  (;    e#   Delete first:          │ [1 1 0 0 0 0]
}%      e# End                      │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]]
r       e# Read token:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&"
S       e# Push space:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&" " "
+       e# Concatenate:             │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "& "
ff=     e# Vectorized array lookup: │ ["  &&&&" " & & &" "&&&  &" "& & & " "&&&&  "]
N*      e# Join with newlines       │ "  &&&&
        e#                          │   & & &
        e#                          │  &&&  &
        e#                          │  & & & 
        e#                          │  &&&&  "
e# Implicit output

0

dc , 70 bytes

Codifica la secuencia de forma bastante directa, con una optimización menor:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

Pruébalo en línea!


Llevado a un extremo (no muy golfista), 145 bytes:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

Pruébalo en línea!

Esto calcula A*x+B, donde Acodifica las posiciones del carácter de entrada y Bcodifica todo el resto:

A = 256 0 + 256 1 + 256 2 + 256 3 + 256 5 + 256 7 + 256 9 + 256 11 + 256 14 + 256 15 + 256 16 + 256 18 + 256 20 + 256 22 + 256 25 + 256 26 + 256 27 + 256 28

B = 10 × 256 4 + 32 × 256 6 + 32 × 256 8 + 10 × 256 10 + 32 × 256 12 + 32 × 256 13 + 10 × 256 17 + 32 × 256 19 + 32 × 256 21 + 32 × 256 23 + 10 × 256 24 + 32 × 256 29 + 32 × 256 30

P El comando imprime el número resultante como una secuencia de bytes.



0

Lote de Windows, 79 bytes

@echo   %1%1%1%1
@echo  %1 %1 %1
@echo %1%1%1  %1
@echo %1 %1 %1
@echo %1%1%1%1

Char especial seguro, 97 bytes:

@echo   ^%1^%1^%1^%1
@echo  ^%1 ^%1 ^%1
@echo ^%1^%1^%1  ^%1
@echo ^%1 ^%1 ^%1
@echo ^%1^%1^%1^%1

¿Se pueden utilizar .. %1%1%1%1\n %1 %1 %1...
avances de

Los
avances de

No podía recordar si estaban o no y no estaban en condiciones de probar :)
TheLethalCoder

Lo siento, estoy confundido, ¿puedes repetir?
stevefestl

No podía recordar si usted podría utilizarlos o no, y no pude prueba en el momento le comenté lo que dejó el comentario por lo que todavía tendría la idea
TheLethalCoder

0

Tcl, 60 bytes

proc c x {regsub . $x "  &&&&\n & & &\n&&&  &\n& & &\n&&&&"}
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.