Mostrar el patrón del teclado de Peter

8

Asuma un teclado simple con este diseño:

1 2 3 4 5 6 7 8 9 0
A B C D E F G H I J
K L M N O P Q R S T
U V W X Y Z . , ? !

El patrón de teclado de Peter se puede generar comenzando en la parte superior izquierda del teclado y muestra los primeros tres caracteres y una nueva línea. Se desplaza sobre un personaje y muestra la segunda, tercera y cuarta tecla. Una vez que alcanza el final de una fila, continúa al final de la siguiente fila y retrocede, hasta que alcanza el comienzo de esa fila y luego avanza en la siguiente fila, y así sucesivamente hasta llegar al comienzo de la última fila .

Este es el patrón de teclado de Peter:

123
234
345
456
567
678
789
890
90J
0JI
JIH
IHG
HGF
GFE
FED
EDC
DCB
CBA
BAK
AKL
KLM
LMN
MNO
NOP
OPQ
PQR
QRS
RST
ST!
T!?
!?,
?,.
,.Z
.ZY
ZYX
YXW
XWV
WVU

Escriba un programa que no acepte entradas y muestre el patrón de teclado de Peter. El programa debe ser menor que 152 bytes , es decir, el tamaño de la cadena que genera.

Este es el código de golf, por lo que gana la solución más corta.

code-golf kolmogorov-complexity Peter Olson
fuente
Incluso en Golfscript estoy luchando por encontrar una forma más corta de generar la cadena base de 40 caracteres.
Peter Taylor
@PeterTaylor Esperaba que alguien usara algún tipo de comprensión de listas, como [1..9 0 J..A K..T ! ? , . Z..U].
Peter Olson, el
Puede usar echo {1..9} "0" {J..A} {K..T} '!?,.' {Z..U}|sed 's/ //g'en bash, pero ya necesita 13 caracteres para agregar un comando sed, para eliminar espacios en blanco. Esto hace 57 caracteres, y hasta ahora no se ha construido un triple. Con el comando hold de sed, debería ser posible, pero en 6 caracteres, superar la solución perl?
Usuario desconocido el
El límite de 152 bytes parece innecesario: de todos modos, codificar la salida sin compresión es un mal golf. También podría prohibir idiomas como brainf ** k, donde los programas grandes son casi siempre una ocurrencia, pero aún podría haber algún juego de golf inteligente.
Zwei

Respuestas:

7

Perl, 63 caracteres

say for"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"=~/(?=(...))/g

Esta solución usa la sayfunción (disponible desde Perl 5.10.0 con el -Einterruptor, o con use 5.010). Sin él, lo mejor que puedo hacer es 67 caracteres (y una nueva línea adicional al final de la salida):

print"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"=~/(?=(...))/g,$,=$/

Solución anterior de 65 char:

s//1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU/;s!(?=(...))!say$1!eg

Reemplazar say$1con print$1.$/permite que el código se ejecute en perls más antiguos, a un costo de 5 caracteres adicionales.

Ilmari Karonen
fuente
Me ganaste por unos pocos personajes. +1.
Toto
2
Ve por la solución de 63 char directamente. meta discusión
JB
6

APL, 43 caracteres

⍪3,/(1⌽⎕D),(⌽10↑⎕A),(10↑10⌽⎕A),'!?,.',6↑⌽⎕A

Esto funciona en Dyalog APL . Logré guardar un par de caracteres generando la cadena de salida (todo después ⊃). ¡Escribiré una explicación cuando tenga algo de tiempo!

Así es como se ve la salida:

      ⍪3,/(1⌽⎕D),(⌽10↑⎕A),(10↑10⌽⎕A),'!?,.',6↑⌽⎕A
 123 
 234 
 345 
 456 
 567 
 678 
 789 
 890 
 90J 
 0JI 
 JIH 
 IHG 
 HGF 
 GFE 
 FED 
 EDC 
 DCB 
 CBA 
 BAK 
 AKL 
 KLM 
 LMN 
 MNO 
 NOP 
 OPQ 
 PQR 
 QRS 
 RST 
 ST! 
 T!? 
 !?, 
 ?,. 
 ,.Z 
 .ZY 
 ZYX 
 YXW 
 XWV 
 WVU

