Les trois rangées du clavier qwerty sont qwertyuiop, asdfghjklet zxcvbnm. Votre tâche consiste à trouver le mot le plus long pouvant être saisi à l'aide d'une seule ligne du clavier, à partir d'une liste de mots donnée.

Exemple d'entrée 1

artist
home
gas
writer
geology
marine
twerp

Sortie

writer

(Des mots donnés, seulement gas, writeret twerppeuvent être écrits en utilisant une seule ligne, et writerest le plus long)

Les mots peuvent ne pas être des mots réels (donc ne présumez pas que la troisième ligne n'est pas valide). Cependant, vous pouvez supposer qu'il y aura toujours exactement une réponse (ni plus, ni moins).

Exemple d'entrée 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Sortie

bxnzmmx

Des signes de ponctuation et des espaces supplémentaires peuvent être fournis en entrée (selon les exigences linguistiques). Cependant, aucune sortie supplémentaire ne doit être donnée. L'entrée et la sortie sont en minuscules. Le code le plus court gagne.

Python 2, 84 octets

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

Recherche l' maxentrée de, en comparant par moins de lignes de clavier étendues, puis en augmentant la longueur. La valeur de la ligne du clavier est extraite par "asdfghjklzxcvbnm".find(c)/9, ce qui prend la ligne du milieu à 0, la ligne du bas à 1et la ligne du haut, qui est exclue, à -1, car finddonne -1les valeurs manquantes.

Autres tentatives:

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 octets

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

Testez-le en ligne! L'entrée est un tableau de chaînes.

Comment ça marche

;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+ et 3, 93 octets

J'ai dû tester combien de coups pour cette approche; cela utilise le fait que la a.strip(b)chaîne est vide si elle ase compose uniquement de caractères apparaissant en b.

La fonction prend la liste des chaînes et renvoie une chaîne.

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

Rétine , 73 octets

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

Essayez-le en ligne!

Conclusion: la rétine a besoin d'une étape de tri.

Explication

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

Il s'agit d'une étape de grep: elle ne conserve que les lignes qui correspondent au regex. C'est-à-dire ceux qui sont formés exclusivement à partir de l'une de ces classes de caractères.

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

Il nous suffit maintenant de trouver la plus grande des chaînes restantes. Nous faisons cela en faisant correspondre tous les mots qui sont au moins aussi longs que tous les mots après eux. Il 1s'agit d'un nouvel ajout à Retina (sorti il ​​y a deux jours), qui limite cette étape de match à la considération du premier match de ce type. Et !demande à Retina d'imprimer la correspondance (au lieu de la compter).

Java, 154 142 ou 142 130 octets

Parce que, tu sais, Java.

C #, pour comparaison .

146 octets si l'entrée doit être une chaîne unique avec des valeurs séparées par \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 octets si je peux assumer l'entrée en tant que chaîne [] à la place:

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

Légèrement non golfé:

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

Le deuxième lambda est un Function<String[],String>.

Gelée, 40 34 octets

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

Essayez-le en ligne!

Comment ça marche

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

Enregistré 5 octets grâce à Kevin.
Enregistré 3 octets grâce à PM 2Ring.
Enregistré 3 octets grâce à Antti Haapala.

Brute le forçant pour le moment. Je filtre les mots jusqu'à ceux contenus dans une seule ligne, puis je trie pour la longueur de chaîne maximale.

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

Cas de 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 octets

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

Prend l'entrée via les arguments de ligne de commande as $args, puis utilise l' -matchopérateur avec une expression régulière pour sélectionner uniquement les mots qui sont exclusivement constitués d'une ligne de clavier. Nous dirigeons ces résultats dans Sort-Objectce type par la propriété Length. Nous pouvons le faire car les chaînes dans PowerShell sont toutes du System.Stringtype, ce qui inclut en .Lengthtant que propriété triable. Cela trie les chaînes dans l'ordre croissant par longueur, nous prenons donc la dernière avec [-1], la laissons sur le pipeline et la sortie est implicite.

Exemple

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

Pyth, 45 35 octets

Merci à @FryAmThe ​​Eggman de m'avoir sauvé quelques octets!

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

Essayez-le ici!

Prend la saisie sous forme de liste de mots.

Explication

elDf} k-LTc. "..." \ `Q # Q = liste de tous les mots saisis

   f Entrée filtre Q # avec T comme variable lambda
         c. "..." \ `# Liste de toutes les lignes du clavier
      -LT # Supprime toutes les lettres de la ligne d'entrée actuelle de l'entrée actuelle
                      # mot. Résultats dans une liste de 3 chaînes dont une est vide si
                      # le mot peut être tapé sur une seule ligne
    } k # Vérifiez si la liste contient une chaîne emtpy
elD # ordonner la liste des résultats par longueur et prendre la dernière

Rubis, 88 82 69

Si je ne suis pas autorisé à prendre une liste de chaînes et que je dois prendre une chaîne multiligne, ajoutez +12 au score et ajoutez .split('\n')juste avant l' .grepappel.

Merci à CatsAreFluffy de m'avoir enseigné les lambdas stabby à Ruby et les optimisations supplémentaires apportées par le manatwork

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

C #, 141/112 / (120 octets)

Candidat au pire langage du golf, pour des raisons évidentes. Utilise "mes" paramètres régionaux avec qwertz au lieu de qwerty mais fonctionne bien sinon.

Programme complet sans où:

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

Sortie uniquement sans Où:

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

Seule sortie (d'origine):

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

bash, 105 octets

Et divers autres utilitaires, bien sûr.

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

awk, 92 84 81 octets

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

économisé 3 octets grâce à la suggestion @Wolfgang

MATL , 54 octets

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

Cela fonctionne avec la version actuelle (14.0.0) du langage / compilateur.

Le format d'entrée est (premier exemple)

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

ou (deuxième exemple)

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

Essayez-le en ligne!

Explication

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

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

Le symbole à la lettre compte assez haut.

Groovy, 65 caractères

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

Exemple d'exécution:

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

Notez que l'expression régulière utilisée par .grep()ne nécessite pas d'ancrage, ce qui permet également d'épargner le regroupement:

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