Sortie du clavier qwerty


37

Avec un caractère, affiche (à l'écran) l'intégralité de la disposition du clavier qwerty (avec espaces et nouvelles lignes) qui suit le caractère. Les exemples le montrent clairement.

Entrée 1

f

Sortie 1

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

Entrée 2

q

Sortie 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

Entrée 3

m

Sortie 3

(Le programme se termine sans sortie)

Entrée 4

l

Sortie 4

z x c v b n m

Le code le plus court gagne. (en octets)

PS

Les nouvelles lignes ou les espaces supplémentaires en fin de ligne sont acceptés.


Une fonction est-elle suffisante ou avez-vous besoin d'un programme complet qui lit / écrit sur stdin / stdout?
agtoever

1
@agtoever Selon meta.codegolf.stackexchange.com/questions/7562/… , il est autorisé. Cependant, la fonction doit toujours sortir à l'écran.
ghosts_in_the_code


1
les espaces devant une ligne sont-ils autorisés?
Sahil Arora

1
@SahilArora Nope.
ghosts_in_the_code

Réponses:


19

CJam, 42 40 octets

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

Testez-le ici.

Explication

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

C'est quoi e#? Est-ce la syntaxe CJam pour un commentaire? Merci d'avance.
AL

@ AL oui c'est le cas.
Martin Ender

11

Pyth, 33 octets

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

Notez que certains caractères ne sont pas imprimables. Essayez-le en ligne dans le compilateur Pyth .

Comment ça marche

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.

Homme Aw, je venais de créer mon premier programme Pyth jamais (seulement 38 octets!), Alors vous êtes arrivé ... +1 BTW, je pense \ est équivalent à d.
ETHproductions

Oups, je suppose que ce n'est pas la même chose ... qu'est-ce qui est différent?
ETHproductions

1
@ETHproductions @Dennis Même raison pour laquelle md5ne produit pas 5 espaces. dest la variable par défaut qui parcourt l'argument iterable de l'opérateur de carte. Et jL\ <list>est simplement un raccourci pour l'opérateur de la carte mj\ d<list>.
Jakube

1
@ Jakube Oh, c'est logique. Merci!
Dennis

10

Perl, 56 octets

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

En comptant le shebang comme 3, l'entrée est prise de stdin. Si l' un des principaux nouvelle ligne est une préoccupation pour les intrants pet l, alors /$_\n?/pourrait être remplacé par un nu $_pour sauver 4.


Exemple d'utilisation

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

$ echo v|perl qwerty.pl
b n m


@DomHastings dans ce cas, ce n'était pas vraiment nécessaire pour le nombre d'octets, s/.\B/$& /gcela fonctionnerait aussi bien. Un meilleur exemple .
Primo

6

GS2 , 38 37 octets

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

Le code source utilise le codage CP437 . Essayez-le en ligne!

Essai

$ 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

Comment ça marche

♦                                      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.

6

C #, 112 octets 105 110

Le compte a augmenté de 5 octets, mais plus correct! Merci @ 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());}

Non-golfé

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

5

JavaScript (ES6), 60 octets

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

Utilise la même technique que la plupart des autres réponses. Suggestions bienvenues!


Pouvez-vous expliquer pourquoi utilisez-vous le "...". J'essaie sans JSFiddle et travaille toujours?
Awashi

@Awashi C'est un opérateur de diffusion . Il sépare la chaîne en un tableau de caractères. Sans cela le .join` `ne ferait rien et il n'y aurait pas d'espaces dans le résultat.
user81655

@ user81655 Tank vous
Awashi

4

Ruby, 63 57 octets

Prend le caractère comme argument de ligne de commande: ruby keyboard.rb e

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

4

TeaScript , 50 45 44 octets

TeaScript est JavaScript pour le golf.

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

Ungolfed et explication

