Salida del teclado qwerty

37

Dado un carácter, genera (en la pantalla) toda la distribución del teclado qwerty (con espacios y líneas nuevas) que sigue al carácter. Los ejemplos lo dejan claro.

Entrada 1

f

Salida 1

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

Entrada 2

q

Salida 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

Salida 3

(El programa termina sin salida)

Entrada 4

l

Salida 4

z x c v b n m

El código más corto gana. (en bytes)

PD

Se aceptan nuevas líneas adicionales o espacios adicionales al final de una línea.

fantasmas_en_el_código
fuente
¿Es suficiente una función o necesita un programa completo que lea / escriba en stdin / stdout?
2015
1
@agtoever Según meta.codegolf.stackexchange.com/questions/7562/… , está permitido. Sin embargo, la función aún debe salir a la pantalla.
ghosts_in_the_code
@agtoever Pruebe este enlace en su lugar. meta.codegolf.stackexchange.com/questions/2419/…
ghosts_in_the_code
1
¿Se permiten espacios iniciales antes de una línea?
Sahil Arora
1
@SahilArora Nope.
ghosts_in_the_code

Respuestas:

19

CJam, 42 40 bytes

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

Pruébalo aquí.

Explicació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.
Martin Ender
fuente
¿Qué es e#? ¿Es la sintaxis de CJam para un comentario? Gracias por adelantado.
AL
@AL sí lo es.
Martin Ender
11

Pyth, 33 bytes

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

Tenga en cuenta que algunos caracteres no se pueden imprimir. Pruébelo en línea en compilador Pyth .

Cómo 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
fuente
Aw hombre, acababa de crear mi primer programa Pyth (¡solo 38 bytes!), Luego apareciste ... +1 BTW, creo que \ es equivalente a d.
ETHproductions
Vaya, supongo que no es lo mismo ... ¿qué es diferente?
ETHproductions
1
@ETHproductions @Dennis La misma razón por la md5que no produce 5 espacios. des la variable predeterminada que itera a través del argumento iterable del operador del mapa. Y jL\ <list>es simplemente un atajo para el operador del mapa mj\ d<list>.
Jakube
1
@Jakube Oh, eso tiene sentido. ¡Gracias!
Dennis
10

Perl, 56 bytes

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

Contando el shebang como 3, la entrada se toma de stdin. Si una nueva línea principal no es una preocupación para las entradas py l, entonces /$_\n?/podría reemplazarse por una simple$_ para ahorrar 4.


Uso de muestra

$ 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
fuente
2
¡Gracias por enseñarme\K !
Dom Hastings
@DomHastings en este caso, no era realmente necesario para el conteo de bytes, s/.\B/$& /gfuncionaría igual de bien. Un mejor ejemplo .
primo
6

GS2 , 38 37 bytes

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

El código fuente usa la codificación CP437 . Pruébalo en línea!

Prueba de funcionamiento

$ 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

Cómo 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
fuente
6

C #, 112 bytes 105 110

El recuento aumentó en 5 bytes, ¡pero más correcto! Gracias @ 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());}

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

JavaScript (ES6), 60 bytes

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

Utiliza la misma técnica que la mayoría de las otras respuestas. Sugerencias bienvenidas!

ETHproducciones
fuente
¿Puedes explicar por qué usas el "..."? ¿Intento sin JSFiddle y sigo trabajando?
Awashi
@Awashi Es un operador de propagación . Separa la cadena en una matriz de caracteres. Sin él .join` `, no haría nada y no habría espacios en el resultado.
user81655
@ user81655 Tank you
Awashi
4

Ruby, 63 57 bytes

Toma el carácter como argumento de línea de comando: ruby keyboard.rb e

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

TeaScript , 50 45 44 bytes

TeaScript es JavaScript para jugar al golf.

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

Sin golfos y explicación

