Trzy rzędy klawiatury qwerty to qwertyuiop: asdfghjkli zxcvbnm. Twoim zadaniem jest znalezienie najdłuższego słowa, które można wpisać za pomocą tylko jednego wiersza klawiatury, z podanej listy słów.

Przykładowe dane wejściowe 1

artist
home
gas
writer
geology
marine
twerp

Wydajność

writer

(Danego słowa, tylko gas, writeri twerpmogą być zapisywane za pomocą pojedynczego wiersza, i writerjest najdłuższym)

Słowa mogą nie być rzeczywistymi słowami (więc nie zakładaj, że trzeci wiersz jest nieprawidłowy). Możesz jednak założyć, że zawsze będzie dokładnie jedna odpowiedź (nie więcej, nie mniej).

Przykładowe wejście 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Wydajność

bxnzmmx

Wprowadzane mogą być dodatkowe znaki interpunkcyjne i białe znaki (zgodnie z wymaganiami językowymi). Nie należy jednak podawać żadnych dodatkowych wyników. Dane wejściowe i wyjściowe są pisane małymi literami. Najkrótszy kod wygrywa.

Python 2, 84 bajtów

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

Znajduje dane maxwejściowe, porównując mniejszą liczbę rzędów klawiatury, a następnie zwiększając ich długość. Wartość rzędu klawiatury jest wyodrębniana przez "asdfghjklzxcvbnm".find(c)/9, który przenosi środkowy wiersz 0, dolny wiersz 1i górny wiersz, który jest wykluczony -1, ponieważ finddaje -1brakujące wartości.

Inne próby:

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 bajtów

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

Przetestuj online! Dane wejściowe to tablica ciągów.

Jak to działa

;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+ i 3, 93 bajty

Musiałem sprawdzić, ile uderzeń dla tego podejścia; wykorzystuje to fakt, że a.strip(b)wynikiem jest pusty ciąg znaków, jeśli askłada się wyłącznie ze znaków występujących w b.

Funkcja pobiera listę ciągów i zwraca ciąg.

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

Siatkówka , 73 bajty

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

Wypróbuj online!

Wniosek: Retina wymaga etapu sortowania.

Wyjaśnienie

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

To jest etap grep: zachowuje tylko linie, które są dopasowane przez wyrażenie regularne. To znaczy te, które powstają wyłącznie z jednej z tych klas postaci.

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

Teraz musimy tylko znaleźć największy z pozostałych ciągów. Robimy to, dopasowując wszystkie słowa, które są co najmniej tak długie, jak wszystkie słowa po nich. 1To nowy dodatek do siatkówki (wydany dwa dni temu), co ogranicza ten etap dopasowania do rozważa tylko pierwszy taki mecz. I !instruuje Retinę, aby wydrukowała mecz (zamiast go liczyć).

Java, 154 142 lub 142 130 bajtów

Ponieważ, wiesz, Java.

C #, dla porównania .

146 bajtów, jeśli dane wejściowe muszą być pojedynczym ciągiem znaków, a wartości należy oddzielić \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 bajty, jeśli zamiast tego mogę przyjąć dane wejściowe jako String []:

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

Nieznacznie nie golfista:

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

Druga lambda to Function<String[],String>.

Galaretka, 40 34 bajtów

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

Wypróbuj online!

Jak to działa

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

Zaoszczędził 5 bajtów dzięki Kevinowi.
Zaoszczędzono 3 bajty dzięki PM 2Ring.
Zaoszczędzono 3 bajty dzięki Antti Haapala.

Brute zmusza go w tej chwili. Filtruję słowa do tylko tych zawartych w jednym rzędzie, a następnie sortuję według maksymalnej długości łańcucha.

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

Przypadki testowe:

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 bajty

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

Pobiera dane wejściowe za pomocą argumentów wiersza polecenia $args, a następnie używa -matchoperatora z wyrażeniem regularnym, aby wybrać tylko słowa, które składają się wyłącznie z jednego wiersza klawiatury. Przekazujemy wyniki do Sort-Objecttego rodzaju według właściwości Length. Możemy to zrobić, ponieważ ciągi znaków w programie PowerShell są tego samego System.Stringtypu, co zawiera .Lengthjako właściwość do sortowania. To sortuje ciągi w porządku rosnącym według długości, więc bierzemy ostatni z [-1], zostawiamy go w potoku, a dane wyjściowe są niejawne.

Przykład

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

Pyth, 45 35 bajtów

Dzięki @FryAmThe ​​Eggman za uratowanie mi kilku bajtów!

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

Wypróbuj tutaj!

Pobiera dane wejściowe jako listę słów.

Wyjaśnienie

elDf} k-LTc. "..." \ `Q # Q = lista wszystkich wprowadzonych słów

   f Q # Wejście filtra z T jako zmienną lambda
         c. "..." \ `# Lista wszystkich wierszy klawiatury
      -LT # Usuń wszystkie litery bieżącego wiersza wprowadzania z bieżącego wejścia
                      # słowo. Wynikiem jest lista 3 ciągów znaków, z których jeden jest pusty, jeśli
                      # słowo można wpisać w jednym wierszu
    } k # Sprawdź, czy lista zawiera pusty ciąg znaków
ELD # uporządkuj listę wyników według długości i wybierz ostatnią

Ruby, 88 82 69

Jeśli nie wolno mi wziąć listy ciągów i muszę wziąć ciąg wielowierszowy, dodaj +12 do wyniku i dodaj .split('\n')bezpośrednio przed .grepwywołaniem.

Dzięki CatsAreFluffy za nauczenie mnie o mocnych lambdach w Ruby i dalsze optymalizacje z manatwork

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

C #, 141/112 / (120 bajtów)

Rywalizuj o najgorszy język golfa, z oczywistych powodów. Używa ustawień regionalnych „my” z qwertz zamiast qwerty, ale w przeciwnym razie działa dobrze.

Pełny program bez:

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

Wyjście tylko bez Where:

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

Tylko wyjście (oryginalne):

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

bash, 105 bytes

And various other utilities, of course.

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

awk , 92 84 81 bytes

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

saved 3 bytes thanks to @Wolfgang suggestion

MATL, 54 bytes

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

This works with current version (14.0.0) of the language/compiler.

Input format is (first example)

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

or (second example)

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

Try it online!

Explanation

[]               % 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 bytes

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

Symbol to letter count pretty high.

Groovy, 65 characters

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

Sample run:

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

Note that the regular expression used by .grep() not requires anchoring, allowing to spare the grouping too:

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