Nehmen Sie eine einfache Tastatur mit diesem Layout an:

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

Das Tastaturmuster von Peter kann generiert werden, indem oben links auf der Tastatur begonnen wird. Die ersten drei Zeichen und eine neue Zeile werden angezeigt. Es verschiebt sich um ein Zeichen und zeigt die zweite, dritte und vierte Taste an. Sobald es das Ende einer Reihe erreicht hat, fährt es am Ende der nächsten Reihe fort und geht rückwärts, bis es den Anfang dieser Reihe erreicht und dann in der nächsten Reihe vorwärts geht, und so weiter, bis es den Anfang der letzten Reihe erreicht .

Dies ist Peters Tastaturmuster:

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

Schreiben Sie ein Programm, das keine Eingaben akzeptiert und Peters Tastaturmuster anzeigt. Das Programm muss kleiner als 152 Byte sein , dh die Größe der ausgegebenen Zeichenfolge.

Dies ist Code Golf, also gewinnt die kürzeste Lösung.

Perl, 63 Zeichen

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

Diese Lösung verwendet die sayFunktion (verfügbar seit Perl 5.10.0 mit dem -ESchalter oder mit use 5.010). Ohne sie kann ich am besten 67 Zeichen (und einen zusätzlichen Zeilenumbruch am Ende der Ausgabe) tun:

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

Frühere 65-Zeichen-Lösung:

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

Durch Ersetzen say$1durch kann print$1.$/der Code auf älteren Perls ausgeführt werden, was 5 zusätzliche Zeichen kostet.

APL, 43 Zeichen

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

Dies funktioniert mit Dyalog APL . Ich habe es geschafft, ein paar Zeichen zu speichern, indem ich die Ausgabezeichenfolge generiert habe (alles danach ⊃). Ich werde eine Erklärung schreiben, wenn ich etwas Zeit habe!

So sieht die Ausgabe aus:

      ⍪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

Erklärung von rechts nach links:

• Zuerst konstruieren wir die Zeichenfolge, die in allen anderen Einträgen zu sehen ist:
  • 6↑⌽⎕A: ⎕Agibt uns eine Zeichenfolge des Großbuchstabens von A bis Z. Wir kehren es dann um ( ⌽) und nehmen ( ↑) die ersten 6 Zeichen davon und geben uns 'ZYXWVU'. (Rückblickend speichert dieser Ansatz keine Zeichen, aber ich lasse ihn, weil er besser passt.)
  • '!?,.',: Wir verketten ( ,) den String '!?,.'mit dem vorherigen Ergebnis.
  • (10↑10⌽⎕A),: Wir nehmen die ersten 10 Zeichen ( 10↑) des Alphabets, das zuerst zehnmal gedreht wird ( 10⌽), und verketten dies mit dem vorherigen Ergebnis. Als Beispiel für die Drehung 5⌽'abcdef'(die Saite wurde 'abcdef'fünfmal gedreht) erhalten wir 'cdefab'.
  • (⌽10↑⎕A),: Nehmen Sie die ersten 10 Zeichen des Alphabets, kehren Sie sie um und verketten Sie diese mit der vorherigen Zeichenfolge.
  • (1⌽⎕D),: ⎕Dgibt uns die Ziffern als Zeichenfolge von 0 bis einschließlich 9. Wir drehen dann ('⌽') diese Zeichenfolge um 1 und ergeben '1234567890'. Nach wie vor verketten wir dies mit dem vorherigen Ergebnis.
• Nachdem wir unseren String erstellt haben (der uns aufgrund der umgebenden Anführungszeichen 3 Zeichen aus der APL-Darstellung erspart hat), können wir unsere endgültige Ausgabe mit etwas Magie erstellen:
  • 3,/: Wir nehmen die Zeichenfolge in Gruppen von drei Zeichen und verketten sie.
  • Zum Abschluss verwenden wir ⍪unseren String-Vektor (eigentlich einen Vektor von Zeichenvektoren) entlang der ersten Dimension. Dies hat den Effekt, dass die Form von 38auf 38 1(eine 38x1-Matrix) geändert wird.

J, 66 62 45 Zeichen

Es stellte sich heraus, dass ich um die Hälfte zu schlau war.

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

ist alles was ich die ganze Zeit brauchte.

Vorher:

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

und:

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

R (75 Zeichen)

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

Was macht das?

• strsplit teilt eine Zeichenfolge in Teilzeichenfolgen auf, in diesem Fall in einzelne Zeichen
• embed ist eine wirklich nützliche Funktion, die einen Vektor in ein Array überlappender Elemente verwandelt
• Der Rest besteht nur darin, Spalten in der richtigen Reihenfolge zu indizieren und zu sortieren.

Dies erzeugt und druckt eine Reihe von Zeichen:

> 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 Zeichen:

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

Mathematica, 73

Ich bin unabhängig voneinander zu der gleichen Methode gekommen wie alle anderen:

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

Groovy, 73

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

All das kluge Zeug, das ich versuchte, erwies sich als länger als dumm.

C, 98 104 Zeichen

Da dies bisher noch niemand getan hat, dachte ich, ich würde versuchen, den String tatsächlich im laufenden Betrieb zu generieren, indem ich eine Art Lauflängencodierung für aufsteigende und absteigende Läufe verwende.

EDIT: Nach einer Reihe von Iterationen ist hier endlich eine "clevere" Lösung, die mit 98 Zeichen mit der kürzesten "dummen" Lösung in C verknüpft ist:

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

Der Code erfordert eine 8-Bit-Latin-1-Codierung (ISO-8859-1 oder Windows-1252), die auf allen gängigen Plattformen problemlos funktionieren sollte, die Quelle jedoch mit einer weniger beliebten 8-Bit-Codepage oder UTF- 8 wird nicht funktionieren.

Die Datenzeichenfolge wurde mit dem folgenden Emacs-Lisp erstellt:

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

Das "Twiddle" -Bit wird verwendet, um nicht druckbare ASCII-Steuerzeichen in der codierten Datenzeichenfolge zu vermeiden und dies i==0nur am Ende der Ausgabe sicherzustellen .

C, 98 Zeichen

Selbst in C können Sie ein kurzes Programm erhalten, indem Sie einfach aufeinanderfolgende Drillinge aus der Originalzeichenfolge drucken:

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

Ruby 69 65 62

Basierend auf einem Groovy-Beispiel

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 Zeichen:

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

Perl, 66 Zeichen:

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

wenn angerufen von:

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

D 124 Zeichen

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

JavaScript, 83 Zeichen

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

Beschlossen zu sehen, ob ich die Lösung von stephencarmody schlagen könnte . Das habe ich mir ausgedacht.

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]

Ich kenne Smalltalk nicht sehr gut, deshalb ist es ein bisschen seltsam für mich. Es wird kompiliert mit gstanderen nicht getestet.

Q ( 66 63 Zeichen)

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

Prolog, 131

Dies ist wahrscheinlich der Grund, warum Sie niemals Prolog-Einträge sehen. Der Zeilenumbruch ist erforderlich (tatsächlich reicht jedes Leerzeichen aus, es muss jedoch ein Leerzeichen vorhanden sein).

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

Probieren Sie es online aus!

Kannst du nicht mehr Golf spielen? Dies sind gewissermaßen <152 Bytes.

Gelee , 41 40 Bytes

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

Probieren Sie es online aus!

Könnte (noch) golfbar sein ...