Die drei Zeilen der QWERTZ - Tastatur sind qwertyuiop, asdfghjklund zxcvbnm. Ihre Aufgabe ist es, aus einer vorgegebenen Wortliste das längste Wort zu finden, das mit nur einer Zeile der Tastatur eingegeben werden kann.

Probeneingabe 1

artist
home
gas
writer
geology
marine
twerp

Ausgabe

writer

(Von den gegebenen Worten nur gas, writerund twerpkann mit einer einzigen Zeile geschrieben werden, und writerist die am längsten)

Die Wörter sind möglicherweise keine echten Wörter (nehmen Sie also nicht an, dass die dritte Zeile ungültig ist). Sie können jedoch davon ausgehen, dass es immer genau eine Antwort geben wird (nicht mehr und nicht weniger).

Probeneingabe 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Ausgabe

bxnzmmx

Zusätzliche Interpunktions- und Leerzeichen können in der Eingabe angegeben werden (je nach Sprachanforderungen). Es sollte jedoch keine zusätzliche Ausgabe erfolgen. Eingabe und Ausgabe erfolgen in Kleinbuchstaben. Kürzester Code gewinnt.

Python 2, 84 Bytes

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

Findet die maxEingaben, vergleicht sie mit weniger überspannten Tastaturzeilen und wird dann länger. Die Tastatur Zeilenwert wird extrahiert durch "asdfghjklzxcvbnm".find(c)/9, die die mittlere Reihe nimmt 0, die untere Zeile 1, und die obere Reihe, die ausgeschlossen ist, an -1, da findgibt -1Werte für vermisste.

Andere Versuche:

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 Bytes

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

Online testen! Die Eingabe ist ein Array von Zeichenfolgen.

Wie es funktioniert

;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+ und 3, 93 Bytes

Musste testen, wie viele Schläge für diesen Ansatz; Dies nutzt die Tatsache, dass a.strip(b)eine leere Zeichenfolge entsteht, wenn sie anur aus Zeichen besteht, die in b vorkommen.

Die Funktion nimmt eine Liste von Zeichenfolgen und gibt eine Zeichenfolge zurück.

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

Netzhaut , 73 Bytes

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

Probieren Sie es online!

Fazit: Retina braucht eine Sortierstufe.

Erläuterung

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

Dies ist eine Grep-Phase: Sie behält nur Zeilen bei, die vom regulären Ausdruck abgeglichen werden. Dh diejenigen, die ausschließlich aus einer dieser Charakterklassen gebildet werden.

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

Jetzt müssen wir nur noch die größte der verbleibenden Saiten finden. Wir tun dies, indem wir alle Wörter abgleichen, die mindestens so lang sind wie alle Wörter nach ihnen. Das 1ist eine neue Ergänzung zu Retina (vor zwei Tagen veröffentlicht), die dieses Spiel Stufe begrenzt nur die erste solche Übereinstimmung zu berücksichtigen. Und !weist Retina an, das Match auszudrucken (anstatt es zu zählen).

Java, 154 142 oder 142 130 Bytes

Weil, weißt du, Java.

C # zum Vergleich .

146 Bytes, wenn die Eingabe eine einzelne Zeichenfolge sein muss, deren Werte durch Folgendes getrennt sind \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 Bytes, wenn ich stattdessen die Eingabe als String [] annehmen kann:

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

Leicht ungolfed:

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

Das zweite Lambda ist a Function<String[],String>.

Jelly, 40 34 Bytes

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

Probieren Sie es online!

Wie es funktioniert

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

5 Bytes gespart dank Kevin.
3 Bytes gespart dank PM 2Ring.
3 Bytes dank Antti Haapala gespeichert.

Im Moment brachial. Ich filtere die Wörter nur nach den Wörtern, die in einer einzelnen Zeile enthalten sind, und sortiere sie dann nach der maximalen Zeichenfolgenlänge.

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

Testfälle:

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 Byte

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

Übernimmt die Eingabe über Befehlszeilenargumente als $argsund verwendet dann den -matchOperator mit einem regulären Ausdruck, um nur die Wörter auszuwählen, die ausschließlich aus einer Tastaturzeile bestehen. Wir leiten diese Ergebnisse an Sort-Objectdie Art der Immobilie weiter Length. Dies ist möglich, da alle Zeichenfolgen in PowerShell vom System.StringTyp sind, einschließlich.Length als sortierbare Eigenschaft enthalten ist. Dadurch werden die Zeichenfolgen in aufsteigender Reihenfolge nach Länge sortiert. Wir nehmen die letzte Zeichenfolge mit [-1], belassen sie in der Pipeline und geben sie implizit aus.

Beispiel

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

Pyth, 45 35 Bytes

Vielen Dank an @FryAmThe ​​Eggman, dass du mir ein paar Bytes erspart hast!

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

Probieren Sie es hier aus!

Nimmt die Eingabe als eine Liste von Wörtern.

Erläuterung

elDf} k-LTc. "..." \ `Q # Q = Liste aller Eingabewörter

   f Q # Filtereingang mit T als Lambda-Variable
         c. "..." \ `# Liste aller Tastaturzeilen
      -LT # Entfernt alle Buchstaben der aktuellen Eingabezeile von der aktuellen Eingabe
                      # word. Ergibt eine Liste mit 3 Zeichenfolgen, wobei eine leer ist, wenn
                      # Das Wort kann mit einer Zeile eingegeben werden
    } k # Überprüfen Sie, ob die Liste eine leere Zeichenfolge enthält
elD # Ergebnisliste nach Länge ordnen und die letzte nehmen

Ruby, 88 82 69

Wenn ich keine Liste von Zeichenfolgen nehmen darf und eine mehrzeilige Zeichenfolge nehmen muss, addiere +12 zur Punktzahl und füge .split('\n')direkt vor dem .grepAufruf hinzu.

Vielen Dank an CatsAreFluffy, dass er mich über Stabby Lambdas in Ruby und weitere Optimierungen durch Manatwork unterrichtet hat

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

C #, 141/112 / (120 Bytes)

Anwärter auf die schlechteste Golfsprache, aus offensichtlichen Gründen. Verwendet "mein" Gebietsschema mit QWERTZ anstelle von QWERTY, funktioniert aber ansonsten einwandfrei.

Volles Programm ohne wo:

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

Nur ohne Where ausgeben:

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

Nur Ausgabe (Original):

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

bash105 Bytes

Und natürlich verschiedene andere Dienstprogramme.

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}  

3 Bytes gespart dank @Wolfgang Vorschlag

MATL , 54 Bytes

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

Dies funktioniert mit der aktuellen Version (14.0.0) der Sprache / des Compilers.

Eingabeformat ist (erstes Beispiel)

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

oder (zweites Beispiel)

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

Probieren Sie es online!

Erläuterung

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

Das Symbol für die Buchstabenanzahl ist ziemlich hoch.

Groovy, 65 Zeichen

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

Probelauf:

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

Beachten Sie, dass der reguläre Ausdruck, der von verwendet wird, .grep()keine Verankerung erfordert, sodass auch die Gruppierung entfällt:

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