Längstes Wort in einer einzelnen Zeile der QWERTY-Tastatur

30

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.

ghosts_in_the_code
quelle
@ MartinBüttner Ich würde gerne sehen, wie das mit Retina gelöst werden kann. Glaubst du, dass es leicht geht?
Jerry Jeremiah
Sind die eingegebenen Wörter immer in Kleinbuchstaben?
Nimi
@ nimi Ja, das sind sie.
ghosts_in_the_code
@ghosts_in_the_code Sie sollten dies in der Aufforderung zur Klarheit
Luis Mendo
6
Relevante xkcd: what-if.xkcd.com/75
John Dvorak

Antworten:

18

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)
xnor
quelle
1
1 /Zeichen mehr für Python 3;)
Antti Haapala
6
Ich wusste nicht, dass die Grammatik kein Leerzeichen zwischen 9und for
zulässt
Dies ist bei weitem meine Lieblingsantwort.
SBI
1
@jogloran, solange das Zeichen kein Eoder ist e, können Sie so ziemlich immer Leerzeichen zwischen einer Zahl und einem Variablennamen / Schlüsselwort
entfernen
@wnnmaw Das gilt nicht mehr für neuere Versionen von Python, z. B. 4if 0else 2ist gültig in 2.7.11 und 3.5.1 (und war wahrscheinlich für einige
frühere
13

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.
ETHproductions
quelle
8
Woah, hast du gerade Dennis übertroffen?
Morgan Thrapp
1
Dies wird schwer zu schlagen sein
Adnan
2
Haben Sie ein "QWERTYUIOP\nASDFGHJKL\nZXCVBNM"vordefiniertes Literal? Gut gespielt :-)
Luis Mendo
1
Ich kann anscheinend nicht herausfinden, wo der DQWERTYUIOP\nASDFGHJKL\nZXCVBNMVariables <...> D 13
Wert
1
@sukhmel A ;am Anfang des Programms setzt Variablen A-Lauf verschiedene Werte zurück. Dist auf die Tastaturzeichenfolge eingestellt. Weitere Infos finden Sie hier .
ETHproductions
11

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)))
Antti Haapala
quelle
5
Willkommen bei PPCG, schöner erster Beitrag :)
FryAmTheEggman
Warum ist die keyVariable dort? Ich denke, Sie können es entfernen.
CalculatorFeline
@CatsAreFluffy nein, das ist nicht möglich. Das keyArgument der maxFunktion ist nur ein Schlüsselwort.
Antti Haapala
Ack, ich habe kwargs vergessen.
CalculatorFeline
8

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

