Suponha um teclado simples com este layout:

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 . , ? !

O padrão de teclado de Peter pode ser gerado começando no canto superior esquerdo do teclado e exibe os três primeiros caracteres e uma nova linha. Ele muda sobre um caractere e exibe a segunda, terceira e quarta tecla. Quando chega ao final de uma linha, continua no final da próxima linha e recua, até atingir o início dessa linha e depois avançar na próxima linha, e assim sucessivamente, até chegar ao início da última linha. .

Este é o padrão 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

Escreva um programa que não aceite entrada e exiba o padrão do teclado de Peter. O programa deve ser menor que 152 bytes , ou seja, o tamanho da string que ele gera.

Isso é código de golfe, então a solução mais curta vence.

Perl, 63 caracteres

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

Esta solução usa a sayfunção (disponível desde o Perl 5.10.0 com o -Eswitch ou com use 5.010). Sem ele, o melhor que posso fazer é 67 caracteres (e uma nova linha extra no final da saída):

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

Solução anterior de 65 caracteres:

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

Substituir say$1por print$1.$/permite que o código seja executado em perls mais antigos, ao custo de 5 caracteres extras.

APL, 43 caracteres

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

Isso funciona no Dyalog APL . Consegui salvar alguns caracteres gerando a string de saída (tudo depois ⊃). Vou escrever uma explicação quando tiver tempo!

Aqui está a aparência da saída:

      ⍪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

Explicação, da direita para a esquerda:

• Primeiro, construímos a string vista em todas as outras entradas:
  • 6↑⌽⎕A: ⎕Anos fornece uma sequência do alfabeto maiúsculo, de A a Z. Em seguida, invertemos ( ⌽) e pegamos ( ↑) os 6 primeiros caracteres, fornecendo-nos 'ZYXWVU'. (Em retrospecto, essa abordagem não acaba salvando nenhum personagem, mas deixarei porque ela se encaixa melhor.)
  • '!?,.',: Concatenamos ( ,) a string '!?,.'com o resultado anterior.
  • (10↑10⌽⎕A),: Pegamos os 10 primeiros caracteres ( 10↑) do alfabeto, que são rotacionados pela primeira vez dez vezes ( 10⌽) e concatenamos isso com o resultado anterior. Como um exemplo de rotação, 5⌽'abcdef'(a corda 'abcdef'girou 5 vezes) nos fornece 'cdefab'.
  • (⌽10↑⎕A),: Pegue os 10 primeiros caracteres do alfabeto e inverta-os e concatene-o com a string anterior.
  • (1⌽⎕D),: ⎕Dnos fornece os dígitos como uma string, de 0 a 9, inclusive. Em seguida, rotacionamos ('⌽') essa string em 1, produzindo '1234567890'. Como antes, concatenamos isso com o resultado anterior.
• Agora que construímos nossa string (que nos salvou três caracteres da representação da APL, devido a aspas), fazemos algumas mágicas para criar nossa saída final:
  • 3,/: Pegamos a string em grupos de três caracteres e as concatenamos.
  • Para finalizar, usamos ⍪o vetor de strings (realmente um vetor de vetores de caracteres) ao longo da primeira dimensão. Isso tem o efeito de alterar sua forma de 38para 38 1(uma matriz 38x1).

J, 66 62 45 caracteres

Acontece que eu estava sendo inteligente demais pela metade.

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

é tudo que eu precisava o tempo todo.

Anteriormente:

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

e:

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

R (75 caracteres)

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

O que isso faz?

• strsplit divide uma string em substrings, nesse caso caracteres individuais
• embed é uma função realmente útil que transforma um vetor em uma matriz de elementos sobrepostos
• O resto é apenas indexar e classificar as colunas na ordem certa.

Isso produz e imprime uma matriz 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

Cheguei independentemente ao mesmo método que todos os outros:

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

Groovy, 73

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

Todas as coisas inteligentes que tentei acabaram sendo mais longas do que fazer da maneira idiota.

C, 98 104 caracteres

Como ninguém mais o fez ainda, pensei em tentar gerar a string rapidamente, usando algum tipo de codificação de comprimento de execução para execuções ascendentes e descendentes.

EDIT: Após várias iterações, aqui está finalmente uma solução "inteligente" que se vincula à menor solução "burra" em C com 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;}

O código requer uma codificação Latin-1 de 8 bits (ISO-8859-1 ou Windows-1252), que deve funcionar bem em todas as plataformas comumente usadas, mas salvando a fonte com uma página de código de 8 bits menos popular ou UTF- 8 não vai funcionar.

A sequência de dados foi criada pela seguinte parte do 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))))))

O bit "twiddle" é usado para evitar caracteres de controle ASCII não imprimíveis na cadeia de dados codificada e para garantir isso i==0apenas no final da saída.

C, 98 caracteres

No entanto, mesmo em C, você pode obter um programa curto simplesmente imprimindo trigêmeos consecutivos a partir da string original:

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

Ruby 69 65 62

Baseado no exemplo 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

quando chamado por:

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

D 124 chars

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

Decidi ver se eu poderia vencer a solução de stephencarmody . Isto é o que eu vim com.

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]

Eu não conheço o Smalltalk muito bem, então é um pouco estranho para mim. É compila com gstoutras pessoas não são testadas.

Q ( 66 63 caracteres)

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

Prolog, 131

É provavelmente por isso que você nunca vê entradas do Prolog. A nova linha é necessária (na verdade, qualquer espaço em branco serve, mas deve haver espaço em branco).

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

Experimente online!

Não pode jogar mais? Isto é, em certo sentido, <152 bytes.

Geléia , 41 40 bytes

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

Experimente online!

Pode (ainda) ser jogável ...