`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

3

JavaScript ES6, 73

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

Si un chef de file nouvelle ligne est autorisée lorsque le paramètre est pou l, puis 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)


3

Sed, 59 personnages

(Option de ligne de commande avec un code de 58 caractères + 1 caractère.)

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

Échantillon échantillon:

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 

3

Ruby, 86 87 83 71 66

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

L'espace supplémentaire après m est d'empêcher le programme de planter si l'entrée est 'm'.

Merci à @manatwork pour ~ 16 octets de conseils


Laissez-moi deviner… Trop de codage Python dans la dernière fois?
manatwork

1
Quelques changements mineurs dans la syntaxe: ARGV$*; each_charchars; do.. end{.. }; printf$><<+ %conduirait à ceci: "qwertyuiop↵asdfghjkl↵zxcvbnm".split($*[0])[1].chars{|i|$><<"%s "%i}. Plus dans Conseils pour jouer au golf en Ruby .
Manatwork

@manatwork Première fois à essayer de jouer au golf en Ruby, merci pour les conseils / le lien!
SnoringFrog

1
Je vois que vous n'avez pas compris l'allusion dans mon premier commentaire. En Ruby, les guillemets triples autour des chaînes multilignes ne sont pas nécessaires. (En fait, je ne savais pas jusqu'à présent que Ruby l'accepterait.)
manatwork

1
Les espaces de début dans la sortie sont assez laids. Comme .dans l' expression régulière ne correspond pas \npar défaut, mieux l' utiliser pour l'espacement: puts"qwertyuiop↵asdfghjkl↵zxcvbnm ".split($*[0])[1].gsub(/./,'\& '). Bien que la longueur du code reste la même.
Manatwork

2

PHP, 88 octets

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

Requiert l' -Foption de ligne de commande, comptabilisée comme 3. Les paramètres .ini par défaut sont utilisés (vous pouvez désactiver votre fichier .ini local avec -n).


Exemple d'utilisation

$ 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

2

Prolog (SWI), 153 133 octets

Edit: coupez 20 octets avec les astuces de @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),!.

Explication

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

Exemples

>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

En utilisant SWI-Prolog, vous pouvez raccourcir la atom_codespartie en utilisant les guillemets qui délimitent les codes de chaîne (vous pouvez ainsi remplacer directement L dans l'appel de bavec la chaîne).
Fataliser

@Fatalize cool! Comme j'utilise quand même SWI-Prolog pour les tests, cela semble être une excellente idée.
Emigna

De plus, utiliser b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]).au lieu de 2 règles différentes best plus court de 7 octets. Habituellement, il est toujours plus court de fusionner toutes les règles en une seule avec des OR ;au lieu d'écrire plusieurs règles, car vous évitez de répéter le nom et les paramètres du prédicat et vous évitez également un saut de ligne;)
Fatalize

Cela fait tellement longtemps que je n'ai pas appris Prolog que j'avais totalement oublié que vous pouviez OU aimer cela. Bon conseil! Merci :)
Emigna

2

Befunge, 122 octets

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

Il a été testé ici: interprète Befunge-93 .

Comment ça marche

  • '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' est poussé sur la pile.
  • Le nombre de valeurs à ignorer (codé en dur @ZVD0FHJ:LNP^\<>,2B48X.T6R) N est poussé.
  • Les premières valeurs N sont ignorées et les valeurs restantes sont imprimées.

Remarque

J'ai choisi le codage pour que la chaîne commence par @se chevaucher avec le programme. Cette chaîne est générée avec le code python suivant:

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

1
Bonne première réponse! Bienvenue chez Code Golf SE. (Je suis nouveau aussi.)
ghosts_in_the_code

1

Oreillons - 102 octets

Script golfé:

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 et commenté:

 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.

La règle permettant de nouvelles lignes supplémentaires m'a sauvé près de 10 octets ...


1

Java - 107 octets

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

Ungolfed avec une lecture de classe wrapper à partir 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 "));
    }
}

Si les espaces en début de ligne étaient acceptables, nous pourrions descendre à 99 octets:

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

1

Python 2, 58 67 63 octets ##

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

Prend l'entrée sous forme de chaîne ou de caractère. Divise la chaîne à l'entrée et affiche tout après la division.

(Première utilisation du code-golf, soyez gentil: P)

EDIT: n'a pas vu les espaces supplémentaires requis entre les caractères, ajouté maintenant

EDIT 2: modifié pour être une fonction lambda anonyme et supprimer l'argument fractionné supplémentaire, économisant 4 octets


Bienvenue chez PPCG! Je ne pense pas que vous ayez besoin d'espace après print, mais il semble que cela n'imprime pas les espaces entre chaque paire de lettres.
Martin Ender

Impossible de fournir une référence pour le moment, mais lorsque l'interprète requiert un formatage supplémentaire de l'entrée, il est également inclus dans le décompte. (Corrigez-moi si je me trompe, mais je pense que cela ne fonctionne que si l'entrée est passée avec des guillemets, comme "f".)
manatwork

Nice premier golf. Les fonctions sont autorisées par défaut, même les anonymes, aussi est-il plus court de le faire lambda s:.... Je pense que la scission n'a pas besoin d'argument 1, car le personnage n'apparaît qu'une seule fois. Cela génère des espaces au début des lignes suivantes, sans savoir si cela est autorisé.
XNOR

1

Rubis, 59 57 67 octets

Ajout d'espaces entre les lettres

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

Cela échoue sur l'entrée «m». Cela peut être facilement corrigé en modifiant l'index du tableau de -1 à 1, mais il en résultera une entrée «m» nil. Ce qui n'est pas un problème en soi, mais qui vous causera des problèmes lors de la finition de votre code pour ajouter des espaces entre les lettres.
manatwork

1

JavaScript, 88 octets

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

(inutile dans l'espace après le premier caractère, car il n'atteint jamais la sortie)

Alerte le clavier lorsque vous appelez s("some letter"). Peut aussi être fait avec document.write()ou console.log(), mais bon, c'est plus long: P

Démo:

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


1
Vous pourriez probablement économiser quelques octets simplement en utilisant \nplutôt que ;dans la chaîne et en supprimant le remplacement.
ETHproductions

@Eth Bien sûr, merci! J'ai utilisé le remplacement, car au début, sans compter les sauts de ligne, le remplacement serait raccourci. Ensuite, j'ai remarqué que les sauts de ligne devraient être là, alors j'ai utilisé remplacer à nouveau. Je ne pensais même pas que cela pourrait
rallonger

1

SQL (MS T-SQL), 172 octets

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

Je suis nouveau ici, je viens juste de découvrir ce site. Aucune idée si j'ai posté correctement ou si T-SQL est autorisé, mais je sais que la procédure ci-dessus fonctionne.


1

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 

This doesn't work on the IDE for some reason, looking into it now...
phase

"qwertyuiop\nasdfghjkl\nzxcvbnm\n"i/r;s{n.'\n=ST?}d only works on the new interpreter but is 51 bytes.
phase

The permalinks are... a work in progress :P
phase

Yup, in the libregexp directory
phase

git clone the repo, then git submodule update --init, then make
phase

1

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.


0

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 

0

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:

output


0

𝔼𝕊𝕄𝕚𝕟, 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!


What language is this? or is it literally this: i.imgur.com/WC7XvYs.png (and is there documentation) it's weird, aha!
ʰᵈˑ

This is ESMin. Letters are in doublestruck, so you might have trouble seeing them. See github.com/molarmanful/ESMin (docs are outdated, though).
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));
}

You could shave off 17 bytes by using puts instead of std::cout<<
DJMcMayhem

@DJMcMayhem Thanks! An excellent point: for some reason I thought I would still need an #include for puts, but evidently I do not!
Tas

Also, this is another 12 shorter.
DJMcMayhem

Thanks! I didn't even know strstr was a thing.
Tas

I think that's a little bit overgolfed. You need <stdio.h> for strstr.
DJMcMayhem

0

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 =!

I'm afraid the command line option would count 1 if cmd would accept it as /VC, like POSIX tools do. But as I know /V requires its own /, which also gets counted.
manatwork

0

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

I don't think you need the call to kb() at the end; defining the function is enough. Also, 1 space of indentation is enough. After making these changes, I get 108 bytes, using this site.
ETHproductions

@ETHproductions wow I didn't know that once space thing. (New to python). Thanks again for your help!
Ashwin Gupta

0

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!

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.