三排QWERTY键盘的是qwertyuiop，asdfghjkl和zxcvbnm。您的任务是从给定的单词列表中找到只能使用键盘的一行即可输入的最长单词。

样品输入1

artist
home
gas
writer
geology
marine
twerp

输出量

writer

（给定的话，只有gas，writer并且twerp可以使用单个行写入，并且writer是最长的）

这些单词可能不是实际单词（因此，请不要假定第三行无效）。但是，您可以假设始终只有一个答案（不多也不少）。

样品输入2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

输出量

bxnzmmx

可以在输入中提供其他标点符号和空格（根据语言要求）。但是，不应提供任何额外的输出。输入和输出均为小写。最短的代码胜出。

Python 2，84个字节

lambda l:max(l,key=lambda w:(-len({"asdfghjklzxcvbnm".find(c)/9for c in w}),len(w)))

查找max输入的，然后按输入的键盘行数进行比较，然后以增加的长度进行比较。键盘行值由提取"asdfghjklzxcvbnm".find(c)/9，其中将中间行移至0，将底部行移至1，将顶部行（排除在外）移至至-1，因为find给出-1了缺少的值。

其他尝试：

lambda l:max((-len({"asdfghjklzxcvbnm".find(c)/9for c in w}),len(w),w)for w in l)[2]
lambda l:max(l,key=lambda w:len(w)-1./len({"asdfghjklzxcvbnm".find(c)/9for c in w}))
lambda l:max([w for w in l if len({"asdfghjklzxcvbnm".find(c)/9for c in w})<2],key=len)

Japt，32个 30字节

;Uf_¬£DbXu)f10Ãä¥ eÃn@Yl -XlÃg

在线测试！输入是一个字符串数组。

怎么运行的

;Uf_  ¬ £  DbXu)f10Ã ä¥  eà n@  Yl -Xlà g
;UfZ{Zq mX{DbXu)f10} ä== e} nXY{Yl -Xl} g

         // Implicit: U = input array of strings
;        // Reset variables A-L to various values.
         // D is set to the string "QWERTYUIOP\nASDFGHJKL\nZXCVBNM".
UfZ{   } // Take U and filter to only the items Z that return truthily to this function:
Zq       //  Split Z into chars, then
mX{    } //  map each char X by this function:
DbXu)    //   Return D.indexOf(X.toUpperCase()),
f10      //   floored to a multiple of 10.
         //  This maps each char to 0 for the top row, 10 for the middle, 20 for the bottom.
q ä==    //  Split the resulting string into chars and check each pair for equality.
e        //  Check that every item in the result is truthy. This returns true if all chars
         //  are on the same row; false otherwise.
         // Now we have only the words that are entirely on one row.
nXY{   } // Sort by passing each two args X and Y into this function:
Yl -Xl   //  Return Y.length - X.length. Sorts the longest to the front.
g        // Get the first item in the resulting array. Implicitly output.

Python 2.5+和3，93个字节

必须测试此方法的笔画数；它使用以下事实：a.strip(b)如果a仅由b中出现的字符组成，则结果为空字符串。

该函数获取字符串列表并返回一个字符串。

lambda a:max(a,key=lambda x:(~all(map(x.strip,['qwertyuiop','asdfghjkl','zxcvbnm'])),len(x)))

视网膜，73字节

G`^([eio-rtuwy]+|[adfghjkls]+|[bcmnvxz]+)$
1!`(.)+(?!\D+(?<-1>.)+(?(1)!))

在线尝试！

结论：视网膜需要分选阶段。

说明

G`^([eio-rtuwy]+|[adfghjkls]+|[bcmnvxz]+)$

这是一个grep阶段：它仅保留正则表达式匹配的行。即那些仅由这些字符类之一构成的字符。

1!`(.)+(?!\D+(?<-1>.)+(?(1)!))

现在，我们只需要找到其余最大的字符串即可。我们通过匹配所有至少长于其后所有单词的单词来做到这一点。这1是Retina（两天前发布的）的新增功能，它将比赛阶段限制为仅考虑第一个此类比赛。并!指示Retina打印匹配项（而不是对其进行计数）。

