Biorąc pod uwagę znak, wypisz (na ekran) cały układ klawiatury qwerty (ze spacjami i znakami nowej linii), który następuje po znaku. Przykłady wyjaśniają.

Wejście 1

f

Wyjście 1

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

Wejście 2

q

Wyjście 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

Wejście 3

m

Wyjście 3

(Program kończy się bez wyjścia)

Wejście 4

l

Wyjście 4

z x c v b n m

Najkrótszy kod wygrywa. (w bajtach)

PS

Akceptowane są dodatkowe znaki nowej linii lub dodatkowe spacje na końcu linii.

CJam, 42 40 bajtów

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

Sprawdź to tutaj.

Wyjaśnienie

"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 bajty

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

Pamiętaj, że niektórych znaków nie można wydrukować. Wypróbuj online w kompilatorze Pyth .

Jak to działa

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 bajtów

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

Licząc shebang jako 3, dane wejściowe są pobierane ze standardowego wejścia. Jeśli wiodącym nowej linii nie jest problemem dla wejść pi l, po czym /$_\n?/można zastąpić gołe $_zapisać 4.

Przykładowe użycie

$ 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 bajtów

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

Kod źródłowy używa kodowania CP437 . Wypróbuj online!

Testowe uruchomienie

$ 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

Jak to działa

♦                                      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 bajtów 105 110

Liczba wzrosła o 5 bajtów, ale bardziej poprawnie! Dzięki @ 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());}

Nie grał w golfa

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 bajtów

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

Używa tej samej techniki, co większość innych odpowiedzi. Sugestie mile widziane!

Rubin, 63 57 bajtów

Pobiera znak jako argument wiersza poleceń: ruby keyboard.rb e

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

TeaScript , 50 45 44 bajtów

TeaScript to JavaScript do gry w golfa.

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

Bez golfa i wyjaśnienia

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

Jeśli wiodący nowy wiersz nie jest dozwolony, gdy parametr ma wartość plub l, to 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 bajty

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

Wypróbuj online

Sed, 59 znaków

(Kod 58 znaków + opcja wiersza poleceń 1 znak.)

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

Przykładowy przebieg:

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 /./,'\& '

Dodatkowa spacja po mto zapobiega awariom programu, jeśli dane wejściowe to „m”.

Dzięki @manatwork za ~ 16 bajtów wskazówek

PHP, 88 bajtów

<?=$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)];

Wymaga -Fopcji wiersza poleceń, liczonej jako 3. Domyślne ustawienia .ini są przyjmowane (możesz wyłączyć lokalne .ini za pomocą -n).

Przykładowe użycie

$ 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 bajty

Edycja: Wytnij 20 bajtów za pomocą wskazówek z @Fatalize

Kod

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

Wyjaśnienie

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

Przykłady

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

"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$\<

Został przetestowany tutaj: Befunge-93 Interpreter .

Jak to działa

• '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' jest wypychany na stos.
• Liczba wartości, które należy odrzucić (na stałe @ZVD0FHJ:LNP^\<>,2B48X.T6R) N jest wypychana.
• Pierwsze N ​​wartości jest odrzucane, a pozostałe wartości są drukowane.

Uwaga

Wybrałem kodowanie, więc ciąg zaczyna się od @, aby pokrył się z programem. Ten ciąg jest generowany przy użyciu następującego kodu python:

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

Świnka - 102 bajtów

Gra w golfa:

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

Nie golfił i skomentował:

 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.

Reguła zezwalająca na dodatkowe znaki nowej linii pozwoliła mi zaoszczędzić prawie 10 bajtów ...

Java - 107 bajtów

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

Niegolfowany z odczytem klasy opakowania z 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 "));
    }
}

Gdyby spacje na początku linii były akceptowalne, moglibyśmy zmniejszyć do 99 bajtów:

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

Python 2, 58 67 63 bajtów ##

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

Pobiera dane wejściowe jako ciąg znaków lub znak. Dzieli ciąg na wejściu i drukuje wszystko po podziale.

(Gra w golfa po raz pierwszy, proszę delikatnie: P)

EDYCJA: Nie widziałem dodatkowych spacji wymaganych między postaciami, dodanych teraz