Explicación, de derecha a izquierda:

  • Primero, construimos la cadena que se ve en todas las otras entradas:
    • 6↑⌽⎕A: ⎕Anos da una cadena del alfabeto en mayúscula, de la A a la Z. Luego lo invertimos ( ⌽) y tomamos ( ↑) los primeros 6 caracteres del mismo, dándonos 'ZYXWVU'. (En retrospectiva, este enfoque no termina guardando ningún personaje, pero lo dejaré porque encaja mejor).
    • '!?,.',: Concatenamos ( ,) la cadena '!?,.'con el resultado anterior.
    • (10↑10⌽⎕A),: Tomamos los primeros 10 caracteres ( 10↑) del alfabeto, que primero se gira diez veces ( 10⌽), y concatenamos esto con el resultado anterior. Como ejemplo de rotación, 5⌽'abcdef'(la cuerda 'abcdef'rota 5 veces) nos da 'cdefab'.
    • (⌽10↑⎕A),: Tome los primeros 10 caracteres del alfabeto, inviértalos y concatene esto con la cadena anterior.
    • (1⌽⎕D),: ⎕Dnos da los dígitos como una cadena, de 0 a 9, inclusive. Luego rotamos ('⌽') esta cadena por 1, produciendo '1234567890'. Como antes, concatenamos esto con el resultado anterior.
  • Ahora que tenemos nuestra cadena construida (que nos salvó 3 caracteres de la representación APL, debido a las comillas), hacemos algo de magia para construir nuestra salida final:
    • 3,/: Tomamos la cadena, en grupos de tres caracteres, y los concatenamos.
    • Para terminar, usamos ⍪para enredar nuestro vector de cadenas (realmente un vector de vectores de caracteres) a lo largo de la primera dimensión. Esto tiene el efecto de cambiar su forma de 38a 38 1(una matriz de 38x1).
Dillon Cower
fuente
6

J, 66 62 45 caracteres

Resulta que estaba siendo demasiado inteligente a la mitad.

3]\'1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU'

es todo lo que necesitaba todo el tiempo.

Previamente:

_2}.|:>(];1&|.;2&|.)'1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU'

y:

