Dibuja un teclado de teléfono artístico ASCII

8

Dibuje lo siguiente en la menor cantidad de bytes posible:

-------------------------
|       |  ABC  |  DEF  |
|   1   |   2   |   3   |
-------------------------
|  GHI  |  JKL  |  MNO  |
|   4   |   5   |   6   |
-------------------------
| PQRS  |  TUV  | WXYZ  |
|   7   |   8   |   9   |
-------------------------
|       |       |       |
|   *   |   0   |   #   |
-------------------------
rybo111
fuente
1
¿Por qué el voto cerrado demasiado amplio?
Digital Trauma
1
Erm ... alerta de salida de codificación!
wizzwizz4
3
Esta salida parece muy bien elegida para un desafío de salida fija. Hay una estructura geométrica, los números están ordenados, las letras están ordenadas alfabéticamente y en trozos, muchas posibles compensaciones para la codificación en lugar de generar. Creo que la longitud es lo suficientemente alta como para que se pierda el hardcoding, pero ya veremos.
xnor
Un teléfono antiguo sin Q o Z sería más fácil de generar.
No es que Charles
1
Yo no soy un jugador de código (ideas de desafío más interesantes), pero ¿se beneficiarían ciertos idiomas al eliminar P y W de una matriz alfabética y luego agregarlos manualmente? Ya que son los dos únicos fuera de lugar.
rybo111

Respuestas:

6

pb , 240 bytes

<[8]^w[Y!14]{w[X!24]{>[8]b[124]^b[124]v}vw[X!-8]{b[45]<}vv}>[12]^[12]b[49]>[12]w[T!8]{<[4]b[T+50]^<w[X%8!6]{b[65+T*3+X%8%3]>}>[10]vw[B!124]{<[24]vvv}t[T+1]}<[4]b[42]>[8]b[48]>[8]b[35]^[4]>w[B!0]{b[B+2]<}b[87]w[X!2]{<[5]w[B!0]{b[B+1]<}}b[80]

(Este programa solicitará la entrada en la versión actual de pbi, porque va a Y = -1 y la Bvariable intenta actualizarse. Incluso si ingresa input, nada se romperá. Es molesto pero es mejor que la versión anterior que solicitó información sin importar qué.)

pb es un lenguaje que trata sobre tratar el terminal como un lienzo 2D. Para generar, debe mover el "pincel" (un punto representado por los valores actuales de las variables X e Y) a donde desea que vaya ese carácter y colocarlo allí. Es engorroso para cosas como imprimir una palabra, pero para el arte a menudo es conveniente.

Este programa en realidad no dibuja exactamente lo que especifica la pregunta. (¡Espera, no me desestimes todavía! ¡Déjame explicarte!)

Dibujar cajas con bucles es bastante fácil, pero hay una trampa. Si repites la siguiente forma:

--------
|
|

Obtendrá cajas, pero las correctas e inferiores estarán abiertas. Puede dibujar manualmente los lados adicionales, pero eso cuesta bytes. Para evitar esto, mi programa realmente dibuja esto, con los bordes abiertos a la izquierda y arriba:

        |       |       |       |
        |       |       |       |
 --------------------------------
        |       |  ABC  |  DEF  |
        |   1   |   2   |   3   |
 --------------------------------
        |  GHI  |  JKL  |  MNO  |
        |   4   |   5   |   6   |
 --------------------------------
        | PQRS  |  TUV  | WXYZ  |
        |   7   |   8   |   9   |
 --------------------------------
        |       |       |       |
        |   *   |   0   |   #   |
 --------------------------------

Pero monorraíl! ¡Eso no es lo que dice la especificación! ¡No puedes dibujar otra cosa porque es más fácil y te da la gana! Además, aunque tengo tu atención, eres muy inteligente y linda.

Shh, shh, está bien. pb le permite "escribir" en un punto del lienzo con uno o más valores negativos en sus coordenadas. El valor se almacena mientras se ejecuta el programa, pero solo los puntos donde X e Y son ambos> = 0 se escriben realmente en la pantalla. Este programa coloca el pincel de modo que las áreas que están teñidas en esta imagen tengan una X o Y negativa:

Aunque las líneas adicionales se "dibujan", nunca se imprimen.

Después de recorrer y crear la cuadrícula, este programa llena los nueve cuadros superiores. El primero está codificado, se escribe un 1 y el programa continúa. Los otros ocho se generan mediante programación. Ignorando el código para pasar al siguiente cuadro, notando cuando la fila está vacía, etc. (suponga que el pincel siempre comienza en la fila inferior del cuadro y en la columna central), esto es lo que se ejecuta ocho veces:

