Mot le plus long utilisant une seule ligne du clavier qwerty


30

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.


@ MartinBüttner J'aimerais vraiment voir comment cela pourrait être résolu avec Retina. Pensez-vous que c'est facile à faire?
Jerry Jeremiah

Les mots saisis sont-ils toujours en minuscules?
nimi

@nimi Oui, ils le sont.
ghosts_in_the_code

@ghosts_in_the_code Vous devez déclarer que dans le défi de la clarté
Luis Mendo

Réponses:


18

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)

1
1 /personnage de plus pour Python 3;)
Antti Haapala

6
Je ne savais pas que la grammaire ne permettait aucun espace entre 9et for...
jogloran

C'est de loin ma réponse préférée.
SBI

1
@jogloran, tant que le caractère n'est pas un Eou e, vous pouvez presque toujours supprimer les espaces entre un nombre et un nom / mot
wnnmaw

@wnnmaw Ce n'est plus le cas pour les nouvelles versions de Python, par exemple 4if 0else 2est valable dans les versions 2.7.11 et 3.5.1 (et a probablement été valable pour quelques versions auparavant)
Sp3000

13

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.

8
Woah, tu viens de surpasser Dennis?
Morgan Thrapp

1
Cela va être difficile à battre
Adnan

2
Avez-vous "QWERTYUIOP\nASDFGHJKL\nZXCVBNM"un littéral prédéfini? Bien joué :-)
Luis Mendo

1
Je n'arrive pas à trouver où il est indiqué qu'il Dest réglé QWERTYUIOP\nASDFGHJKL\nZXCVBNM, même la page à laquelle vous faites référence semble indiquerVariables <...> D 13
sukhmel

1
@sukhmel A ;au début du programme réinitialise les variables A-Là différentes valeurs. Dest défini sur la chaîne du clavier. Vous pouvez trouver plus d'informations ici .
ETHproductions

11

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

5
Bienvenue à PPCG, joli premier post :)
FryAmTheEggman

Pourquoi la keyvariable est-elle là? Je pense que vous pouvez le supprimer.
CalculatorFeline

@CatsAreFluffy non, ce n'est pas possible. l' keyargument de la maxfonction est uniquement mot-clé.
Antti Haapala

Ack, j'ai oublié les kwargs.
CalculatorFeline

8

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).


C'est cool! Je devrai parfois examiner des groupes équilibrés. Bien qu'ils semblent difficiles à comprendre. J'ai essayé cela (et il semble que cela fonctionne), mais je voulais attendre votre réponse pour voir quel genre de chose allez-vous créer.
daavko

@daavko Désolé pour l'auto-promotion, mais avez-vous lu mon article Stack Overflow sur les groupes d'équilibrage ? On me dit que c'est une bonne introduction. Le concept lui-même n'est vraiment pas si compliqué, surtout si vous n'utilisez pas la (?<a-b>...)syntaxe qui est rarement nécessaire dans le golf de code.
Martin Ender

Je ne pense pas avoir vu ce post. Très probablement parce que je ne navigue pas souvent sur Stack Overflow. Merci pour le lien, je vais le mettre en signet et le lire.
daavko

1
Probablement hors sujet pour un commentaire, mais à peu près 100% de ma connaissance des groupes d'équilibrage vient d'avoir lu votre post. Je pense que vous pouvez l'auto-promouvoir à tout moment, c'est une grande aide :) Quoi qu'il en soit plus sur le sujet, trier le travail de scène quelque chose comme <code> O-1`. * </code> pour obtenir la ligne avec la plus longue entrée? Peut-être que cela devrait fonctionner comme la translittération et avoir plus d'une région séparée par un backtick, une expression régulière sur laquelle se diviser et une sur laquelle compter? En fait, peut-être que cela appartient également au chat ... ¯_ (ツ) _ / ¯
FryAmTheEggman

Je n'y aurais jamais pensé o-r, génial.
Emanuel Vintilă

6

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>.


Ma version mise à jour bat désormais même le lambda plus court en tant que programme complet :)
SBI

@SBI Curse Invocations de la longue méthode Java! (Tout en s'amusant)
CAD97

Étant moi-même développeur Java, c'est agréable de voir un langage verbeux qui parvient à être concis en même temps :)
SBI

Si nous allons faire une hypothèse d'entrée, faisons celle qui nous aide le plus, l'entrée se présente sous la forme d'une liste <String>: l->l.stream().filter(g->g.matches("[wertyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()(116 caractères)
Andreas

@Andreas Selon ma récente méta-discussion , si un lambda prend une liste, vous devez inclure import java.util.*;dans le nombre d'octets, ce qui signifie que la prise d'une liste est de -16 octets en prenant une liste mais +19 pour importer la liste. CEPENDANT, vous y avez attrapé en utilisant maxau lieu de reducepour un gain de -7 octets.
CAD97

4

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.

4

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'

3

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

3

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

3

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}

Non, vous ajoutez .split('\n')avant le .select, non? Et pourquoi pas de lambdas poignardés?
CalculatorFeline

Je ne connaissais pas le lambda lambda jusqu'à maintenant, quand vous en avez parlé. Merci!
Value Ink

Pouvez-vous ajouter un espace entre le -88- et le 82?
CalculatorFeline

Pas besoin de l'affecter à une variable, les fonctions anonymes sont autorisées; si la seule chose à faire à .selectl' intérieur du bloc de code est de le mettre en correspondance avec une expression régulière, .grepest plus approprié; pas besoin de mettre des parenthèses autour des paramètres de la dernière méthode dans une chaîne d'appel; .lengtha un alias plus court, .size:->x{x.grep(/^([o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+)$/).max_by &:size}
manatwork

3

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

1
Le défi dit que vous devez utiliser Querty et puisque vous codez en dur de toute façon, je ne vois aucune raison de changer cela. Vous pouvez également utiliser une fonction (peut-être même un lambda) au lieu d'un programme complet pour enregistrer certains octets. Ceci est toujours autorisé, sauf interdiction explicite dans le défi.
Denker

Être fier de ma mise en page: P, ce n'est pas comme si j'avais une chance de gagner de toute façon en utilisant C #. Édité dans une version qui n'est que la sortie.
SBI

Ajout d'une autre alternative, en utilisant uniquement Last avec un prédicat au lieu d'utiliser where. Cela rase encore 8 octets.
SBI

2

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

Le awkcode peut être écrit plus court comme $0=length"\t"$0.
manatwork

2

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


Vous pouvez soustraire un octet en utilisant à la [wetyuio-r]place, et aussi deux autres en faisant à la /^(expr|expr|expr)$/place de `/ ^ expr $ | ^ expr $ | ^ expr $ /
Wolfgang

@Wolfgang: merci pour l'astuce. J'ai déjà essayé le 2ème et sur mon awk ça m'a donné le mot le plus long au lieu du bon ... Je vais réessayer. Je suis cependant d'accord avec le premier, économise 1 octet
Olivier Dulac

@ Wolfgang: hmm, ça marche cette fois (j'ai peut-être fouillé les parenthèses sur mon propre test, vendredi). Je modifie vos conseils, merci.
Olivier Dulac

Êtes-vous sûr que les parenthèses autour de l'expression régulière sont nécessaires? gawket mawksont heureux sans eux.
manatwork

@manatwork: les internes sont nécessaires, les externes je préfère les avoir pour assurer la logique et l'ordre d'évaluation. .. peut-être au "coût" de 2 caractères
Olivier Dulac

1

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

1

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.


0

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]
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.