输出qwerty键盘

37

给定一个字符，输出（到屏幕）该字符之后的整个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

最短的代码胜出。（以字节为单位）

聚苯乙烯

可以接受多余的换行符或行尾的多余空格。

code-golf  keyboard 
— ghosts_in_the_code
source
一个功能是否足够？或者您需要一个可读取/写入stdin / stdout的完整程序？
— 2015年
1
@agtoever根据meta.codegolf.stackexchange.com/questions/7562/…，它是允许的。但是，该功能仍必须输出到屏幕。
— ghosts_in_the_code 2015年
— ghosts_in_the_code
1
允许在行前加空格？
— Sahil Arora 2015年
1
@SahilArora没有。
— ghosts_in_the_code 2015年

Answers:

19

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.
— 马丁·恩德
source
什么e#啊 它是CJam语法来发表评论吗？提前致谢。
— AL
@AL是的。
— 马丁·恩德
11

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.
— 丹尼斯
source
man，我刚刚创建了我的第一个Pyth程序（只有38个字节！），然后您就... +1顺便说一句，我认为\ 等同于d。
— ETHproductions 2015年
糟糕，我想这不一样​​...有什么不同？
— ETHproductions 2015年
1
@ETHproductions @Dennis为什么md5不产生5个空格的原因相同。d是通过map运算符的iterable参数迭代的默认变量。并且jL\ <list>对于地图操作员而言只是一个快捷方式mj\ d<list>。
— 雅库布2015年
1
@Jakube哦，这很有道理。谢谢！
— 丹尼斯
10

Perl，56个字节

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

将shebang计为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
— 原始
source
2
谢谢您教我\K！
— Dom Hastings
在这种情况下，@ DomHastings并不需要字节数，它s/.\B/$& /g同样可以正常工作。一个更好的例子。
— primo 2015年
6

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.
— 丹尼斯
source
6

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());
}
— 约翰
source
5

JavaScript（ES6），60个字节

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

使用与大多数其他答案相同的技术。建议欢迎！

— ETH生产
source
您能否解释为什么使用“ ...”。我在没有JSFiddle的情况下尝试仍可以正常工作吗？
— Awashi 2015年
@Awashi它是一个传播算子。它将字符串分成字符数组。没有它，.join` `它将什么也不会做，结果中将不会有空格。
— user81655 2015年
@ user81655给您
— 加油
4

Ruby，63 57字节

将字符作为命令行参数： ruby keyboard.rb e

"qwertyuiop
asdfghjkl
zxcvbnm".scan$*[0]
puts$'.chars*' '
— 达涅罗
source
4

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
— ETH生产
source
3

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)
— edc65
source
3

Python，83个字节

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

在线尝试

— Mego
source
3

Sed，59个字符

（58个字符的代码+ 1个字符的命令行选项。）

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

样品运行：

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
— 工作的人
source
3

红宝石，86 87 83 71 66

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

m如果输入为“ m”，则后面的多余空间是为了防止程序崩溃。

感谢@manatwork提供约16个字节的提示

— 打nor青蛙
source
让我猜测一下……上一次有太多的Python编码？
— manatwork
1
一些小的语法更改：ARGV→ $*; each_char→ chars; do.. end→ {.. }; printf→ $><<+ %会导致这样的："qwertyuiop↵asdfghjkl↵zxcvbnm".split($*[0])[1].chars{|i|$><<"%s "%i}。在Ruby中打高尔夫球的技巧中的更多内容。
— manatwork
@manatwork第一次尝试在Ruby中打高尔夫球，感谢您的提示/链接！
— SnoringFrog 2015年
1
我看到您在我的第一条评论中没有得到提示。在Ruby中，不需要在多行字符串周围使用三引号。（实际上直到现在我还不知道它是否被Ruby接受。）
— manatwork
1
输出中的前导空格非常难看。由于.正则表达式\n默认情况下不匹配，因此最好将其用于间距：puts"qwertyuiop↵asdfghjkl↵zxcvbnm ".split($*[0])[1].gsub(/./,'\& ')。虽然代码长度将保持不变。
— manatwork
2

PHP，88字节

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

需要使用-F命令行选项，计数为3。假定使用默认的.ini设置（您可以使用禁用本地.ini -n）。

样品用量

$ 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
— 原始
source
2

Prolog（SWI），153133字节

