Geben Sie für ein bestimmtes Zeichen das gesamte QWERTY-Tastaturlayout (mit Leerzeichen und Zeilenumbrüchen) auf dem Bildschirm aus, das dem Zeichen folgt. Die Beispiele machen es deutlich.

Eingang 1

f

Ausgang 1

g h j k l
z x c v b n m

Eingang 2

q

Ausgang 2

w e r t y u i o p
a s d f g h j k l
z x c v b n m

Eingang 3

m

Ausgang 3

(Programm wird ohne Ausgabe beendet)

Eingang 4

l

Ausgang 4

z x c v b n m

Kürzester Code gewinnt. (in Bytes)

PS

Zusätzliche Zeilenumbrüche oder zusätzliche Leerzeichen am Ende einer Zeile werden akzeptiert.

CJam, 42 40 Bytes

"wertyuiop asdfghjkl zxcvbnm"q/W=S%Sf*N*

Teste es hier.

Erläuterung

"we...nm"
     e# Push the letters in order, without q. We don't need q, because it will never
     e# be part of the output.
q/   e# Split the string around the input. If the input is "q", the entire string
     e# will go into a single chunk.
W=   e# Select the last chunk.
S%   e# Split the string around spaces, discarding empty segments (only relevant for the 
     e# first segment if the input is "p" or "l").
Sf*  e# Join each line by spaces.
N*   e# Join the lines by linefeeds.

Pyth, 33 Bytes

