Эти три ряда 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()

134 байта, если вместо этого я могу принять ввод как String []:

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

Вторая лямбда-это 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.

Питон 3, 98

Сохранено 5 байтов благодаря Кевину.
Сохранено 3 байта благодаря PM 2Ring.
Сохранено 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 в качестве лямбда-переменной
         c. "..." \ `# Список всех строк клавиатуры
      -LT # Удалить все буквы текущей строки ввода из текущего ввода
                      # слово. В результате получается список из 3 строк, одна из которых пуста, если
                      # слово может быть набрано одной строкой
    } k # Проверить, содержит ли список строку emtpy
elD # упорядочить список результатов по длине и взять последний

Руби, 88 82 69

Если мне не разрешено брать список строк и нужно брать многострочную строку, добавьте +12 к партитуре и добавьте .split('\n')прямо перед .grepвызовом.

Спасибо CatsAreFluffy за то, что он научил меня лабиринтам в Ruby и дальнейшим оптимизациям от 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]+)$")));}

Только вывод без Где:

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

bash105 байт

И различные другие утилиты, конечно.

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}  

сэкономили 3 байта благодаря предложению @Wolfgang

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]