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.

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.

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

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'

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" 

Scala 70 caracteres:

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

Mathematica, 73

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

Grid@Partition[Characters@"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU",3,1]

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.

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

Rubí 69 65 62

Basado en el ejemplo de Groovy

38.times{|i|p"1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU"[i,2]}

Haskell, 80

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

Javascript, 103

for(a='1234567890JIHGFEDCBAKLMNOPQRST!?,.ZYXWVU';a.length>2;a=a.substring(1))console.log(a.substr(0,3))

Haskell, 94

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

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'

D 124 caracteres

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

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

Python, 73

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

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.

Q ( 66 63 caracteres)

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

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.

Q, 63

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

/// , 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.

Jalea , 41 40 bytes

ØAḣ⁵Ṛ
ØDṫ2;0;¢;“KLMNOPQRST!?,.ZYXWVU”ṡ3Y

Pruébalo en línea!

Podría (todavía) ser golfable ...