b[T+50]
^<w[X%8!6]{b[65+T*3+X%8%3]>}
t[T+1]

Incluso sabiendo que ese bes el comando para escribir un personaje, ^v<>mueve el pincel y w[a!b]{}ejecuta el código entre llaves hasta que a != bsea ​​difícil de seguir. Lo primero que debe tener en cuenta es que no puede definir variables en pb. Hay seis en cada programa y tienes que aprender a vivir con ellos. En segundo lugar, Tes la única variable que realmente puede usar de la forma en que está acostumbrado a usar variables; asignar un valor y luego leerlo más tarde. Cualquier otra variable no se puede establecer y solo le dice algo sobre el punto en el lienzo en el que se encuentra o solo se puede establecer indirectamente y con efectos secundarios ( ^v<>cambiar Xy Y, que también cambia la ubicación del pincel. cEstablece Pen(P+1)%8, que también cambia el color de salida). Mantener un contador para saber qué número debe escribirse y qué letras es simplemente imposible. En cambio, este código solo realiza un seguimiento del número y calcula las letras basadas en él. Así es cómo:

b[T+50]                       # We start printing at box 2 with T==0, 0+50=='2'
^<                            # Go up and to the left of the number
w[X%8!6]{                     # Take the X coordinate mod 8 so it's like we're in
                              # the leftmost box. Until hitting the sixth cell:
    b[                          # Write this character:
      65                          # 'A'
      + T * 3                     # Number of current box - 2 (letters start at
                                  # 2) * 3 (3 letters per box)
      + X % 8 % 3                 # X % 8 makes every box behave like it's on the
                                  # left, % 3 puts 0 at the point where the first
                                  # letter goes, then 1, then 2. This is how each
                                  # letter is made different in a box.
    ]
    >                           # Move to the right
}
t[T+1]                        # Box is done, increase counter

Esto es imperfecto, ya que solo se colocan 3 letras en los cuadros 7 y 9. Entonces, después de llenar la fila inferior (codificación simple), cada letra en el cuadro 9 se incrementa en 2 y la W se coloca manualmente. Del mismo modo, cada letra en las casillas 7 y 8 se incrementa en 1 y la P se coloca manualmente.

Sin golf:

<[8]^                         # Go to (-8, -1)
w[Y!14]{                      # While the brush is not on Y=14:
    w[X!24]{                      # While the brush is not on X=24:
        >[8]                          # Go right 8
        b[124]^b[124]v                # Draw a pipe at the current location and above it
    }
    vw[X!-8]{b[45]<}              # Go down and draw hyphens all the way until X=-8
    vv                            # Go down by 2 to start drawing next row
}
>[12]^[12]b[49]               # Write a 1 in the first box
>[12]                          # Go to the bottom pipe on the right of box 2       
w[T!8]{                       # While T is not 8:
    <[4]                          # Go to center cell of the box
    b[T+50]                       # Write the number that belongs there
    ^<w[X%8!6]{b[65+T*3+X%8%3]>}  # Write the letters
    >[10]v                        # Go to the next box
    w[B!124]{                     # If the next box isn't there:
        <[24]vvv                      # Go down a row
    }
    t[T+1]                        # Increase counter
}
<[4]b[42]>[8]b[48]>[8]b[35]   # Put the asterisk, 0 and hash in their boxes
^[4]>w[B!0]{b[B+2]<}          # Increase all letters in the 9th box by 2
b[87]                         # Put a W in the 9th box
w[X!2]{<[5]w[B!0]{b[B+1]<}}   # Increase all letters in the 7th/8th box by 1
b[80]                         # Put a P in the 7th box
metro subterráneo
fuente
6

Brainfuck, 565 caracteres (212 bytes)

 1 +++++[>+++++>>>>+++++++++>>>>+++++++++++++<<<<<<<<<-]    //initialize
 2 >[->>+++++>>>>+++++<<<<<<]                               //initialize
 3 >>>++++++++[-<<<++++++>++++>>>>>>++++<<<<]               //initialize
 4 ++++++++++<->>>>-<<                                      //initialize
 5
 6 //print first block (123)
 7 >+++++[-<.....>]<<.>>>.>.......<.<++[->>..>.+.+.+<..<.<]<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.
 8 //print second block (456)
 9 >>+++++[-<.....>]<<.>>>.<+++[->>..>.+.+.+<..<.<]<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.
10 //print third block (789)
11 >>+++++[-<.....>]<<.>>>.>.>.+.+.+.+<..<.>..>.+.+.+<..<.>.>.+.+.+.+<..<.<<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.
12 //print fourth block (*0#)
13 >>+++++[-<.....>]<<.>>>.<+++[->>.......<.<]<<.<.<...<---------------.>...>.<...<++++++.>...>.<...<-------------.>...>.>>><<.
14 //print last block (the remaining dashes)
15 >>+++++[-<.....>]