EDYCJA 2: Zmodyfikowana, aby była anonimową funkcją lambda i usuwa dodatkowy podzielony argument, oszczędzając 4 bajty

Rubin, 59 57 67 bajtów

Dodano spacje między literami

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

JavaScript, 88 bajtów

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

(nie ma potrzeby wprowadzania spacji po pierwszym znaku, ponieważ nigdy nie trafia on do wyjścia)

Ostrzega klawiaturę podczas połączenia s("some letter"). Można go również wykonać za pomocą document.write()lub console.log(), ale hej, jest dłuższy: P

Próbny:

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 bajty

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

Nie golfowany:

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

Jestem tu nowy, dopiero co odkryłem tę stronę. Nie mam pojęcia, czy opublikowałem poprawnie, czy T-SQL jest dozwolony, ale wiem, że powyższa procedura działa.

O 2.2, 48 46 znaków

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

Przykładowy przebieg:

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

O, 61 znaków

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

Przykładowy przebieg:

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 bajtów

Japt to skrócona wersja Ja vaScri pt . Interpretator

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

?Powinna być niecenzuralny char Unicode U + 0086.

Jak to działa

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

Teraz bije CJam! :) Sugestie mile widziane!

Wersja niekonkurencyjna, 12 bajtów

;Dv qU g1 ¬¸

Od 11 stycznia dodałem nową fajną funkcję do Japt: jeśli program zawiera przecinek wiodący, zmienne ABCDEFGHIJLsą przedefiniowywane do różnych wartości. Djest ustawiony na "QWERTYUIOP\nASDFGHJKL\nZXCVBNM", więc ;Dvwystarczy zastąpić ciąg tutaj.

Gema, 56 znaków

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

Przykładowy przebieg:

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

Kod maszynowy 8086 + DOS, 61 bajtów

Hexdump (z widokiem ASCII po prawej):

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.

Kod źródłowy asemblera (może być skompletowany z tasm):

    .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

Dwie zabawne rzeczy tutaj:

1. Przesunięcie qwertyłańcucha wynosi 0x011e. Górny bajt to 1, który jest numerem funkcji DOS do wprowadzania znaków. To oszczędza 1 bajt w kodzie.
2. Wszystkie małe litery mają ustawiony bit 5. Kiedy robisz ANDz 0x20, wszystkie są zamieniane w przestrzeń, która jest następnie drukowana. Jeśli poprzedni znak był bajtem końca linii, zostaje zamieniony na 0 i nie jest wyprowadzane spacja. Służy to do uniknięcia nonsensownej sekwencji 0d 20 0a 20na końcu linii.

Jedna prawie zabawna rzecz:

Próbowałem wyszukać znak wejściowy zaczynając od adresu 0 (co zmniejszyło rozmiar programu o 2 bajty), zamiast zwykłego miejsca (początek łańcucha). To prawie działało; jednak nie udało się wprowadzić danych t, ponieważ sam kod zawiera bajt t(jako część kodowania skoku warunkowego). Tak więc t, wyświetliłby kilka śmieciowych bajtów:

𝔼𝕊𝕄𝕚𝕟, 32 znaki / 79 bajtów

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

Try it here (Firefox only).

Przynajmniej wygrywam w liczbie znaków ... (Liczba bajtów to inna historia.)

O tak, właśnie zdałem sobie sprawę, że zaimplementowałem skróty indeksu ( ⎖1zamiast [1]) jakiś czas temu. Głupi ja!

C ++, 129, 112 97 bajtów

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

Nie golfowany:

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

Partia, 206 + 2 = 208 bajtów

Ponieważ wykorzystuje to opóźnione rozszerzenie, należy je wywołać CMD /V /C keyboard.cmd <letter>, dodając 1 2 dla /Vprzełącznika.

@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 bajtów

Wiem, że jest trochę duży, ale to wszystko, co wiem, jak teraz zrobić!

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 bajtów

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

Wypróbuj sam, albo zamień 1 $ na żądany znak, albo stwórz skrypt #! / Bin / bash.

Oto kilka próbek z cygwina:

$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

Nie jest najkrótszy, ale wciąż jestem z tego dumny!