Las tres filas del teclado qwerty son qwertyuiop, asdfghjkly zxcvbnm. Su tarea es encontrar la palabra más larga que se puede escribir usando solo una fila del teclado, de una lista dada de palabras.

Entrada de muestra 1

artist
home
gas
writer
geology
marine
twerp

Salida

writer

(De las palabras dadas, solo gas, writery twerpse pueden escribir usando una sola fila, y writeres la más larga)

Las palabras pueden no ser palabras reales (así que no asuma que la tercera fila no es válida). Sin embargo, puede suponer que siempre habrá exactamente una respuesta (ni más ni menos).

Entrada de muestra 2

wrhuji
bxnzmmx
gllwssjjd
vnccbb
lrkjhgfdsa
tttttt

Salida

bxnzmmx

Se pueden proporcionar signos de puntuación y espacios en blanco adicionales en la entrada (según los requisitos de idioma). Sin embargo, no se debe dar salida adicional. La entrada y la salida están en minúsculas. El código más corto gana.

Python 2, 84 bytes

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

Encuentra el maxde la entrada, comparándolo con menos filas de teclado distribuidas, luego en longitud creciente. El valor de la fila del teclado se extrae mediante "asdfghjklzxcvbnm".find(c)/9, que lleva la fila central a 0, la fila inferior a 1, y la fila superior, que se excluye, a -1, dado que findda -1valores perdidos.

Otros intentos

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

¡Pruébelo en línea! La entrada es una matriz de cadenas.

Cómo funciona

;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+ y 3, 93 bytes

Tuve que probar cuántos golpes para este enfoque; esto utiliza el hecho de que a.strip(b)da como resultado una cadena vacía si asolo consiste en caracteres que aparecen en b.

La función toma una lista de cadenas y devuelve una cadena.

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

Retina , 73 bytes

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

Pruébalo en línea!

Conclusión: la retina necesita una etapa de clasificación.

Explicación

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

Esta es una etapa grep: solo mantiene líneas que coinciden con la expresión regular. Es decir, aquellos que se forman exclusivamente a partir de una de esas clases de personajes.

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

Ahora solo necesitamos encontrar la mayor de las cadenas restantes. Hacemos esto haciendo coincidir todas las palabras que son al menos tan largas como todas las palabras que siguen. The 1es una nueva adición a Retina (lanzada hace dos días), que limita esta etapa del partido a considerar solo el primero. Y le !indica a Retina que imprima el partido (en lugar de contarlo).

Java, 154 142 o 142 130 bytes

Porque, ya sabes, Java.

C #, para comparar .

146 bytes si la entrada tiene que ser una sola cadena con valores separados por \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 si puedo asumir la entrada como String [] en su lugar:

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

Ligeramente incólume:

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 segunda lambda es a Function<String[],String>.

Jalea, 40 34 bytes

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

Pruébalo en línea!

Cómo funciona

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.

Pitón 3, 98

Guardado 5 bytes gracias a Kevin.
Guardado 3 bytes gracias a PM 2Ring.
Guardado 3 bytes gracias a Antti Haapala.

Brute forzándolo en este momento. Filtre las palabras solo a las contenidas en una sola fila, y luego ordeno por la longitud máxima de la cadena.

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

Casos de prueba:

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 bytes

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

Toma datos a través de argumentos de línea de comandos como $args, luego usa el -matchoperador con una expresión regular para seleccionar solo las palabras que se componen exclusivamente de una fila de teclado. Canalizamos esos resultados en Sort-Objectese tipo por la propiedad Length. Podemos hacer esto ya que las cadenas en PowerShell son todas del System.Stringtipo, lo que incluye .Lengthcomo una propiedad ordenable. Esto ordena las cadenas en orden ascendente por longitud, por lo que tomamos la última con[-1] , lo dejamos en la tubería y la salida es implícita.

Ejemplo

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

Pyth, 45 35 bytes

¡Gracias a @FryAmThe ​​Eggman por salvarme algunos bytes!

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

Pruébalo aquí!

Toma entrada como una lista de palabras.

Explicación

elDf} k-LTc. "..." \ `Q # Q = lista de todas las palabras de entrada

   f Q # Entrada de filtro con T como variable lambda
         c. "..." \ `# Lista de todas las filas del teclado
      -LT # Eliminar todas las letras de la fila de entrada actual de la entrada actual
                      # palabra. Resultados en una lista de 3 cadenas con una vacía si
                      # la palabra se puede escribir con una fila
    } k # Compruebe si la lista contiene una cadena vacía
elD # ordena la lista de resultados por longitud y toma el último

Rubí, 88 82 69

Si no se me permite tomar una lista de cadenas y debo tomar una cadena multilínea, agregue +12 a la puntuación y agregue .split('\n')justo antes de la .grepllamada.

Gracias CatsAreFluffy por enseñarme sobre lambdas stabby en Ruby, y otras optimizaciones de manatwork

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

C #, 141/112 / (120 bytes)

Contendiente por el peor lenguaje de golf, por razones obvias. Utiliza "my" locale con qwertz en lugar de qwerty, pero de lo contrario funciona bien.

Programa completo sin donde:

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

Solo salida sin Where:

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

Solo salida (original):

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

bash105 bytes

Y varias otras utilidades, por supuesto.

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}  

ahorró 3 bytes gracias a la sugerencia de @Wolfgang

MATL , 54 bytes

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

Esto funciona con la versión actual (14.0.0) del lenguaje / compilador.

El formato de entrada es (primer ejemplo)

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

o (segundo ejemplo)

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

Pruébalo en línea!

Explicación

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

El símbolo a la letra cuenta bastante alto.

Groovy, 65 personajes

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

Ejecución de muestra:

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

Tenga en cuenta que la expresión regular utilizada por .grep()no requiere anclaje, lo que permite ahorrar también la agrupación:

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