Código simple:

+++++[>+++++>>>>+++++++++>>>>+++++++++++++<<<<<<<<<-]>[->>+++++>>>>+++++<<<<<<]>>>++++++++[-<<<++++++>++++>>>>>>++++<<<<]++++++++++<->>>>-<<>+++++[-<.....>]<<.>>>.>.......<.<++[->>..>.+.+.+<..<.<]<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.>>+++++[-<.....>]<<.>>>.<+++[->>..>.+.+.+<..<.<]<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.>>+++++[-<.....>]<<.>>>.>.>.+.+.+.+<..<.>..>.+.+.+<..<.>.>.+.+.+.+<..<.<<<.<.>>>+++[-<<<<...<+.>...>.>>>]<<.>>+++++[-<.....>]<<.>>>.<+++[->>.......<.<]<<.<.<...<---------------.>...>.<...<++++++.>...>.<...<-------------.>...>.>>><<.>>+++++[-<.....>]
Monja permeable
fuente
3

Chicle , 103 bytes

Hexdump:

00000000: d3d5 c501 b86a 1420 0048 3b3a 3983 6917  .....j. .H;:9.i.
00000010: 5737 200d 9631 84c8 2818 4169 6310 cd85  W7 ..1..(.Aic...
00000020: cb30 b069 ee1e 9e60 b55e de3e 60da d7cf  .0.i...`.^.>`...
00000030: 1f66 9a09 d414 5328 6d46 d0b4 80c0 a060  .f....S(mF.....`
00000040: b0da 90d0 3010 1d1e 1119 0533 cd1c 6a8a  ....0......3..j.
00000050: 0594 b624 ec36 984f 5169 b08c 1654 c400  ...$.6.OQi...T..
00000060: 4a2b e337 0d00 04                        J+.7...

Aburrido y práctico.

Pomo de la puerta
fuente
1
"Aburrido y práctico" como un teclado de teléfono :)
rybo111
2

Python 2, 147 bytes

print(("|%s"*3+"|\n")*2).join(["-"*25+"\n"]*5)%tuple(x.center(7)for x in" ABC DEF 1 2 3 GHI JKL MNO 4 5 6 PQRS TUV WXYZ 7 8 9    * 0 #".split(' '))

Un borrador rápido de una estrategia básica. Utiliza el formato de cadena para insertar las etiquetas, que están codificadas en una cadena larga.

xnor
fuente
2

C, 160 bytes

j,k,l,m,n=65;main(i){for(i=325;i--;i%25||puts(""))l=i-139,putchar((k=i/25%3)?(j=i%25%8)?k-2?j-4?32:"123456789*0#"[m++]:j/3-1&&l*l!=64||i%290<75?32:n++:'|':45);}

Tiene sentido aprovechar el hecho de que las letras están en secuencia. Este código recorre los 325 caracteres del teclado e imprime un espacio o la siguiente letra según sea necesario.

Sin golf

i,    //main loop variable
j,    //x position within key
k,    //y position within key
l,    //distance from character 139 (the space immediately left of T)
m,    //symbol counter
n='A';//letter counter

main(){
  for(i=325;i--;i%25||puts(""))             //loop through 325 characters. puts() adds a newline at the end of each line of 25 
    l=i-139,                                //calculate l. if it is 8, we need to print P or W
    putchar((k=i/25%3)?                     //if row not divisible by 3
      (j=i%25%8)?                             //if position on row not a |
         k-2?                                   //if row mod 3 = 1
           j-4?' ':"123456789*0#"[m++]            //print a space or a character from the string (increment m for next time)
         :                                      //else row mod 3 must = 2
           j/3-1&&l*l!=64||i%290<75?' ':n++       //print a space or a letter according to formula (increment n to the next letter)
      :'|'                                    //else print |
    :
    '-')                                    //else print -
;}

// j/3-1 returns a 0 when in any of the three columns where letters are generally found
// l*l!=64 returns a 0 at the correct place fo P and W
// i%290<75 returns a 1 for keys 1,*,0,#, supressing the printing of letters/symbols
Level River St
fuente
2

Java, 296 bytes

Golfizado:

class a{static void main(String[]a){System.out.println("-\n|&|  ABC  |  DEF  |\n|$1$|$2$|$3$|\n-\n|  GHI  |  JKL  |  MNO  |\n|$4$|$5$|$6$|\n-\n| PQRS  |  TUV  | WXYZ  |\n|$7$|$8$|$9$|\n-\n|&|&|&|\n|$*$|$0$|$#$|\n-".replace("&","       ").replace("$","   ").replace("-","--------------------"));}}

Sin golf:

public class AsciiPhoneKeypad{
    public static void main(String []args){
        // - for twenty-five dashes
        // $ for three spaces
        // & for seven spaces
        System.out.println("-\n|&|  ABC  |  DEF  |\n|$1$|$2$|$3$|\n-\n|  GHI  |  JKL  |  MNO  |\n|$4$|$5$|$6$|\n-\n| PQRS  |  TUV  | WXYZ  |\n|$7$|$8$|$9$|\n-\n|&|&|&|\n|$*$|$0$|$#$|\n-"
        .replace("&","       ").replace("$","   ").replace("-","--------------------"));
     }
}
Monja permeable
fuente
283 bytes (sí tiene una nueva línea final, pero esto está permitido de manera predeterminada), sin embargo, todavía hay 289 bytes .
Kevin Cruijssen
1

Lua, 209 bytes

Golfizado:

a=("-\n|&|  ABC  |  DEF  |\n123|\n-\n|  GHI  |  JKL  |  MNO  |\n456|\n-\n| PQRS  |  TUV  | WXYZ  |\n789|\n-\n|&|&|&|\n*0#|\n-"):gsub("&","       "):gsub("([0-9*#])","|   %1   "):gsub("-",("-"):rep(25))print(a)

Sin golf:

-- "&" for seven spaces
-- "1" -> "|   1   "
-- "-" -> twenty-five dashes

a="-\n|&|  ABC  |  DEF  |\n123|\n-\n|  GHI  |  JKL  |  MNO  |\n456|\n-\n| PQRS  |  TUV  | WXYZ  |\n789|\n-\n|&|&|&|\n*0#|\n-"

a = a:gsub("&","       ")

a = a:gsub("([0-9*#])","|   %1   ")

a = a:gsub("-",("-"):rep(25))

print(a)
Monja permeable
fuente
1

JavaScript (ES6), 184 182 bytes

f=
_=>`-
! |  ABC  |  DEF  |
!1!2!3|
-
|  GHI  |  JKL  |  MNO  |
!4!5!6|
-
| PQRS  |  TUV  | WXYZ  |
!7!8!9|
-
! ! ! |
!*!0!#|
-`.replace(/-|!./g,s=>s<`-`?`|   ${s[1]}   `:s.repeat(25))
;document.write('<pre>'+f());

Las filas de guiones son obviamente comprimibles y los dígitos también, pero no pude hacer nada con las letras. Editar: Guardado 1 de 2 bytes gracias a @Shaggy.

Neil
fuente
Guarde un byte con: replace(/-|!./g,s=>s=="-"?s.repeat(25):"| ${s[1]} ")- reemplazando comillas por comillas inversas. Intenté algunas cosas para rellenar los grupos de letras, pero lo mejor que pude hacer fue 194 bytes.
Shaggy
1
@ Shaggy Gracias, ¡y también me las arreglé para eliminar otro byte!
Neil
0

CJam, 128 bytes

'-25*N+:A" ABC DEF GHI JKL MNO PQRS TUV WXYZ   "S/3/{['|\{_,5\-S*\"  |"}%N]:+:+}%"123456789*0#"1/3/{['|\{S3*_@@'|}%N]:+:+}%.+A*A

Pruébalo en línea.

GamrCorps
fuente
0

Perl, 142 + 1 = 143 bytes

$ perl -MCompress::Zlib x.pl
$ cat x.pl
print uncompress(<DATA>)
__DATA__
x<9c><d3><d5><c5>^A<b8>j^T ^@H;:9<83>i^WW7 ^M<96>1<84><c8>(^XAic<10><cb>0<b0>i<ee>^^<9e>`<b5>^<de>>`<da><d7><cf>^_f<9a> <d4>^TS(mFд<80> `<b0>ڐ<d0>0^P^]^^^Q^Y^E3<cd>^\j<8a>^E<94><b6>$<ec>6<98>OQi<b0><8c>^VT<c4>^@J+<e3>7^M^@^D:@k

Caracteres no imprimibles, por lo que la versión sin codificar está debajo.

$ cat x.pl.uue
begin 664 x.pl
M<')I;G1?=6YC;VUP<F5S<R@\1$%403XI"E]?1$%405]?"GB<T]7%`;AJ%"``
M2#LZ.8-I%U<W(`V6,83(*!A!:6,0S87+,+!I[AZ>8+5>WCY@VM?/'V::"=04
M4RAM1M"T@,"@8+#:D-`P$!T>$1D%,\T<:HH%E+8D[#:83U%IL(P65,0`2BOC
(-PT`!#I`:PH`
`
end
$
Steve
fuente
Espera, ¿no -M...debería contarse también?
Ven
0

Python 3.5 - 240 bytes:

k=' ABC DEF 1 2 3 GHI JKL MNO 4 5 6 PQRS TUV WXYZ 7 8 9    * 0 #'.split(' ')
for _ in range(8):
 print('\n',end='')
 if _%2==0:print("-"*27+'\n',end='')
 [print('|{}|'.format(g.center(7)),end='')for g in k[:3:1]];del k[:3:1]
print('\n'+"-"*27)

Imprime exactamente lo que quiere el OP, aunque puede ser un poco largo.

R. Kap
fuente
0

Pitón 2, 200

r=str.replace;print r(r(r(r(r("""-.|  ABC`DEF`
,1=,2=,3 `-|  GHI`JKL`MNO`
,4=,5=,6 `-| PQRS`TUV`WXYZ |
,7=,8=,9 `-...|
,*=,0=,# `-""","-","\n"+"-"*25+"\n"),".",",= "),",","|="),"`","  |  "),"=","   ")

Estrategia de reemplazo simple.

Oliver Ni
fuente
0

Python 2, 168 bytes

Un método sencillo que no utiliza compresión incorporada:

for i in range(13):print['-'*25,'|'+'|'.join(["123456789*0#"," ABC DEF GHI JKL MNO PQRS TUV WXYZ   ".split(' ')][i%3%2][i/3%4*3+m].center(7)for m in[0,1,2])+'|'][i%3>0]
quintapia
fuente
0

/// , 154 caracteres

/%/=====//=/-----//?/ ! //!/}  //{/ }//}/  |//(/|   /%
(  !ABC!DEF}
(1?2?3{
%
|  GHI!JKL!MNO}
(4?5?6{
%
| PQRS!TUV} WXYZ}
(7?8?9{
%
(  !   !   }
(*?0?#{
%
hombre trabajando
fuente
0

GML (Game Maker Language) 8.0, 269 bytes

a='-------------------------'b='   |   'c='  |#|   'draw_text(0,0,a+"#|       |  ABC  |  DEF"+c+"1"+b+"2"+b+"3   |#"+a+"#|  GHI  |  JKL  |  MNO"+c+"4"+b+"5"+b+"6   |#"+a+"#| PQRS  |  TUV  | WXYZ"+c+"7"+b+"8"+b+"9   |#"+a+"#|    "+b+" "+b+"  "+c+"*"+b+"0"+b+"\#   |#"+a)

En Game Maker, #es el personaje de nueva línea y se puede escapar\#

Timtech
fuente
0

Python 2, 134 bytes

Esta fuente contiene caracteres no imprimibles, por lo que se presenta como un volcado hexadecimal con el que se puede decodificar xxd -r.

00000000: efbb bf70 7269 6e74 2778 01d3 c505 b86a  ...print'x.....j
00000010: 1420 5c30 483b 3a39 8369 1757 3720 5c72  . \0H;:9.i.W7 \r
00000020: 9631 84c8 2818 4169 6310 cd85 d734 770f  .1..(.Aic....4w.
00000030: 4fb0 5a2f 6f1f 30ed ebe7 0f33 cd04 6a8a  O.Z/o.0....3..j.
00000040: 2994 3623 685a 4060 5030 586d 4868 1888  ).6#hZ@`P0XmHh..
00000050: 0e8f 888c 8299 660e 35c5 024a 5b12 345c  ......f.5..J[.4\
00000060: 7202 3068 b08c 1654 c45c 304a 2be3 375c  r.0h...T.\0J+.7\
00000070: 725c 3004 3a40 6b27 2e64 6563 6f64 6528  r\0.:@k'.decode(
00000080: 277a 6970 2729                           'zip')
Anders Kaseorg
fuente
0

05AB1E , 91 bytes (no competitivos)

•O«ò•3B7ô'-7×.ø'|ìε3×}'|«D¦Ð)˜»A3ô5£ðý"pqrs tuvwxyz"‚J5úR12úRv0y.;}1ð:2'A:9LJ"*0#"«v'Ay.;}u

Pruébalo en línea!

Urna de pulpo mágico
fuente
0

J , 105 103 bytes

9!:7'|'9}11#'-'
echo'PW'(7 2;7 18)}":_3;/\(12{.'',8 3$65{26-.&'PW'\a.),:&(5|.7{.])"1' ',.'123456789*0#'

Pruébalo en línea!

FrownyFrog
fuente