Saída do teclado qwerty

37

Dado um caractere, imprima (para a tela) todo o layout do teclado qwerty (com espaços e novas linhas) que segue o caractere. Os exemplos deixam claro.

Entrada 1

f

Saída 1

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

Entrada 2

q

Saída 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

Entrada 3

m

Saída 3

(O programa termina sem saída)

Entrada 4

l

Saída 4

z x c v b n m

O menor código vence. (em bytes)

PS

Novas linhas extras ou espaços extras no final de uma linha são aceitos.

ghosts_in_the_code
fonte
Uma função é suficiente ou você precisa de um programa completo que leia / grave no stdin / stdout?
agtoever
11
@agtoever Conforme meta.codegolf.stackexchange.com/questions/7562/… , é permitido. No entanto, a função ainda deve ser exibida na tela.
ghosts_in_the_code
@agtoever Experimente este link. meta.codegolf.stackexchange.com/questions/2419/…
ghosts_in_the_code
11
estão levando espaço antes que uma linha seja permitida?
Sahil Arora
11
@SahilArora Nope.
ghosts_in_the_code

Respostas:

19

CJam, 42 40 bytes

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

Teste aqui.

Explicação

"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.
Martin Ender
fonte
O que é e#? É a sintaxe do CJam para um comentário? Desde já, obrigado.
AL
@AL sim é.
Martin Ender
11

Pitão, 33 bytes

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

Observe que alguns caracteres não são imprimíveis. Experimente online no Pyth Compiler .

Como funciona

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.
Dennis
fonte
Ah cara, eu tinha acabado de criar meu primeiro programa Pyth (apenas 38 bytes!), Então você apareceu ... +1 BTW, acho que \ é equivalente a d.
ETHproductions
Opa, acho que não é o mesmo ... o que é diferente?
ETHproductions
11
@ETHproductions @Dennis A mesma razão pela qual md5não produz 5 espaços. dé a variável padrão que itera através do argumento iterável do operador de mapa. E jL\ <list>é simplesmente um atalho para o operador de mapa mj\ d<list>.
Jakube
11
@Jakube Oh, isso faz sentido. Obrigado!
Dennis
10

Perl, 56 bytes

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

Contando o shebang como 3, a entrada é obtida de stdin. Se uma nova linha líder não for uma preocupação para insumos pe l, /$_\n?/poderá ser substituída por uma simples $_para salvar 4.


Uso da amostra

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

$ echo v|perl qwerty.pl
b n m
primo
fonte
2
Obrigado por me\K ensinar sobre !
Dom Hastings
O @DomHastings, nesse caso, não era realmente necessário para a contagem de bytes, s/.\B/$& /gfuncionaria igualmente bem. Um exemplo melhor .
primo
6

GS2 , 38 37 bytes

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

O código-fonte usa a codificação CP437 . Experimente online!

Execução de teste

$ 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

Como funciona

♦                                      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.
Dennis
fonte
6

C #, 112 bytes 105 110

A contagem aumentou em 5 bytes, mas mais correta! Obrigado @ 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());}

Sem golfe

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());
}
Johan
fonte
5

JavaScript (ES6), 60 bytes

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

Usa a mesma técnica que a maioria das outras respostas. Sugestões são bem-vindas!

ETHproductions
fonte
Você pode explicar por que você usa o "...". Eu tento sem JSFiddle e ainda está trabalhando?
23715 Awashi
@Awashi É um operador de spread . Ele separa a string em uma matriz de caracteres. Sem ele .join` `, nada faria e não haveria espaço no resultado.
user81655
@ user81655 Tank you
Awashi
4

Ruby, 63 57 bytes

Toma o caractere como argumento da linha de comando: ruby keyboard.rb e

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

TeaScript , 50 45 44 bytes

TeaScript é JavaScript para jogar golfe.

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

Ungolfed e explicação