编辑：使用@Fatalize的技巧剪切20个字节

码

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

说明

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

例子

>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
— 艾米尼亚
source
使用SWI-Prolog，您可以atom_codes通过使用反引号来缩短零件，反引号分隔字符串代码（因此，您可以在调用时直接b用字符串替换L ）。
— 致命
@Fatalize酷！无论如何，由于我正在使用SWI-Prolog进行测试，这听起来是个好主意。
— Emigna 2015年
同样，使用b([A,_|T],[H]):-A=H,writef('%s',[T]);b(T,[H]).而不是2个不同的规则可以b缩短7个字节。通常，将所有规则与OR合并为一个规则;而不是编写多个规则通常会更短，因为您避免重复谓词的名称和参数，也避免了换行；）
— Fatalize 2015年
自从学习Prolog以来已经很久了，我完全忘记了您可以那样做。大提示！谢谢:)
— 艾米尼亚2015年
2

Befunge，122个字节

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

它已经在这里经过测试：Befunge-93 Interpreter。

这个怎么运作

  • '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' 被推入堆栈。
  • 丢弃（硬编码为@ZVD0FHJ:LNP^\<>,2B48X.T6R）N 的值的数量被推送。
  • 前N个值将被丢弃，其余值将被打印。

注意

我选择了编码，因此字符串以与@程序重叠开头。该字符串是通过以下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))
— 文森特
source
1
好的第一答案！欢迎来到Code Golf SE。（我也是
— 新手
1

腮腺炎-102字节

打高尔夫球的脚本：

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

取消评论并评论：

 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.

允许额外换行的规则为我节省了将近10个字节...

— Zmerch
source
1

Java-107字节

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

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

如果在空格开始的行是可以接受的，我们可以深入到99个字节：

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

Python 2，58 67 63字节##

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

将输入作为字符串或字符。在输入处拆分字符串，并在拆分后输出所有内容。

（第一次进行代码搜索，请谨慎：P）

编辑：现在没有看到字符之间所需的其他空格

编辑2：修改为匿名lambda函数，并删除额外的split arg，节省4个字节

— 乔恩·阿索普
source
欢迎来到PPCG！我认为您在之后不需要空格print，但这似乎并没有在每对字母之间打印空格。
— Martin Ender 2015年
目前无法提供参考，但是当解释器要求输入的额外格式时，该计数也包括在内。（如果我错了，请纠正我，但是我认为只有在输入内容与引号一起传递的情况下，此方法才有效"f"。）
— manatwork 2015年
不错的第一场高尔夫球。默认情况下允许使用函数，即使是匿名函数也是如此，因此将其简化为lambda s:...。我认为拆分不需要arg 1，因为该字符仅出现一次。这将在后续行的开头输出空格，不确定是否允许这样做。
— xnor
1

红宝石， 59 57 67个字节

在字母之间添加空格

puts"qwertyuiop\nasdfghjkl\nzxcvbnm".split(gets.chop)[-1].chars*' '
— 赫贝杰尔
source
输入“ m”失败。通过将数组索引从-1更改为1可以很容易地解决该问题，但是在输入“ m”时将产生结果nil。这本身不是问题，但是在完成代码以在字母之间添加空格时会引起问题。
— manatwork 2015年
1

JavaScript，88个字节

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("some letter")。也可以用document.write()或制成console.log()，但是，它更长了：P

演示：

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"));
展开摘要

— 尼卡
source
1
您可能只\n需要;在字符串中使用而不是replace并替换掉即可节省一些字节。
— ETHproductions 2015年
@Eth当然，谢谢！我确实使用了替换，因为起初不计换行符，替换会缩短。然后我注意到换行符应该在那儿，所以我再次使用了replace。甚至都没有想到它可以使代码更长：D
— nicael
1

SQL（MS T-SQL），172个字节

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

取消高尔夫：

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

我是新来的，才发现这个网站。不知道我是否已正确发布或是否允许T-SQL，但我知道上面的过程有效。

— 史蒂夫·马修斯
source
1

ø2.2，48 46个字符

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

样品运行：

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

O，61个字符

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

样品运行：