Martin Ender
quelle
Das ist cool! Ich muss mir irgendwann ausgeglichene Gruppen ansehen. Obwohl sie schwer zu verstehen scheinen. Ich habe versucht , diese (und es sieht aus wie es funktioniert), aber ich wollte für Ihre Antwort warten , um zu sehen , welche Art von Sache , die Sie erstellen.
Daavko
@daavko Entschuldigung für die Eigenwerbung, aber haben Sie meinen Stapelüberlauf-Beitrag über Bilanzkreise gelesen ? Mir wurde gesagt, dass es eine gute Einführung ist. Das Konzept selbst ist wirklich nicht so kompliziert, besonders wenn Sie nicht die (?<a-b>...)Syntax verwenden, die beim Codegolf selten benötigt wird.
Martin Ender
Ich glaube nicht, dass ich diesen Beitrag gesehen habe. Höchstwahrscheinlich, weil ich nicht oft im Stapelüberlauf browse. Vielen Dank für den Link, ich werde es bookmarken und lesen.
Daavko
1
Vermutlich nicht zum Thema gehörend für einen Kommentar, aber so ziemlich 100% meines Wissens über Bilanzkreise stammen davon, dass ich Ihren Beitrag gelesen habe. Ich denke, Sie können es jederzeit selbst bewerben, es ist eine große Hilfe :) Wie auch immer, wenn Sie mehr über das Thema zu tun haben, würden Sie Bühnenarbeiten wie <code> O-1`. * </ Code> sortieren, um die Zeile mit der längsten Eingabe zu erhalten? Vielleicht sollte es wie eine Transliteration funktionieren und mehr als einen durch Backtick getrennten Bereich haben, einen Regex zum Teilen und einen zum Zählen? Eigentlich gehört das vielleicht auch in den Chat ... ¯_ (ツ) _ / ¯
FryAmTheEggman
Hätte nie gedacht o-r, super.
Emanuel Vintilă
6

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

CAD97
quelle
Meine aktualisierte Version schlägt jetzt sogar den kürzeren Lambda als volles Programm :)
SBI
@SBI Curse Javas lange Methodenaufrufe! (Alles in allem viel Spaß)
CAD97
Da ich selbst Java-Entwickler bin, ist es schön, eine ausführliche Sprache zu sehen, die es schafft, gleichzeitig präzise zu sein :)
SBI
Wenn wir eine Eingabeannahme machen wollen, nehmen wir diejenige, die uns am meisten hilft, und geben sie als List <String> ein: l->l.stream().filter(g->g.matches("[wertyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()(116 Zeichen)
Andreas
@ Andreas Laut meiner jüngsten Metadiskussion müssen Sie einschließen , wenn ein Lambda eine Liste erstelltimport java.util.*; in die , was bedeutet, dass das Aufnehmen einer Liste -16 Bytes umfasst, indem Sie eine Liste aber +19 verwenden, um die Liste zu importieren. Sie haben dort jedoch maxstatt reducefür einen Gewinn von -7 Bytes abgefangen.
CAD97
4

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.
Dennis
quelle
4

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'
Morgan Thrapp
quelle
3

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
AdmBorkBork
quelle
3

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
Denker
quelle
3

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}
Wert Tinte
quelle
Nein, fügst du .split('\n')vor dem hinzu .select, oder? Und warum keine Lambdas?
CalculatorFeline
Ich wusste bis jetzt, als du es erwähnt hast, nichts über den Stabby Lambda. Vielen Dank!
Value Ink
Können Sie ein Leerzeichen zwischen -88- und 82 einfügen?
CalculatorFeline
Sie müssen es keiner Variablen zuweisen. Anonyme Funktionen sind zulässig. Wenn das einzige, was innerhalb .selectdes Codeblocks zu tun ist , ist, ihn mit einem regulären Ausdruck abzugleichen, .grepist dies geeigneter. Es ist nicht erforderlich, die Parameter der letzten Methode in einer Aufrufkette in Klammern zu setzen. .lengthhat einen kürzeren Alias .size:->x{x.grep(/^([o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+)$/).max_by &:size}
Manatwork
3

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());
SBI
quelle
1
Die Herausforderung besagt, dass Sie querty verwenden müssen, und da Sie dies sowieso fest codieren, sehe ich keinen Grund, dies zu ändern. Sie können auch eine Funktion (vielleicht sogar ein Lambda) anstelle eines vollständigen Programms verwenden, um einige Bytes zu speichern. Dies ist immer erlaubt, es sei denn, dies ist ausdrücklich in der Challenge verboten.
Denker
Da ich stolz auf mein Layout bin: P, habe ich ohnehin keine Chance, mit C # zu gewinnen. Bearbeitet in einer Version, die nur die Ausgabe ist.
SBI
Es wurde eine weitere Alternative hinzugefügt, bei der nur Last mit einem Prädikat anstelle von where verwendet wird. Dies spart weitere 8 Bytes.
SBI
2

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
Wolfgang
quelle
Der awkCode kann kürzer als geschrieben werden $0=length"\t"$0.
Manatwork
2

awk, 92 84 81 bytes

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

3 Bytes gespart dank @Wolfgang Vorschlag

Olivier Dulac
quelle
Sie können ein Byte subtrahieren, indem Sie [wetyuio-r]stattdessen verwenden, und zwei weitere, indem Sie /^(expr|expr|expr)$/anstelle von `/ ^ expr $ | ^ expr $ | ^ expr $ /
Wolfgang
@Wolfgang: danke für den tipp. Ich habe bereits das 2. Wort ausprobiert und auf meiner Awk gab es mir das längste Wort anstelle des richtigen ... Ich werde es erneut versuchen. Ich stimme dem ersten zu, speichere 1 Byte
Olivier Dulac
@Wolfgang: hmm, klappt diesmal (ich habe die Klammer vielleicht bei meinem eigenen Test Freitag gefummelt). Ich bearbeite deine Tipps in, danke.
Olivier Dulac
Sind Sie sicher, dass die Klammern um den regulären Ausdruck erforderlich sind? gawkund mawksind glücklich ohne sie.
Manatwork
@manatwork: die inneren sind notwendig, die äußeren bevorzuge ich sie, um die Logik und die Auswertungsreihenfolge sicherzustellen. .. vielleicht zum "Preis" von 2 Zeichen
Olivier Dulac
1

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
Luis Mendo
quelle
1

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.

Dale Johnson
quelle
0

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]
Mann bei der Arbeit
quelle