`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
ETHproductions
fonte
3

JavaScript ES6, 73

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

Se uma nova linha principal não for permitida quando o parâmetro for pou 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)
edc65
fonte
3

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

Experimente online

Mego
fonte
3

Sed, 59 caracteres

(Código de 58 caracteres + opção de linha de comando de 1 caractere.)

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

Exemplo de execução:

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 
homem a trabalhar
fonte
3

Ruby, 86 87 83 71 66

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

O espaço extra a seguir mé para impedir que o programa trave se a entrada for 'm'.

Obrigado a @manatwork por ~ 16 bytes de dicas

SnoringFrog
fonte
Deixe-me adivinhar ... Muitos códigos Python da última vez?
manatwork
11
Algumas pequenas alterações de sintaxe: ARGV$*; each_charchars; do.. end{.. }; printf$><<+ %levaria a isto: "qwertyuiop↵asdfghjkl↵zxcvbnm".split($*[0])[1].chars{|i|$><<"%s "%i}. Mais em Dicas para jogar golfe em Ruby .
24515 manatwork
@manatwork Primeira vez tentando jogar golfe em Ruby, obrigado pelas dicas / link!
SnoringFrog
11
Vejo que você não recebeu a dica no meu primeiro comentário. Em Ruby, não há necessidade de aspas triplas em torno de cadeias de linhas múltiplas. (Na verdade, eu não tinha idéia até agora que aceitou por Ruby.)
manatwork
11
Os espaços principais na saída são bastante feios. Como .na expressão regular não corresponde \n, por padrão, um melhor uso que para o espaçamento: puts"qwertyuiop↵asdfghjkl↵zxcvbnm ".split($*[0])[1].gsub(/./,'\& '). Embora o comprimento do código permaneça o mesmo.
manatwork
2

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

Requer a -Fopção de linha de comando, contada como 3. A configuração .ini padrão é assumida (você pode desativar o .ini local com -n).


Uso da amostra

$ 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
primo
fonte
2

Prolog (SWI), 153 133 bytes

Editar: Corte 20 bytes com dicas de @Fatalize

Código

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

Explicação

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

Exemplos

>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
Emigna
fonte
Usando o SWI-Prolog, você pode encurtar a atom_codespeça usando as aspas que delimitam os códigos de sequência (para substituir diretamente L na chamada de bcom a sequência).
Fatalize
@Fatalize cool! Como estou usando o SWI-Prolog para testar de qualquer maneira, parece uma ótima idéia.
Emigna
Além disso, usando b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]). vez de 2 regras diferentes para bé 7 bytes mais curto. Normalmente, é sempre mais curto mesclar todas as regras em uma única com ORs, em ;vez de escrever várias regras, porque você evita repetir o nome e os parâmetros do predicado e também evita um avanço de linha;)
Fatalize
Faz tanto tempo desde que aprendi o Prolog que esqueci totalmente que você podia OU assim. Ótima dica! Obrigado :)
Emigna
2

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

Foi testado aqui: Intérprete Befunge-93 .

Como funciona

  • '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' é empurrado na pilha.
  • O número de valores a serem descartados (codificado em @ZVD0FHJ:LNP^\<>,2B48X.T6R ) N é pressionado.
  • Os primeiros N valores são descartados e os demais são impressos.

Nota

Eu escolhi a codificação para que a string comece com @ fim de se sobrepor ao programa. Essa sequência é gerada com o seguinte código 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))
Vincent
fonte
11
Boa primeira resposta! Bem-vindo ao Code Golf SE. (Eu sou novo também.)
ghosts_in_the_code
1

Caxumba - 102 bytes

Script de golfe:

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 e comentou:

 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.

A regra que permite novas linhas extras me salvou quase 10 bytes ...

zmerch
fonte
1

Java - 107 bytes

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

Ungolfed com leitura de classe de wrapper de 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 "));
    }
}

Se os espaços no início da linha forem aceitáveis, podemos reduzir para 99 bytes:

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

Python 2, 58 67 63 bytes ##

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

Recebe a entrada como uma sequência ou caractere. Divide a sequência na entrada e imprime tudo após a divisão.

(Código de golfe pela primeira vez, seja gentil: P)

EDIT: não viu os espaços adicionais necessários entre os caracteres, adicionados agora

EDIT 2: Modificado para ser uma função lambda anônima e removendo o argumento de divisão adicional, economizando 4 bytes

Jon Alsop
fonte
Bem-vindo ao PPCG! Acho que você não precisa do espaço depois print, mas parece que isso não imprime os espaços entre cada par de letras.
Martin Ender
Não é possível fornecer uma referência agora, mas quando o intérprete exige uma formatação extra da entrada, isso também está incluído na contagem. (Corrija-me se estiver errado, mas acho que isso só funciona se a entrada for passada junto com aspas, como "f".)
manatwork
Bom primeiro golfe. As funções são permitidas por padrão, mesmo as anônimas, portanto é mais curto fazer isso como lambda s:.... Eu acho que a divisão não precisa de um argumento 1, já que o personagem aparece apenas uma vez. Isso gera espaços no início das linhas seguintes, sem ter certeza se isso é permitido.
Xnor
1

Rubi, 59 57 67 bytes

Espaços adicionados entre letras

puts"qwertyuiop\nasdfghjkl\nzxcvbnm".split(gets.chop)[-1].chars*' '
hbejgel
fonte
Isso falha na entrada "m". Isso pode ser facilmente corrigido alterando o índice da matriz de -1 para 1, mas a entrada "m" resultará nil. O que não é um problema em si, mas causará problemas ao concluir seu código para adicionar espaços entre as letras.
manatwork
1

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

(não é necessário espaço após o primeiro caractere, pois ele nunca chega à saída)

Alerta o teclado quando você liga s("some letter"). Também pode ser feito com document.write()ou console.log(), mas ei, é mais longo: 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"));

nicael
fonte
11
Provavelmente, você pode salvar alguns bytes usando apenas em \nvez de ;na string e se livrando da substituição.
ETHproductions
@ É claro, obrigado! Usei a substituição, porque, a princípio, sem contar as quebras de linha, a substituição diminuiria. Então eu notei que as quebras de linha deveriam estar lá, então usei replace novamente. Nem sequer acho que poderia tornar o código mais longo: D
nicael 24/11/2015
1

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

Sou novo por aqui, apenas descobri este site. Não faço ideia se eu postei corretamente ou se o T-SQL é permitido, mas eu sei que o procedimento acima funciona.

Steve Matthews
fonte
1

O 2.2, 48 46 caracteres

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

Exemplo de execução:

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

O, 61 caracteres

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

Exemplo de execução:

bash-4.3$ java xyz.jadonfowler.o.O keyboard.o <<< 'f'
g h j k l 
z x c v b n m 
homem a trabalhar
fonte
Por algum motivo, isso não funciona no IDE, analisando-o agora ...
fase
"qwertyuiop\nasdfghjkl\nzxcvbnm\n"i/r;s{n.'\n=ST?}dfunciona apenas no novo intérprete, mas tem 51 bytes.
fase
Os links permanentes são ... um trabalho em andamento: P
fase
Sim, no diretório libregexp
fase
git clona o repositório, então git submodule update --init, entãomake
fase
1

Japt , 49 42 41 40 38 bytes

Japt é uma versão abreviada do Ja vaScri pt . Intérprete

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

o ? deve ser o impublicável Unicode caractere U + 0086.

Como funciona

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

Agora batendo CJam! :) Sugestões são bem-vindas!

Versão não concorrente, 12 bytes

;Dv qU g1 ¬¸

Desde 11 de janeiro, adicionei um novo recurso interessante ao Japt: se o programa contiver uma vírgula inicial, as variáveis ABCDEFGHIJLserão redefinidas para vários valores. Destá definido como "QWERTYUIOP\nASDFGHJKL\nZXCVBNM", portanto, ;Dvé suficiente substituir a string aqui.

ETHproductions
fonte
0

Gema, 56 caracteres

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

Exemplo de execução:

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

Código de máquina 8086 + DOS, 61 bytes

Hexdump (com exibição ASCII à direita):

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.

Código fonte do assembly (pode ser montado com o 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

Duas coisas divertidas aqui:

  1. O deslocamento da qwertystring é0x011e . O byte superior é 1, que é o número da função DOS para entrada de caracteres. Isso economiza 1 byte no código.
  2. Todas as letras minúsculas possuem o bit 5 definido. Ao fazer um ANDcom 0x20, todos são transformados em um espaço, que é impresso. Se o caractere anterior fosse um byte de fim de linha, ele será transformado em 0 e nenhum espaço será gerado. Isso é usado para evitar a sequência sem sentido 0d 20 0a 20no final da linha.

Uma coisa quase divertida:

Tentei procurar o char de entrada começando no endereço 0 (que diminuiu o tamanho do programa em 2 bytes), em vez do local usual (início da string). Isso quase funcionou; no entanto, falhou na entrada t, porque o próprio código contém o byte t(como parte da codificação de um salto condicional). Portanto t, ele produziria alguns bytes indesejados:

saída

anatolyg
fonte
0

, 32 caracteres / 79 bytes

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

Try it here (Firefox only).

Pelo menos estou ganhando em contagem de caracteres ... (A contagem de bytes é uma história diferente.)

Ah, sim, acabei de perceber que implementei atalhos de índice (em ⎖1vez de [1]) há algum tempo. Parvo eu!

Mama Fun Roll
fonte
Que língua é essa? ou é literalmente o seguinte: i.imgur.com/WC7XvYs.png (e há documentação) é estranho, aha!
ʰᵈˑ
Este é o ESMin. As cartas estão em duplicado, então você pode ter problemas para vê-las. Consulte github.com/molarmanful/ESMin (embora os documentos estejam desatualizados).
Mama Fun Roll
0

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));
}
Tas
fonte
Você pode cortar 17 bytes usando em putsvez destd::cout<<
DJMcMayhem
@DJMcMayhem Thanks! Um ponto excelente: por alguma razão, pensei que ainda precisaria de um #includepara puts, mas evidentemente não preciso !
Tas
Além disso, este é outro 12 mais curto.
DJMcMayhem
Obrigado! Eu nem sabia que strstrera uma coisa.
Tas
Eu acho que isso é um pouco exagerado. Você precisa <stdio.h>para strstr.
DJMcMayhem
0

Lote, 206 + 2 = 208 bytes

Como isso usa expansão atrasada, você precisa invocá-lo CMD /V /C keyboard.cmd <letter>, adicionando 1 2 ao /Vcomutador.

@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 =!
Neil
fonte
Receio que a opção da linha de comando conte 1 se a cmdaceitar como /VC, como fazem as ferramentas POSIX. Mas, como eu sei, /Vrequer um método próprio /, que também é contado.
manatwork
0

Python, 109 bytes

Eu sei que é um pouco grande, mas é tudo o que sei fazer agora!

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])
Ashwin Gupta
fonte
Eu não acho que você precise ligar kb()no final; definir a função é suficiente. Além disso, 1 espaço de recuo é suficiente. Depois de fazer essas alterações, recebo 108 bytes usando este site .
ETHproductions
@ETHproductions uau, eu não sabia disso antes. (Novo no python). Obrigado novamente por sua ajuda!
Ashwin Gupta
0

Bash, 80 bytes

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

Tente você mesmo, substitua $ 1 pelo caractere desejado ou faça um script #! / Bin / bash.

Aqui estão algumas amostras do 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

Não é o mais curto, mas ainda estou orgulhoso disso!

Cajova_Houba
fonte