bash-4.3$ java xyz.jadonfowler.o.O keyboard.o <<< 'f'
g h j k l 
z x c v b n m
— 工作的人
source
这不会对IDE出于某种原因，目前正在调查这件事......
— 相
"qwertyuiop\nasdfghjkl\nzxcvbnm\n"i/r;s{n.'\n=ST?}d仅适用于新的解释器，但为51字节。
— 阶段
永久链接是正在进行的工作：P
— 阶段
是的，在libregexp目录中
— 阶段
git clone仓库，然后git submodule update --init，然后make
— 阶段
1

Japt，49 42 41 40 38字节

Japt是Ja vaScri pt的缩写。口译员

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

本?应是不可打印的Unicode字符U + 0086

这个怎么运作

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

现在击败CJam！:)欢迎提出建议！

非竞争版本，12字节

;Dv qU g1 ¬¸

从1月11日起，我为Japt 添加了一个很酷的新功能：如果程序包含一个前导逗号，则将变量ABCDEFGHIJL重新定义为各种值。D设置为"QWERTYUIOP\nASDFGHJKL\nZXCVBNM"，因此;Dv足以在此处替换字符串。

— ETH生产
source
0

Gema，56个字符

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

样品运行：

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

8086机器代码+ DOS，61字节

十六进制转储（右侧为ASCII视图）：

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.

汇编源代码（可以用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

这里有两个有趣的事情：

  1. qwerty字符串的偏移量是0x011e。它的高字节是1，它是字符输入的DOS功能号。这将在代码中节省1个字节。
  2. 所有小写​​字母都设置了位5。当这样做的AND用0x20，它们都被转变成的空间中，然后将其打印出来。如果前一个字符是行尾字节，则将其变为0，并且不输出任何空格。这用于避免0d 20 0a 20行尾出现不必要的序列。

一件事几乎很有趣：

我尝试搜索从地址0（将程序大小减少2个字节）开始的输入char，而不是通常的位置（字符串的开头）。这几乎起作用了；但是，输入失败t，因为代码本身包含字节t（作为条件跳转的编码的一部分）。因此，对于t，它将输出一些垃圾字节：

输出

— 阿纳托利格
source
0

𝔼𝕊𝕄𝕚𝕟，32个字符/ 79个字节

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

Try it here (Firefox only).

至少我在字符数方面赢了……（字节数是另外一回事了。）

哦，是的，我刚刚意识到我实现了索引快捷方式（⎖1而不是[1]）。傻我！

— 妈妈趣味卷
source
这是什么语言？还是字面上的意思是：i.imgur.com/WC7XvYs.png（并且有文档），这很奇怪，啊哈！
— 2015年
这是ESMin。字母被双击，因此您可能看不到它们。参见github.com/molarmanful/ESMin（尽管文档已过时）。
— Mama Fun Roll
0

C ++，129、112 97字节

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

取消高尔夫：

#include<string>
#include<cstdio>
void o(char c)
{
    puts(strstr("qwertyuiopasdfghjklzxcvbnm",&c));
}
— 塔斯
source
您可以使用puts代替std::cout<<
— DJMcMayhem
@DJMcMayhem谢谢！一个很好的观点：出于某种原因，我认为我仍然需要#includefor puts，但是显然我不需要！
— 2015年
另外，这要短12个。
— DJMcMayhem
谢谢！我什至不知道strstr是一回事。
— 2015年
我认为这有点过头了。你需要<stdio.h>的strstr。
— DJMcMayhem
0

批处理，206 + 2 = 208字节

因为这使用延迟扩展CMD /V /C keyboard.cmd <letter>，所以您需要使用调用它，因此为开关添加1 2 /V。

@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 =!
— 尼尔
source
恐怕命令行选项会像POSIX工具一样cmd接受1 /VC。但是据我所知/V需要它自己的/，这也得到了计数。
— manatwork
0

Python，109个字节

我知道它有点大，但是我现在知道该怎么做！ 

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）
source
我认为您不需要在最后致电给您kb()；定义功能就足够了。另外，仅1个缩进空间就足够了。进行这些更改后，使用此站点，我得到了108个字节。
— ETHproductions 2015年
@ETHproductions哇，我不知道曾经是太空人。（python的新手）。再次感谢您的帮助！
— Ashwin Gupta
0

Bash，80个字节

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

自己尝试，用所需的字符替换$ 1或制作一个＃！/ bin / bash脚本。

以下是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

它不是最短的，但我仍然为此感到骄傲！

— Cajova_Houba
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.