Le tre righe della tastiera qwerty sono qwertyuiop, asdfghjkle zxcvbnm. Il tuo compito è trovare la parola più lunga che può essere digitata usando solo una riga della tastiera, da un determinato elenco di parole.

Esempio di input 1

artist
home
gas
writer
geology
marine
twerp

Produzione

writer

(Delle parole date, solo gas, writere twerppuò essere scritto usando una singola riga, ed writerè il più lungo)

Le parole potrebbero non essere parole reali (quindi non dare per scontato che la terza riga non sia valida). Tuttavia, puoi presumere che ci sarà sempre esattamente una risposta (niente di più, niente di meno).

Esempio di input 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Produzione

bxnzmmx

Punteggiatura aggiuntiva e spazi bianchi possono essere forniti in input (secondo i requisiti della lingua). Tuttavia, non deve essere fornito alcun output aggiuntivo. Ingresso e uscita sono in minuscolo. Il codice più corto vince.

Python 2, 84 byte

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

Trova l' maxinput, confrontandolo con un minor numero di righe della tastiera, quindi in lunghezza crescente. Il valore della riga della tastiera viene estratto da "asdfghjklzxcvbnm".find(c)/9, che porta alla riga centrale 0, alla riga inferiore a 1e alla riga superiore, che è esclusa, a -1, poiché findfornisce -1valori mancanti.

Altri tentativi:

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 byte

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

Provalo online! L'input è una matrice di stringhe.

Come funziona

;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+ e 3, 93 byte

Ho dovuto testare quanti colpi per questo approccio; questo utilizza il fatto che a.strip(b)risulta in una stringa vuota se è acostituito esclusivamente da caratteri presenti in b.

La funzione accetta un elenco di stringhe e restituisce una stringa.

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

Retina , 73 byte

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

Provalo online!

Conclusione: Retina ha bisogno di una fase di selezione.

Spiegazione

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

Questo è uno stadio grep: mantiene solo le linee che sono abbinate al regex. Cioè quelli che sono formati esclusivamente da una di quelle classi di caratteri.

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

Ora dobbiamo solo trovare la più grande delle stringhe rimanenti. Lo facciamo abbinando tutte le parole che sono almeno lunghe quanto tutte le parole che seguono. Si 1tratta di una nuova aggiunta a Retina (rilasciata due giorni fa), che limita questa fase della partita a considerare solo la prima di tali partite. E !ordina a Retina di stampare la corrispondenza (invece di contarla).

Java, 154 142 o 142 130 byte

Perché, sai, Java.

C #, per confronto .

146 byte se l'input deve essere una singola stringa con valori separati da \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 byte se posso assumere invece input come String []:

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

Leggermente non golfato:

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

La seconda lambda è a Function<String[],String>.

Gelatina, 40 34 byte

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

Provalo online!

Come funziona

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 byte salvati grazie a Kevin.
Salvato 3 byte grazie a PM 2Ring.
Salvato 3 byte grazie ad Antti Haapala.

Bruto forzandolo al momento. Filtra le parole solo per quelle contenute in una singola riga, quindi ordina per la lunghezza massima della stringa.

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

Casi test:

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]

Accetta input tramite argomenti della riga di comando come $args, quindi utilizza l' -matchoperatore con una regex per selezionare solo le parole composte esclusivamente da una riga della tastiera. Inoltriamo tali risultati in Sort-Objectquel tipo dalla proprietà Length. Possiamo farlo poiché le stringhe in PowerShell sono tutte del System.Stringtipo, che include .Lengthcome proprietà ordinabile. Questo ordina le stringhe in ordine crescente per lunghezza, quindi prendiamo l'ultima con [-1], la lasciamo sulla pipeline e l'output è implicito.

Esempio

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

Pyth, 45 35 byte

Grazie a @FryAmThe ​​Eggman per avermi salvato alcuni byte!

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

Provalo qui!

Accetta input come un elenco di parole.

Spiegazione

elDf} k-LTc. "..." \ `Q # Q = elenco di tutte le parole di input

   f Q # Filtro di input con T come variabile lambda
         c. "..." \ `# Elenco di tutte le righe della tastiera
      -LT # Rimuove tutte le lettere della riga di input corrente dall'input corrente
                      # parola. Risultati in un elenco di 3 stringhe con una vuota se
                      # la parola può essere digitata con una riga
    } k # Verifica se l'elenco contiene una stringa emtpy
elD # ordina l'elenco dei risultati per lunghezza e accetta l'ultimo

Ruby, 88 82 69

Se non mi è permesso prendere un elenco di stringhe e devo prendere una stringa su più righe, aggiungi +12 al punteggio e aggiungi .split('\n')subito prima della .grepchiamata.

Grazie CatsAreFluffy per avermi insegnato a proposito di stabby lambdas in Ruby e ulteriori ottimizzazioni dal manatwork

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

C #, 141/112 / (120 byte)

Concorrente per il peggior linguaggio del golf, per ovvi motivi. Usa la "mia" localizzazione con qwertz invece di qwerty, ma per il resto funziona bene.

Programma completo senza dove:

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

Uscita solo senza Dove:

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

Solo uscita (originale):

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

bash, 105 byte

E varie altre utilità, ovviamente.

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

awk, 92 84 81 byte

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

salvato 3 byte grazie al suggerimento di @Wolfgang

MATL , 54 byte

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

Funziona con la versione corrente (14.0.0) del linguaggio / compilatore.

Il formato di input è (primo esempio)

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

o (secondo esempio)

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

Provalo online!

Spiegazione

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

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

Il simbolo per il conteggio delle lettere è piuttosto elevato.

Groovy, 65 caratteri

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

Esecuzione di esempio:

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

Si noti che l'espressione regolare utilizzata .grep()non richiede l'ancoraggio, consentendo anche di risparmiare il raggruppamento:

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