jjL\ cec."`zÈ´ýß44,ûtKÕÀ@"z\`

Beachten Sie, dass einige Zeichen nicht druckbar sind. Versuchen Sie es online im Pyth-Compiler .

Wie es funktioniert

jjL\ cec."`z…"z\`

        ."`z…"     Unpack …, with lowest character '`' and highest character `z`.
       c      z    Split at occurrences of the input (z).
      e            Retrieve the last resulting chunk.
     c         \`  Split into rows, at backticks.
 jL\               Separate the characters of each row by spaces.
j                  Separate the rows by linefeeds.

Perl, 56 Bytes

#!perl -p
'qwertyuiop
asdfghjkl
zxcvbnm'=~/$_
?/;$_=$';s/\B/ /g

Zählt man den Shebang als 3, wird die Eingabe von stdin übernommen. Wenn ein führender Zeilenumbruch kein Problem mit Eingaben pund ist l, /$_\n?/kann er durch einen leeren ersetzt werden $_, um 4 zu sparen.

Beispielnutzung

$ echo g|perl qwerty.pl
h j k l
z x c v b n m

$ echo v|perl qwerty.pl
b n m

GS2 , 38 37 Bytes

♦wertyuiop asdfghjkl zxcvbnm♣B3$,■♪2◙

Der Quellcode verwendet die CP437- Codierung. Probieren Sie es online!

Testlauf

$ base64 -d > qwerty.gs2 <<< BHdlcnR5dWlvcCBhc2RmZ2hqa2wgenhjdmJubQVCMyQs/g0yCg==
$ wc -c qwerty.gs2
37 qwerty.gs2
$ echo -n f | gs2 qwerty.gs2
g h j k l
z x c v b n m

Wie es funktioniert

♦                                      Begin string literal.
 wertyuiop asdfghjkl zxcvbnm
                            ♣          End string literal.
                             B         Swap the string with the input.
                              3        Split the string at the input character.
                               $       Select the last chunk.
                                ,      Split the selected chunk at spaces.
                                 ■     Map over the resulting array:
                                  ♪      Push ' '.
                                   2     Join the characters, separating by ' '.
                                    ◙    Push a linefeed.

C #, 112 Bytes 105 110

Die Anzahl ist um 5 Bytes gestiegen, aber korrekter! Danke @ MartinBüttner !!

void c(char i){System.Console.Write(@"q w e r t y u i o p
a s d f g h j k l
z x c v b n m".Split(i)[1].Trim());}

Nicht golfen

void c(char i)
{
    System.Console.Write(@"q w e r t y u i o p
    a s d f g h j k l
    z x c v b n m".Split(i)[1].Trim());
}

JavaScript (ES6), 60 Byte

x=>[...`qwertyuiop
asdfghjkl
zxcvbnm`].join` `.split(x)[1]

Verwendet die gleiche Technik wie die meisten anderen Antworten. Vorschläge willkommen!

Ruby, 63 57 Bytes

Nimmt das Zeichen als Kommandozeilenargument: ruby keyboard.rb e

"qwertyuiop
asdfghjkl
zxcvbnm".scan$*[0]
puts$'.chars*' '

TeaScript , 50 45 44 Bytes

TeaScript ist JavaScript zum Golfen.

`qwertyuiop
asdfghjkl
zxcvbnm`.s×[1]s(b)j(p)

Ungolfed und Erklärung

`qwertyuiop
asdfghjkl
zxcvbnm`.s(x)[1]s(b)j(p)

      // Implicit: x = input string
`...` // Take the qwerty string,
.s(x) // and split it at the input.
[1]   // Take the second item from this,
s(b)  // split it into chars,
j(p)  // and join the result with spaces.
      // Implicit: output final expression

JavaScript ES6, 73

f=x=>[...(k=`qwertyuiop
asdfghjkl
zxcvbnm`).slice(k.search(x)+1)].join` `

Wenn ein führender Zeilenumbruch nicht zulässig ist, wenn der Parameter poder ist l, dann 83

f=x=>(k=`q w e r t y u i o p
a s d f g h j k l
z x c v b n m`).slice(k.search(x)+2)

Python, 83 Bytes

lambda c,s="q w e r t y u i o p\na s d f g h j k l\nz x c v b n m":s[s.index(c)+2:]

Probieren Sie es online aus

Sed, 59 Zeichen

(58 Zeichen Code + 1 Zeichen Befehlszeilenoption.)

s/./&qwertyuiop\nasdfghjkl\nzxcvbnm/
s/(.).*\1//
s/\w/& /g

Probelauf:

bash-4.3$ echo -n 'f' | sed -r 's/./&qwertyuiop\nasdfghjkl\nzxcvbnm/;s/(.).*\1//;s/\w/& /g'
g h j k l 
z x c v b n m 

Ruby, 86 87 83 71 66

puts"qwertyuiop
asdfghjkl
zxcvbnm ".split($*[0])[1].gsub /./,'\& '

Das zusätzliche Leerzeichen nach msoll verhindern, dass das Programm abstürzt, wenn die Eingabe 'm' ist.

Vielen Dank an @manatwork für ~ 16 Bytes an Tipps

PHP, 88 Bytes

<?=$m[1&ereg("$argn.(.*)",'q w e r t y u i o p
a s d f g h j k l
z x c v b n m',$m)];

Erfordert die -FBefehlszeilenoption, die als 3 gezählt wird. Es wird die Standardeinstellung INI angenommen (Sie können Ihre lokale INI mit deaktivieren -n).

Beispielnutzung

$ echo g|php -F qwerty.php
h j k l
z x c v b n m

$ echo v|php -F qwerty.php
b n m

Prolog (SWI), 153-133 Bytes

Bearbeiten: Schneiden Sie 20 Bytes mit Tipps von @Fatalize

Code

b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]).
p(X):-name(X,C),b(`q w e r t y u i o p \r\na s d f g h j k l \r\nz x c v b n m`,C),!.

Erläuterung

p(X):-name(X,C),                                                               % Get charcode of input
      b(`q w e r t y u i o p \r\na s d f g h j k l \r\nz x c v b n m`,C),!.    % Get keyboard chars as charcodes and call b
b([A,_|T],[H]):-A=H,                                                           % If list head is input element
                writef('%s',[T]);                                              % Interpret list as charcodes and print as string
                b(T,[H]).                                                      % Else remove first element of list and try again

Beispiele

>p(f).
g h j k l 
z x c v b n m

>p(q).
w e r t y u i o p 
a s d f g h j k l 
z x c v b n m

Befunge, 122 Bytes

"m n b v c x z"25*"l k j h g f d s a"v
v1-")"g2-"U"~"q w e r t y u i o p"*25<
>-:#v_$>:#,_@ZVD0FHJ:LNP^\<>,2B48X.T6R
^1$\<

Es wurde hier getestet: Befunge-93 Interpreter .

Wie es funktioniert

• 'q w e r t y u i o p\na s d f g h j k l\nz x c v b n m' wird auf den Stapel geschoben.
• Die Anzahl der zu verwerfenden (fest codierten @ZVD0FHJ:LNP^\<>,2B48X.T6R) Werte in N wird gepusht.
• Die ersten N Werte werden verworfen und die verbleibenden Werte gedruckt.

Hinweis

Ich habe die Codierung so gewählt, dass die Zeichenfolge mit beginnt, @um sie mit dem Programm zu überlappen. Diese Zeichenfolge wird mit dem folgenden Python-Code generiert:

import string
letters = string.ascii_lowercase
base = 'q w e r t y u i o p a s d f g h j k l z x c v b n m'
print(''.join(chr(base.index(x) + 32 + 9 + 3) for x in letters))

Mumps - 102 Bytes

Golf-Skript:

S A="qwertyuiopasdfghjklzxcvbnm",B=0 R P F I=1:1:$L(A) S Q=$E(A,I) W:B Q," " X:"qpl"[Q "W !" S:Q=P B=1

Ungolfed und kommentiert:

 S A="qwertyuiopasdfghjklzxcvbnm" ; Need the qwerty order
 S B=0 ; boolean flag for printing, default to false.
 R P   ; read from stdin into P
 F I=1:1:$L(A) D   ; Count I from 1 to length of qwerty variable; do all of the following:
 . S Q=$E(A,I)     ; Extract 1 letter (at position I) from A and save in Q.
 . W:B Q," "       ; If our print flag (B) is true, print the letter in Q & a space.
 . X:"qpl"[Q "W !" ; If Q is q, p or l, write a cr/lf
 . S:Q=P B=1       ; If Q == P (stdin) change our print flag from false to true.

Die Regel, die zusätzliche Zeilenumbrüche zulässt, hat mir fast 10 Bytes erspart ...

Java - 107 Bytes

void q(char c){System.out.print("qwertyuiop\nasdfghjkl\nzxcvbnm ".split(""+c)[1].replaceAll("\\w","$0 "));}

Ungolfed mit Wrapper-Klasse Lesen von System.in

public class Qwerty {

    public static void main(String[] args) {
        new Qwerty().q(new java.util.Scanner(System.in).next().charAt(0));
    }
    void q(char c) {
        System.out.print("qwertyuiop\nasdfghjkl\nzxcvbnm ".split(""+c)[1].replaceAll("\\w","$0 "));
    }
}

Wenn Leerzeichen am Zeilenanfang akzeptabel wären, könnten wir auf 99 Bytes reduzieren:

void q(char c){System.out.print("qwertyuiop\nasdfghjkl\nzxcvbnm ".split(""+c)[1].replace(""," "));}

Python 2, 58 67 63 Bytes ##

lambda x:" ".join("qwertyuiop\nasdfghjkl\nzxcvbnm".split(x)[1])

Nimmt Eingaben als Zeichenfolge oder Zeichen. Teilt den String am Eingang und druckt alles nach dem Teilen aus.

(Zum ersten Mal Code-Golfen, bitte seien Sie vorsichtig: P)

BEARBEITEN: Es wurden keine zusätzlichen Leerzeichen zwischen den Zeichen hinzugefügt

BEARBEITEN 2: Geändert, um eine anonyme Lambda-Funktion zu sein und das zusätzliche aufgeteilte Argument zu entfernen, wodurch 4 Bytes gespart werden

Rubin, 59 57 67 Bytes

Leerzeichen zwischen Buchstaben hinzugefügt

puts"qwertyuiop\nasdfghjkl\nzxcvbnm".split(gets.chop)[-1].chars*' '

JavaScript, 88 Bytes

function s(d){alert("qw e r t y u i o p\na s d f g h j k l\nz x c v b n m".split(d)[1])}

(Keine Notwendigkeit im Leerzeichen nach dem ersten Zeichen, da es nie zur Ausgabe kommt)

Benachrichtigt die Tastatur, wenn Sie anrufen s("some letter"). Kann auch mit document.write()oder gemacht werden console.log(), aber hey, es ist länger: P

Demo:

function s(d){alert("qw e r t y u i o p\na s d f g h j k l\nz x c v b n m".split(d)[1])}

s(prompt("Enter the key"));

SQL (MS T-SQL), 172 Bytes

CREATE PROC c @I CHAR(1) AS DECLARE @S CHAR(49) SET @S = 'w e r t y u i o p' + CHAR(13) + 'a s d f g h j k l' + CHAR(13) + 'z x c v b n m' PRINT RIGHT(@S,LEN(@S)-CHARINDEX(@I,@S))

Ungolfed:

CREATE PROC c                           -- Create a procedure named "c"
    @I CHAR(1)                          -- Which is invoked with a single character input (@I)
AS

DECLARE @S CHAR(49) = 'w e r t y u i o p' + CHAR(13) + 'a s d f g h j k l' + CHAR(13) + 'z x c v b n m' -- Initialise the entire output omitting "q " as @S
PRINT RIGHT(@S,LEN(@S)-CHARINDEX(@I,@S))    -- Use the charindex funtion to effectively substring @S

Ich bin neu hier, habe diese Seite gerade erst entdeckt. Keine Ahnung, ob ich richtig gepostet habe oder ob T-SQL erlaubt ist, aber ich weiß, dass das obige Verfahren funktioniert.

O 2,2, 48 46 Zeichen

"qwertyuiop
asdfghjkl
zxcvbnm
"i/r;s{n.U=ST?}d

Probelauf:

bash-4.3$ ./o keyboard.o <<< 'f'
g h j k l 
z x c v b n m 

O, 61 Zeichen

"qwertyuiop\nasdfghjkl\nzxcvbnm\n"i/r;""/rl{.o"\n"={}{' o}?}d

Probelauf:

bash-4.3$ java xyz.jadonfowler.o.O keyboard.o <<< 'f'
g h j k l 
z x c v b n m 

Japt , 49 42 41 40 38 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt . Dolmetscher

`qØÆyuiop\n?dfghjkl\nzxcvbnm`qU g1 ¬qS

Das ?sollte das nicht druckbare Unicode-Zeichen U + 0086 sein.

Wie es funktioniert

          // Implicit: U = input char
`...`     // Take the compressed string and decompress it.
qU g1     // Split the string at the input and take the second item.
¬qS       // Split into chars, then join with spaces.
          // Implicit: output final expression

Schlagen Sie jetzt CJam! :) Vorschläge willkommen!

Nicht konkurrierende Version, 12 Bytes

;Dv qU g1 ¬¸

Ab 11. Januar habe ich hinzugefügt ein cooles neues Feature Japt: Wenn das Programm eine führende Komma enthält, die Variablen ABCDEFGHIJLsind auf verschiedene Werte neu definiert. Dist auf gesetzt "QWERTYUIOP\nASDFGHJKL\nZXCVBNM", reicht also ;Dvaus, um die Zeichenfolge hier zu ersetzen.

Gema, 56 Zeichen

?=@subst{\\A\*?=\;\?=\? ;qwertyuiop\nasdfghjkl\nzxcvbnm}

Probelauf:

bash-4.3$ echo -n 'f' | gema '?=@subst{\\A\*?=\;\?=\? ;qwertyuiop\nasdfghjkl\nzxcvbnm}'
g h j k l 
z x c v b n m 

8086 Maschinencode + DOS, 61 Bytes

Hexdump (mit ASCII-Ansicht rechts):

B8 1E 01 8B F8 CD 21 B1 1F F2 AE 8B F7 AC 8A D0 ......!.........
B4 02 CD 21 80 E2 20 74 02 CD 21 E2 F0 C3 71 77 ...!.. t..!...qw
65 72 74 79 75 69 6F 70 0D 0A 61 73 64 66 67 68 ertyuiop..asdfgh
6A 6B 6C 0D 0A 7A 78 63 76 62 6E 6D 0D          jkl..zxcvbnm.

Assembly-Quellcode (kann mit tasm zusammengestellt werden):

    .MODEL TINY

    .CODE
    org 100h

    MAIN PROC

    mov ax, offset qwerty ; sets ah=1 (coincidence)
    mov di, ax      ; di points to the string
    int 21h         ; reads a char from keyboard into al

    mov cl, 31      ; cx is the length of the string
    repne scasb     ; look for the char
    mov si, di      ; si now points beyond the found char

myloop:
    lodsb           ; load a char
    mov dl, al
    mov ah, 2
    int 21h         ; output the char

    and dl, 20h     ; if it's a letter, set it to a space
    jz print_done   ; if it's not a letter, don't print a space
    int 21h         ; if it's a letter, print a space
print_done:
    loop myloop     ; repeat until end of string

    ret

qwerty db 'qwertyuiop',13,10,'asdfghjkl',13,10,'zxcvbnm',13

    MAIN ENDP
    END MAIN

Zwei lustige Dinge hier:

1. Der Versatz der qwertyZeichenfolge ist 0x011e. Das obere Byte davon ist 1, was die DOS-Funktionsnummer für die Zeicheneingabe ist. Dies spart 1 Byte im Code.
2. Bei allen Kleinbuchstaben ist Bit 5 gesetzt. Wenn Sie ANDmit machen 0x20, werden sie alle in ein Leerzeichen umgewandelt, das dann gedruckt wird. Wenn das vorherige Zeichen ein Zeilenende-Byte war, wird es auf 0 gesetzt und es wird kein Leerzeichen ausgegeben. Dies wird verwendet, um die unsinnige Abfolge 0d 20 0a 20am Zeilenende zu vermeiden .

Eine fast lustige Sache:

Ich habe versucht, nach dem Eingabezeichen zu suchen, beginnend mit der Adresse 0 (die die Programmgröße um 2 Byte verringert hat), anstelle des üblichen Ortes (Beginn der Zeichenfolge). Das hat fast funktioniert; Die Eingabe tschlug jedoch fehl , da der Code selbst das Byte enthält t(als Teil der Codierung eines bedingten Sprungs). Also twürde es ein paar Junk-Bytes ausgeben:

𝔼𝕊𝕄𝕚𝕟 32 Zeichen / 79 Byte

⟦ɘƄ瀛ذ鸊ް΀ꀆဓƘ᳀ᘁ堍怍訁码聮Ęݠⶰ䀀#]ø⬭Čï⎖1

Try it here (Firefox only).

Zumindest gewinne ich in Char Count ... (Byte Count ist eine andere Geschichte.)

Oh ja, habe gerade festgestellt, dass ich vor einiger Zeit Indexverknüpfungen ( ⎖1anstelle von [1]) implementiert habe . Wie dumm von mir!

C ++, 129, 112 97 Bytes

#include<string>
#include<cstdio>
void o(char c){puts(strstr("qwertyuiopasdfghjklzxcvbnm",&c));}

Ungolfed:

#include<string>
#include<cstdio>
void o(char c)
{
    puts(strstr("qwertyuiopasdfghjklzxcvbnm",&c));
}

Batch, 206 + 2 = 208 Bytes

Da dies eine verzögerte Erweiterung verwendet, müssen Sie sie mit aufrufen CMD /V /C keyboard.cmd <letter>und 1 2 für den /VSwitch hinzufügen .

@echo off
set a=q w e r t y u i o p
set b=a s d f g h j k l
set c=z x c v b n m
if not "!a:*%1 =!"=="!a!" echo !a:*%1 =!
if not "!a:*%1=!!b:*%1 =!"=="!a!!b!" echo !b:*%1 =!
if not %1==m echo !c:*%1 =!

Python, 109 Bytes

Ich weiß, es ist ein bisschen groß, aber es ist alles, was ich jetzt tun kann!

def kb(c): 
 s = "q w e r t y u i o p \n a s d f g h j k l \n z x c v b n m"
 a = s.split(c)
 print(a[1])

Bash, 80 Bytes

x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*$1}|sed 's/./& /g'

Versuchen Sie es selbst, ersetzen Sie entweder $ 1 durch das gewünschte Zeichen oder erstellen Sie ein #! / Bin / bash-Skript.

Hier einige Beispiele von Cygwin:

$x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*q}|sed 's/./& /g'
w e r t z u i o p
a s d f g h j k l
y x c v b n m

$x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*m}|sed 's/./& /g'

$x="qwertzuiop\nasdfghjkl\nyxcvbnm"&&echo -e ${x#*h}|sed 's/./& /g'
j k l
y x c v b n m

Es ist nicht die kürzeste, aber ich bin trotzdem stolz darauf!