38 3$($:@}.,~3$])^:(3<#)'1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU'
Gareth
fuente
4

R (75 caracteres)

embed(strsplit("1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU","")[[1]],3)[,3:1]

Que hace esto?

  • strsplit divide una cadena en subcadenas, en este caso caracteres individuales
  • embed es una función realmente útil que convierte un vector en una matriz de elementos superpuestos
  • El resto es solo indexar y ordenar columnas en el orden correcto.

Esto produce e imprime una serie de caracteres:

> embed(strsplit("1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU","")[[1]],3)[,3:1]
      [,1] [,2] [,3]
 [1,] "1"  "2"  "3" 
 [2,] "2"  "3"  "4" 
 [3,] "3"  "4"  "5" 
 [4,] "4"  "5"  "6" 
 [5,] "5"  "6"  "7" 
 [6,] "6"  "7"  "8" 
 [7,] "7"  "8"  "9" 
 [8,] "8"  "9"  "0" 
 [9,] "9"  "0"  "J" 
[10,] "0"  "J"  "I" 
[11,] "J"  "I"  "H" 
[12,] "I"  "H"  "G" 
[13,] "H"  "G"  "F" 
[14,] "G"  "F"  "E" 
[15,] "F"  "E"  "D" 
[16,] "E"  "D"  "C" 
[17,] "D"  "C"  "B" 
[18,] "C"  "B"  "A" 
[19,] "B"  "A"  "K" 
[20,] "A"  "K"  "L" 
[21,] "K"  "L"  "M" 
[22,] "L"  "M"  "N" 
[23,] "M"  "N"  "O" 
[24,] "N"  "O"  "P" 
[25,] "O"  "P"  "Q" 
[26,] "P"  "Q"  "R" 
[27,] "Q"  "R"  "S" 
[28,] "R"  "S"  "T" 
[29,] "S"  "T"  "!" 
[30,] "T"  "!"  "?" 
[31,] "!"  "?"  "," 
[32,] "?"  ","  "." 
[33,] ","  "."  "Z" 
[34,] "."  "Z"  "Y" 
[35,] "Z"  "Y"  "X" 
[36,] "Y"  "X"  "W" 
[37,] "X"  "W"  "V" 
[38,] "W"  "V"  "U"
Andrie
fuente
¡+1 embedes una función muy útil!
Tommy
3

Scala 70 caracteres:

"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU".sliding(3,1).mkString("\n")
usuario desconocido
fuente
2

Mathematica, 73

Llegué independientemente al mismo método que todos los demás:

Grid@Partition[Characters@"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU",3,1]
Señor mago
fuente
2

Groovy, 73

(0..37).each{println"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"[it..it+2]}

Todas las cosas inteligentes que probé resultaron ser más largas que hacerlo de la manera tonta.

Armand
fuente
2

C, 98104 caracteres

Como nadie más lo ha hecho todavía, pensé que intentaría generar la cadena sobre la marcha, utilizando algún tipo de codificación de longitud de ejecución para carreras ascendentes y descendentes.

EDITAR: Después de varias iteraciones, finalmente hay una solución "inteligente" que se vincula con la solución "tonta" más corta en C con 98 caracteres:

char*s="0º.ÿK»Jº ü=ÿ*ø[×",a[99],*p=a,i;main(j){for(;i-=i<8?j=*s++,*s++:8;puts(p++))p[2]=j+=i%4-1;}

El código requiere una codificación Latin-1 de 8 bits (ISO-8859-1 o Windows-1252), que debería funcionar bien en todas las plataformas de uso común, pero guardando la fuente con alguna página de códigos de 8 bits menos popular, o UTF- 8 no funcionará.

La cadena de datos fue creada por la siguiente pieza de emacs lisp:

(require 'cl)
(apply 'concat
  (let ((last-remainder 0))
    (loop for (begin count step twiddle)
          in '((?1 9 +1 4) (?0 1 +2 4) (?J 10 -1 4) (?K 10 +1 0)
               (?! 1 +1 4) (?? 1 +2 4) (?, 2 +2 4) (?Z 6 -1 8))
          append (prog1 (list (char-to-string (- begin step))
                              (char-to-string 
                               (logand 255 (- last-remainder
                                              (+ (* 8 (- count 1)) (+ step 1)
                                                 twiddle)))))
                   (setq last-remainder (+ (logand twiddle 7) step 1))))))

El bit "twiddle" se usa para evitar caracteres de control ASCII no imprimibles en la cadena de datos codificados, y para garantizar que i==0solo se encuentre al final de la salida.

C, 98 caracteres

Sin embargo, incluso en C puede obtener un programa corto simplemente imprimiendo trillizos consecutivos desde la cadena original:

main(){char s[]="12,34567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU",*p=s+2;for(;*p=p[1];puts(p-3))*++p=0;}
han
fuente
2

Rubí 69 65 62

Basado en el ejemplo de Groovy

38.times{|i|p"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"[i,2]}
Hauleth
fuente
Creo que la convención aquí en el pasado para respuestas múltiples en diferentes idiomas ha sido publicar una respuesta para cada idioma.
Gareth el
2

Haskell, 80

mapM_(putStrLn.take 3.(`drop`"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"))[0..37]
Angs
fuente
1

Javascript, 103

for(a='1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU';a.length>2;a=a.substring(1))console.log(a.substr(0,3))
stephencarmody
fuente
2
Un usuario anónimo sugirió reducir esto a 93 caracteres comofor(a='1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU';a[3];a=a.slice(1))console.log(a.slice(0,3))
Peter Taylor
1

Haskell, 94

main=putStr.unlines.take 38$take 3`map`iterate tail"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"
hammar
fuente
1

Perl, 73 caracteres:

print substr('1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU',$_,3),$/for 0..37

Perl, 66 caracteres:

say substr"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU",$_,3for 0..37

cuando es llamado por:

perl -E 'say substr"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU",$_,3for 0..37'
Toto
fuente
1

D 124 caracteres

import std.stdio;void main(){enum s="1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU";
foreach(i;3..s.length){writeln(s[i-3..i)]);}}
monstruo de trinquete
fuente
1