Java中，154 142或142 130个字节

因为，你知道，Java。

C＃，用于比较。

146个字节（如果输入必须是一个字符串，其值由分隔）\n：

s->java.util.Arrays.stream(s.split("\n")).filter(g->g.matches("[wetyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()

如果我可以假设输入为String []则为134个字节：

s->java.util.Arrays.stream(s).filter(g->g.matches("[wetyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()

稍微松了一下：

UnaryOperator<String> longestQwertyStr = s -> 
        java.util.Arrays.stream(s.split("\n")) // Split string input over `\n` and convert to Stream<String>
                .filter(g->g.matches("[wetyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")) // Filter to Strings that only use characters from a single row
                .max((a,b)->a.length()-b.length()) // Find the max by comparing String length
                .get(); // Convert from Optional<String> to String and implicit return single statement lambda

第二个lambda是一个Function<String[],String>。

果冻，40 34字节

p“£vẈ¬ḣ“£AS°GƤg“£ḷḳƤ²ƤȤḤ»f/€fµL€Mị

在线尝试！

怎么运行的

p“£vẈ¬ḣ“£AS°GƤg“£ḷḳƤ²ƤȤḤ»f/€fµL€Mị

 “£vẈ¬ḣ“£AS°GƤg“£ḷḳƤ²ƤȤḤ»           Use dictionary compression to yield
                                    ['quipo twyer', 'adj flash jg', 'bcmnz xv'].
p                                   Cartesian product; for all pairs of an input
                                    string and one of the rows.
                         f/€        Reduce each pair by filter, keeping only the
                                    letters in the input string that are on that
                                    particular keyboard row.
                            f       Filter the results, keeping only filtered words
                                    that occur in the input.
                             µ      Begin a new chain.
                              L€    Get the length of each kept word.
                                M   Get the index corr. to the greatest length.
                                 ị  Retrieve the word at that index.

Python 3、98

感谢Kevin，节省了5个字节。
借助PM 2Ring，节省了3个字节。
感谢Antti Haapala，节省了3个字节。

此刻蛮横地强迫它。我将单词过滤为仅包含在一行中的单词，然后对最大字符串长度进行排序。

lambda a:max(a,key=lambda x:(any(map(set(x).__le__,['qwertyuiop','asdfghjkl','zxcvbnm'])),len(x)))

测试用例：

assert f(['asdf', 'qwe', 'qaz']) == 'asdf'
assert f('''artist
home
gas
writer
geology
marine
twerp'''.splitlines()) == 'writer'
assert f('''wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt'''.splitlines()) == 'bxnzmmx'

PowerShell v2 +，72字节

($args-match"^([qwertyuiop]+|[asdfghjkl]+|[zxcvbnm]+)$"|sort Length)[-1]

通过命令行参数将输入作为$args，然后使用带有正则表达式的-match运算符来仅选择仅由一个键盘行组成的单词。我们将这些结果Sort-Object按属性通过管道进行分类Length。我们可以这样做，因为PowerShell中的字符串是所有System.String类型，包括.Length作为可排序属性。这将按长度将字符串按升序排序，因此我们将最后一个带[-1]，将其保留在管道中，并且输出是隐式的。

例

PS C:\Tools\Scripts\golfing> .\longest-word-qwerty-keyboard.ps1 asdf qwe zxc typewriter halls establishment
typewriter

Pyth，45 35字节

感谢@FryAmThe Eggman为我节省了一些字节！

elDf}k-LTc."`z:I¿Ç  Ì(T4²ª$8·"\`Q

在这里尝试！

将输入作为单词列表。

说明

elDf} k-LTc。“ ...” \`Q＃Q =所有输入单词的列表

   f Q＃使用T作为lambda变量过滤输入
         c。“ ...” \`＃所有键盘行的列表
      -LT＃从当前输入中删除当前输入行的所有字母
                      ＃个字。导致3个字符串的列表，如果不包含则为空
                      ＃单词可以排成一行
    } k＃检查列表中是否包含一个空字符串
ELD＃按长度排序结果列表，并取最后一个

红宝石，88 82 69

如果不允许我使用字符串列表，而必须使用多行字符串，请在乐谱上加+12并.split('\n')在.grep通话之前添加。

感谢CatsAreFluffy教给我有关Ruby中稳定的lambda的知识，以及有关manatwork的进一步优化的知识

->x{x.grep(/^([o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+)$/).max_by &:size}

C＃，141/112 /（120字节）

出于明显的原因，最糟糕的高尔夫语言是竞争者。在qwertz而非qwerty中使用“我的”语言环境，但在其他情况下则可以正常工作。

完整程序，无位置：

static void Main(string[]a){Console.WriteLine(a.OrderBy(x=>x.Length).Last(x=>Regex.IsMatch(x,"^([qwertzuiop]+|[asdfghjkl]+|[yxcvbnm]+)$")));}

仅输出而没有Where：

Console.WriteLine(a.OrderBy(x=>x.Length).Last(x=>Regex.IsMatch(x,"^([qwertzuiop]+|[asdfghjkl]+|[yxcvbnm]+)$")));

仅输出（原始）：

Console.WriteLine(a.Where(x=>Regex.IsMatch(x,"^([qwertzuiop]+|[asdfghjkl]+|[yxcvbnm]+)$")).OrderBy(x=>x.Length).Last());

bash，105字节

当然还有其他各种实用程序。

egrep -x '[wetyuio-r]+|[asdfghjkl]+|[zxcvbnm]+'|awk '{print length($0)"\t"$0;}'|sort -n|cut -f2|tail -n1

awk，92 84 81字节

(/^([wetyuio-r]+|[asdfghjkl]+|[zxcvbnm]+)$/)&&length>length(a){a=$0}END{print a}  

@Wolfgang建议节省了3个字节

MATL，54字节

[]y"@Y:nh]2$SP"@Y:!t'asdfghjkl'mw'zxcvbnm'myy+~hhAa?@.

这适用于该语言/编译器的当前版本（14.0.0）。

输入格式为（第一个示例）

{'artist' 'home' 'gas' 'writer' 'geology' 'marine' 'twerp'}

或（第二个示例）

{'wrhuji' 'bxnzmmx' 'gllwssjjd' 'vnccbb' 'lrkjhgfdsa' 'tttttt'}

在线尝试！

说明

[]               % push empty array. Will be used for concatenation
y                % take input array implicitly at bottom of stack, and copy onto top
"                % for each string
  @Y:            %   push current string
  nh             %   get its length. Concatenate with array of previous lengths
]                % end for each
2$S              % sort the original copy of input array by increasing string length
P                % flip: sort by decreasing length
"                % for each string in decreasing order of length
  @Y:!           %   push that string as a column char vector
  t'asdfghjkl'm  %   duplicate. Tru for chars in 2nd row of keyboard
  w'zxcvbnm'm    %   swap. True for chars in 3rd row of keyboard
  yy+~           %   duplicate top two arrays, sum, negate: true for chars in 1st row
  hh             %   concatenate horizontally twice
  Aa             %   true if any column has all true values
  ?              %   if that's the case
    @            %     push string  
    .            %     break for each loop
                 %   end if implicitly
                 % end for each
                 % display implicitly

Perl，81个字节

$a=$1 if/^([wetyuio-r]+|[asdfghjkl]+|[zxcvbnm]+)$/&&1<<y///c>$a=~y///c;END{say$a}

符号到字母的计数很高。

Groovy，65个字符

{it.grep(~/[o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+/).max{it.size()}}

样品运行：

groovy:000> ({it.grep(~/[o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+/).max{it.size()}})(['wrhuji', 'bxnzmmx', 'gllwssjjd', 'vnccbb', 'lrkjhgfdsa', 'tttttt'])
===> bxnzmmx

请注意，所使用的正则表达式.grep()不需要锚定，从而也可以节省分组：

groovy:000> ['ab', 'ac', 'bc', 'abc', 'aca', 'bbc'].grep ~/[ac]+|b+/
===> [ac, aca]