Palabra más larga usando una sola fila del teclado qwerty

30

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.

fantasmas_en_el_código
fuente
@ MartinBüttner Realmente me gustaría ver cómo esto podría resolverse con Retina. ¿Crees que se hace fácilmente?
Jerry Jeremiah
¿Las palabras de entrada están siempre en minúsculas?
nimi
@nimi Sí, lo son.
ghosts_in_the_code
@ghosts_in_the_code Deberías decir eso en el desafío por la claridad
Luis Mendo
66
Relevante xkcd: what-if.xkcd.com/75
John Dvorak

Respuestas:

18

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)
xnor
fuente
1
1 /personaje más para Python 3;)
Antti Haapala
66
No sabía que la gramática no permitía espacios en blanco entre 9y for...
jogloran 18/03/2016
Esta es, con mucho, mi respuesta favorita.
SBI
1
@jogloran, siempre que el personaje no sea un Eo e, casi siempre
wnnmaw
@wnnmaw Eso ya no es cierto para las versiones más recientes de Python, por ejemplo, 4if 0else 2es válido en 2.7.11 y 3.5.1 (y probablemente ha sido válido para algunas versiones anteriores)
Sp3000
13

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.
ETHproducciones
fuente
8
Woah, ¿acabas de superar a Dennis?
Morgan Thrapp
1
Esto va a ser difícil de superar
Adnan
2
¿Tiene "QWERTYUIOP\nASDFGHJKL\nZXCVBNM"un literal predefinido? Bien jugado :-)
Luis Mendo
1
Parece que no puedo encontrar dónde Destá establecido QWERTYUIOP\nASDFGHJKL\nZXCVBNM, incluso la página a la que te refieres parece indicarVariables <...> D 13
sukhmel
1
@sukhmel A ;al comienzo del programa restablece las variables A-La varios valores. Dse establece en la cadena del teclado. Puedes encontrar más información aquí .
ETHproductions
11

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)))
Antti Haapala
fuente
55
Bienvenido a PPCG, buen primer post :)
FryAmTheEggman
¿Por qué está la keyvariable allí? Creo que puedes eliminarlo.
CalculatorFeline
@CatsAreFluffy no, eso no es posible. El keyargumento de la maxfunción es solo de palabra clave.
Antti Haapala
Ack, me olvidé de los kwargs.
CalculatorFeline
8

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

Martin Ender
fuente
¡Esto es genial! Tendré que mirar grupos equilibrados alguna vez. Aunque parecen ser difíciles de entender. He intentado esto (y parece que funciona), pero quería esperar tu respuesta para ver qué tipo de cosas crearás.
daavko
@daavko Perdón por la autopromoción, pero ¿has leído mi publicación de Stack Overflow sobre grupos de equilibrio ? Me dicen que es una buena introducción. El concepto en sí realmente no es tan complicado, especialmente si no usa la (?<a-b>...)sintaxis que rara vez se necesita en el golf de código.
Martin Ender
No creo haber visto esa publicación. Lo más probable es que no navego Stack Overflow a menudo. Gracias por el enlace, lo marcaré y lo leeré.
daavko
1
Probablemente fuera del tema para un comentario, pero casi el 100% de mi conocimiento sobre el equilibrio de grupos proviene de haber leído su publicación. Creo que puede promocionarlo en cualquier momento, es una gran ayuda :) De todos modos, más sobre el tema, ¿ordenaría el trabajo de escenario como <code> O-1`. * </code> para obtener la línea con la entrada más larga? ¿Tal vez debería funcionar como transliteración y tener más de una región separada por retroceso, una expresión regular para dividir y una para contar? En realidad, tal vez esto también pertenece al chat ... ¯_ (ツ) _ / ¯
FryAmTheEggman
Nunca lo hubiera pensado o-r, increíble.
Emanuel Vintilă
6

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

CAD97
fuente
Mi versión actualizada ahora incluso supera a la lambda más corta como un programa completo :)
SBI
¡@SBI Curse las invocaciones de métodos largos de Java! (Todo en buena diversión)
CAD97
Siendo yo mismo un desarrollador de Java, es bueno ver un lenguaje detallado que logra ser conciso al mismo tiempo :)
SBI
Si vamos a hacer una suposición de entrada, hagamos la que más nos ayude, la entrada viene como una Lista <String>: l->l.stream().filter(g->g.matches("[wertyuio-r]*|[asdfghjkl]*|[zxcvbnm]*")).max((a,b)->a.length()-b.length()).get()(116 caracteres)
Andreas
@Andreas Según mi meta discusión reciente , si un lambda toma una Lista, debe incluir import java.util.*;en el conteo de bytes, lo que significa que tomar una lista es -16 bytes tomando una Lista pero +19 para importar la Lista. SIN EMBARGO, atrapó allí usando en maxlugar de reduceuna ganancia de -7 bytes.
CAD97
4

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

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

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

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

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}
Tinta de valor
fuente
No, agregas .split('\n')antes del .select, ¿verdad? ¿Y por qué no hay lambdas stabby?
CalculatorFeline
No sabía sobre el lambda stabby hasta ahora, cuando lo mencionaste. ¡Gracias!
Value Ink
¿Puedes agregar un espacio entre -88- y 82?
CalculatorFeline
No es necesario asignarlo a una variable, se permiten funciones anónimas; si lo único que se puede hacer dentro .selectdel bloque de código es compararlo con una expresión regular, .grepes más adecuado; no es necesario poner paréntesis alrededor de los parámetros del último método en una cadena de llamadas; .lengthtiene un alias más corto, .size:->x{x.grep(/^([o-rwetyui]+|[asdfghjkl]+|[zxcvbnm]+)$/).max_by &:size}
manatwork
3

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());
OSE
fuente
1
El desafío dice que tienes que usar querty y como de todos modos estás codificando esto, no veo ninguna razón para cambiar eso. También puede usar una función (tal vez incluso una lambda) en lugar de un programa completo para guardar algunos bytes. Esto siempre está permitido a menos que esté explícitamente prohibido en el desafío.
Denker
Estar orgulloso de mi diseño: P, no es como si tuviera la oportunidad de ganar de todos modos usando C #. Editado en una versión que es solo la salida.
SBI
Se agregó otra alternativa, usando solo Last con un predicado en lugar de usar where. Esto reduce otros 8 bytes.
SBI
2

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
Wolfgang
fuente
El awkcódigo se puede escribir más corto como $0=length"\t"$0.
manatwork
2

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

Olivier Dulac
fuente
Puede restar un byte usando en su [wetyuio-r]lugar, y también dos más haciendo en /^(expr|expr|expr)$/lugar de `/ ^ expr $ | ^ expr $ | ^ expr $ /
Wolfgang
@ Wolfgang: gracias por el consejo. Ya probé el segundo y en mi awk me dio la palabra más larga en lugar de la correcta ... Lo intentaré nuevamente. Sin embargo, estoy de acuerdo con el primero, ahorra 1 byte
Olivier Dulac
@Wolfgang: hmm, esta vez funciona (puede que haya perdido el paréntesis en mi propio examen, viernes). Edito tus consejos, gracias.
Olivier Dulac
¿Estás seguro de que los paréntesis alrededor de la expresión regular son necesarios? gawky mawkson felices sin ellos
manatwork
@manatwork: los internos son necesarios, el externo prefiero tenerlos para garantizar la lógica y el orden de evaluación. .. tal vez al "costo" de 2 caracteres
Olivier Dulac
1

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

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.

Dale Johnson
fuente
0

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]
hombre trabajando
fuente