JavaScript, 83 caracteres

for(i=0;i<38;)console.log('1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU'.substr(i++,3))

Decidí ver si podía vencer la solución de Stephencarmody . Esto es lo que se me ocurrió.

Ilmari Karonen
fuente
1

Python, 73

for i in range(38):print"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"[i:i+3]
Steven Rumbalski
fuente
1

Smalltalk 102 99

1to:38 do:[:i|x:='1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU'copyFrom:i to:i+2.Transcript cr show:x]

No conozco a Smalltalk muy bien, así que es un poco extraño para mí. Sus compilaciones con gstotros no se prueban.

Hauleth
fuente
1
Primer truco: elimine el espacio entre 38 y haga: -> 98 - segundo truco para eliminar otro espacio, pase de 3to: 40 y copie De: i-2to: i -> 97 - tercer truco, no use una variable x: = ... show: x, solo muestra: ('...' copyDe: i-2to: i) directamente, eso es -4 caracteres + 2 paréntesis -> 95
aka.nice
1

Q ( 66 63 caracteres)

(((!)38),'3)sublist\:"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"
skeevey
fuente
1

Prolog, 131

Esta es probablemente la razón por la que nunca ves entradas de Prolog. La nueva línea es obligatoria (en realidad, cualquier espacio en blanco servirá pero debe haber un espacio en blanco).

z(S,L):-append(_,X,L),append(S,_,X),length(S,3).
:-forall(z(X,"1234567890JIHFEDCBAKLMNOPQRST!?,.ZYXWVU"),writef("%s\n",[X])),halt.
marinus
fuente
0

Q, 63

{(x;3)sublist"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"}'[(!)38]
tmartin
fuente
0

/// , 151 bytes

123
234
345
456
567
678
789
890
90J
0JI
JIH
IHG
HGF
GFE
FED
EDC
DCB
CBA
BAK
AKL
KLM
LMN
MNO
NOP
OPQ
PQR
QRS
RST
ST!
T!?
!?,
?,.
,.Z
.ZY
ZYX
YXW
XWV
WVU

Pruébalo en línea!

¿No puedes jugar más al golf? Esto es, en cierto sentido, <152 bytes.

Erik el Outgolfer
fuente
Este no es un contendiente serio según nuestras reglas . No hace ningún esfuerzo para hacerlo mejor que el puntaje mínimo.
Mego
No puedo, por eso lo publiqué tal cual. Si crees que podrías hacerlo mejor, puedes intentarlo. No conozco ninguna solución más corta y, de hecho, me esforcé un poco, pero me di cuenta de que esto nunca se va a reducir aún más.
Erik the Outgolfer
No estoy convencido de que esto se pueda jugar en ///, pero la especificación dice que el programa debe ser más corto [...] que la cadena que genera , lo cual no es el caso aquí.
Dennis
@ Dennis No, dice que el programa debe ser menor a 152 bytes (151 <152). Creo que es un error, o leo la publicación de manera diferente, pero i.e.no anula el significado de algo, solo te ayuda a entenderlo mejor, en mi sentido. Además, no incluí una nueva línea final, tal vez por eso son 151 bytes. Y sí, leí esa sección.
Erik the Outgolfer