8

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.

code-golf kolmogorov-complexity Peter Olson
fonte

Mesmo no Golfscript, estou lutando para encontrar uma maneira mais curta de gerar a string base de 40 caracteres.

Peter Taylor

@ PeterTaylor Eu esperava que alguém usasse algum tipo de compreensão de lista, como [1..9 0 J..A K..T ! ? , . Z..U].

Peter Olson

Você pode usar echo {1..9} "0" {J..A} {K..T} '!?,.' {Z..U}|sed 's/ //g'no bash, mas já precisa de 13 caracteres para anexar um comando sed, para remover espaços em branco. Isso gera 57 caracteres, e nenhum triplo foi construído até agora. Com o comando hold do sed, deve ser possível, mas em 6 caracteres, vencer a solução perl?

usuário desconhecido

O limite de 152 bytes parece desnecessário - codificar a saída sem nenhuma compactação é, de qualquer maneira, ruim no golfe. Também poderia potencialmente barrar idiomas como o brainf ** k, onde grandes programas quase sempre ocorrem, mas ainda pode haver algum golfe inteligente em andamento.

Zwei

7

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.

Ilmari Karonen
fonte

você me venceu por alguns personagens. +1.

Toto

2

Vá diretamente para a solução de 63 caracteres. meta-discussão

JB

6

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

Dillon Cower
fonte

6

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'

Gareth
fonte

4

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"

Andrie
fonte

+1 embedé realmente uma função muito útil!

Tommy

3

Scala 70 caracteres:

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

Usuário desconhecido
fonte

2

Mathematica, 73

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

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

Mr.Wizard
fonte

2

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.

Armand
fonte

2

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

han
fonte

2

Ruby 69 65 62

Baseado no exemplo Groovy

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

Hauleth
fonte

Eu acho que a convenção aqui no passado para várias respostas em diferentes idiomas foi postar uma resposta para cada idioma.

Gareth

2

Haskell, 80

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

Angs
fonte

1

Javascript, 103

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

stephencarmody
fonte

2

Um usuário anônimo sugeriu reduzi-lo para 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
fonte

1

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'

Toto
fonte

1

D 124 chars

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

catraca arrepiante
fonte

1

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.

Ilmari Karonen
fonte

1

Python, 73

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

Steven Rumbalski
fonte

1

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.

Hauleth
fonte

1

Primeiro truque: remova o espaço entre 38 e faça: -> 98 - segundo truque para remover outro espaço, faça um loop de 3 a 40 e copie De: i-2 a: i -> 97 - terceiro truque, não use uma variável x: = ... show: x, just show: ('...' copyFrom: i-2to: i) diretamente, isso é -4 caracteres + 2 parênteses -> 95

aka.nice

1

Q ( 66 63 caracteres)

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

skeevey
fonte

1

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.

marinus
fonte

0

Q, 63

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

tmartin
fonte

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

Experimente online!

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

Erik, o Outgolfer
fonte

Este não é um candidato sério pelas nossas regras . Você não faz nenhum esforço para fazer melhor que a pontuação mínima.

Mego4

Não posso, é por isso que publiquei como está. Se você acha que poderia fazer melhor, pode tentar. Não conheço nenhuma solução mais curta e, de fato, esforcei-me um pouco, mas percebi que isso nunca será mais complicado.

Erik the Outgolfer

Não estou convencido de que isso possa ser praticado em ///, mas a especificação diz que o programa deve ser mais curto que a [...] string que ele gera , o que não é o caso aqui.

Dennis

@ Dennis Não, ele diz que o programa deve ser menor que 152 bytes (151 <152). Acho que é um erro, ou leio o post de forma diferente, mas i.e.não substitui o significado de algo, apenas o ajuda a entender melhor, no meu sentido. Além disso, não incluí uma nova linha à direita, talvez por isso seja 151 bytes. E sim, eu li essa seção.