`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
ETHproducciones
fuente
3

JavaScript ES6, 73

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

Si no se permite una nueva línea inicial cuando el parámetro es po l, entonces 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
fuente
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:]

Pruébalo en línea

Mego
fuente
3

Sed, 59 caracteres

(Código de 58 caracteres + opción de línea de comando de 1 carácter).

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

Ejecución de muestra:

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 
hombre trabajando
fuente
3

Rubí, 86 87 83 71 66

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

El espacio extra después m es para evitar que el programa se bloquee si la entrada es 'm'.

Gracias a @manatwork por ~ 16 bytes de consejos

Ronquidos
fuente
Déjame adivinar ... ¿Demasiada codificación Python en la última vez?
manatwork
1
Algunos cambios menores de sintaxis: ARGV$*; each_charchars; do.. end{.. }; printf$><<+ %llevaría a esto: "qwertyuiop↵asdfghjkl↵zxcvbnm".split($*[0])[1].chars{|i|$><<"%s "%i}. Más en Consejos para jugar al golf en Ruby .
manatwork
@manatwork Primera vez que intentas jugar al golf en Ruby, ¡gracias por los consejos / enlaces!
SnoringFrog
1
Veo que no entendiste la pista en mi primer comentario. En Ruby no hay necesidad de comillas triples alrededor de cadenas multilínea. (En realidad, no tenía idea hasta ahora que Ruby lo aceptara)
Manatwork
1
Los espacios iniciales en la salida son bastante feos. Como .en la expresión regular no detectará \nde forma predeterminada, un mejor uso que para el espacio: puts"qwertyuiop↵asdfghjkl↵zxcvbnm ".split($*[0])[1].gsub(/./,'\& '). Aunque la longitud del código seguirá siendo la misma.
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)];

Requiere la -Fopción de línea de comando, contada como 3. Se asume la configuración predeterminada de .ini (puede deshabilitar su .ini local con -n).


Uso de muestra

$ 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
fuente
2

Prólogo (SWI), 153 133 bytes

Editar: corte 20 bytes con consejos 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),!.

Explicación

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

Ejemplos

>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
fuente
Usando SWI-Prolog, puede acortar la atom_codesparte usando las comillas inversas que delimitan los códigos de cadena (para que pueda reemplazar directamente L en la llamada de bcon la cadena).
Fatalize
@ Fatalize cool! Como estoy usando SWI-Prolog para probar de todos modos, eso suena como una gran idea.
Emigna
Además, usar en b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]).lugar de 2 reglas diferentes para bes 7 bytes más corto. Por lo general, siempre es más corto fusionar todas las reglas en una sola con OR en ;lugar de escribir varias reglas, porque evita repetir el nombre y los parámetros del predicado y también evita un
salto de
Ha pasado tanto tiempo desde que aprendí Prolog que me había olvidado por completo de que podrías O así. Gran consejo! Gracias :)
Emigna
2

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

Ha sido probado aquí: Befunge-93 Intérprete.

Cómo 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' es empujado en la pila.
  • Se @ZVD0FHJ:LNP^\<>,2B48X.T6Rempuja el número de valores a descartar (codificados ) N.
  • 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))
Vincent
fuente
1
Good first answer! Welcome to Code Golf SE. (I'm new as well.)
ghosts_in_the_code
1

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

zmerch
fuente
1

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(""," "));}
janschweizer
fuente
1

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

Jon Alsop
fuente
Welcome to PPCG! I don't think you need the space after print, but it seems that this doesn't print the spaces between each pair of letters.
Martin Ender
Can't provide a reference right now, but when the interpreter requires extra formatting of the input, that is also included in the count. (Correct me if I am wrong, but I think this only works if the input is passed together with surrounded quotes, like "f".)
manatwork
Nice first golf. Functions are allowed by default, even anonymous ones, so it's shorter to do this as lambda s:.... I think the split doesn't need an arg of 1, since the character appears only once. This outputs spaces at the start of succeeding lines, not sure if that's allowed.
xnor
1

Ruby, 59 57 67 bytes

Added spaces between letters

puts"qwertyuiop\nasdfghjkl\nzxcvbnm".split(gets.chop)[-1].chars*' '
hbejgel
fuente
This fails on input “m”. That can be easily fixed by changing the array index from -1 to 1, but then on input “m” will result nil. Which is not a problem itself, but will cause you problems when finishing your code to add spaces between the letters.
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])}

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

nicael
fuente
1
You could probably save a few bytes by just using \n instead of ; in the string and getting rid of the replace.
ETHproductions
@Eth Sure, thanks! I did use the replace, because at first, without counting the line breaks, the replace would shorten. Then I've noticed that the line breaks should be there, so I've used replace again. Didn't even think it could make the code longer :D
nicael
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

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.

Steve Matthews
fuente
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 
manatwork
fuente
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.

ETHproductions
fuente
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 
manatwork
fuente
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

anatolyg
fuente
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!

Mama Fun Roll
fuente
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));
}
Tas
fuente
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 =!
Neil
fuente
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])
Ashwin Gupta
fuente
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!

Cajova_Houba
fuente