Враховуючи характер, виведіть (на екран) всю розкладку клавіатури qwerty (з пробілами та новими рядками), що слідує за символом. На прикладах це ясно.

Введення 1

f

Вихід 1

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

Введення 2

q

Вихід 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

Введення 3

m

Вихід 3

(Програма закінчується без виводу)

Введення 4

l

Вихід 4

z x c v b n m

Найкоротший код виграє.(у байтах)

PS

Додаткові нові рядки або додаткові пробіли в кінці рядка приймаються.

CJam, 42 40 байт

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

Перевірте це тут.

Пояснення

"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 байти

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

Зауважте, що деякі символи не можна друкувати. Спробуйте його в Інтернеті компіляторі Pyth .

Як це працює

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 байт

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

Підрахувавши шебанг як 3, вхід береться від stdin. Якщо ведучий символ нового рядка не є проблемою для входів pі l, потім /$_\n?/може бути замінений на голій , $_щоб зберегти 4.

Використання зразків

$ 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 байт

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

У вихідному коді використовується кодування CP437 . Спробуйте в Інтернеті!

Тестовий запуск

$ 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

Як це працює

♦                                      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 байт 105 110

Кількість піднялася на 5 байт, але правильніше! Дякую @ 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());}

Без гольфу

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 байт

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

Використовується та ж методика, що і більшість інших відповідей. Пропозиції Ласкаво просимо!

Рубі, 63 57 байт

Приймає символ як аргумент командного рядка: ruby keyboard.rb e

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

TeaScript , 50 45 44 байт

TeaScript - це JavaScript для гольфу.

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

Необурені і пояснення

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

Якщо ведучий символ нового рядка не допускається , якщо параметр pабо l, то 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:]

Try it online

Sed, 59 characters

(58 characters code + 1 character command line option.)

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

Sample run:

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

The extra space after m is to prevent the program from crashing if the input is 'm'.

Thanks to @manatwork for ~16 bytes of tips

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

Requires the -F command line option, counted as 3. Default .ini setting are assumed (you may disable your local .ini with -n).

Sample Usage

$ 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

Edit: Cut 20 bytes with tips from @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),!.

Explanation

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

Examples

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

It has been tested here: Befunge-93 Interpreter.

How it works

• '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' is pushed on the stack.
• The number of values to discard (hardcoded in @ZVD0FHJ:LNP^\<>,2B48X.T6R) N is pushed.
• First N values are discarded and the remaining values are printed.

Note

I picked the encoding so the string starts with @ in order to overlap with the program. This string is generated with the following python code:

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

Golfed script:

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 and commented:

 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.

The rule allowing extra newlines saved me almost 10 bytes...

Java - 107 bytes

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

Ungolfed with wrapper-class reading from 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 "));
    }
}

If spaces at start-of-line were acceptable, we could go down to 99 bytes:

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

Takes input as a string or char. Splits the string at the input and prints off everything after the split.

(First time code-golfing, please be gentle :P )

EDIT: Didn't see the additional spaces required between characters, added now

EDIT 2: Modified to be an anonymous lambda function and removing the additional split arg, saving 4 bytes

Ruby, 59 57 67 bytes

Added spaces between letters

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

(no need in the space after the first char, as it never gets to the output)

Alerts the keyboard when you call s("some letter"). Can be also made with document.write() or console.log(), but hey, it's longer :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

I'm new here, only just discovered this site. No idea if I've posted correctly or if T-SQL is allowed but I know the procedure above works.

O 2.2, 48 46 characters

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

Sample run:

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

O, 61 characters

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

Sample run:

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 is a shortened version of JavaScript. Interpreter

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

The ? should be the unprintable Unicode char U+0086.

How it works

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

Now beating CJam! :) Suggestions welcome!

Non-competing version, 12 bytes

;Dv qU g1 ¬¸

As of Jan 11, I've added a cool new feature to Japt: If the program contains a leading comma, the variables ABCDEFGHIJL are redefined to various values. D is set to "QWERTYUIOP\nASDFGHJKL\nZXCVBNM", so ;Dv is enough to replace the string here.

Gema, 56 characters

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

Sample run:

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 machine code + DOS, 61 bytes

Hexdump (with ASCII view on the right):

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 source code (can be assembled with 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

Two fun things here:

1. The offset of the qwerty string is 0x011e. The upper byte of it is 1, which is the DOS function number for character input. This saves 1 byte in the code.
2. All lower-case letters have bit 5 set. When doing an AND with 0x20, they are all turned into a space, which is then printed. If the previous char was an end-of-line byte, it gets turned into 0, and no space is output. This is used to avoid the nonsensical sequence 0d 20 0a 20 at end of line.

One almost-fun thing:

I tried to search for the input char starting at address 0 (that decreased program size by 2 bytes), instead of the usual place (start of the string). This almost worked; however, it failed for input t, because the code itself contains the byte t (as part of the encoding of a conditional jump). So for t, it would output a few junk bytes:

𝔼𝕊𝕄𝕚𝕟, 32 chars / 79 bytes

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

Try it here (Firefox only).

At least I'm winning in char count... (Byte count's a different story.)

Oh yeah, just realized that I implemented index shortcuts (⎖1 instead of [1]) awhile back. Silly me!

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

Because this uses delayed expansion you need to invoke it with CMD /V /C keyboard.cmd <letter>, so adding 12 for the /V switch.

@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

I know its a bit large but its all I know how to do right now!

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'

Try it yourself, either replace $1 with desired character or make a #!/bin/bash script.

Here are some samples from 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

It's not the shortest, but I'm still proud of it!