Sobre el tema de las contraseñas

10

En Keep Talking and Nobody Explodes , los jugadores tienen la tarea de desactivar bombas en base a la información de sus "expertos" (otras personas con un manual). Cada bomba está compuesta de módulos, uno de los cuales puede ser una contraseña, donde el experto recibe esta lista de posibles contraseñas, las cinco letras largas:

about   after   again   below   could
every   first   found   great   house
large   learn   never   other   place
plant   point   right   small   sound
spell   still   study   their   there
these   thing   think   three   water
where   which   world   would   write

Y el jugador recibe una lista de 6 letras posibles para cada lugar en la contraseña. Dadas las posibles combinaciones de letras, envíe la contraseña correcta. La entrada puede estar en cualquier formato razonable (matriz 2D, cadena separada por nueva línea, etc.) Puede descontar el código que usa para comprimir / generar la lista / cadena / matriz / cualquier contraseña. (Gracias @DenkerAffe)

NOTA: Las contraseñas no distinguen entre mayúsculas y minúsculas. Puede suponer que la entrada solo resolverá una contraseña.

Ejemplos / Casos de prueba

La entrada aquí se representará como una matriz de cadenas. 

["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"] => first
["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"] => large
["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"] => still
code-golf 
— AlcaldeMonty
fuente
— Rɪᴋᴇʀ
8
Sugiero permitir la lista de posibles contraseñas como entrada para el programa. De lo contrario, esto se reduce a qué idioma tiene la mejor compresión de cadena.
— Denker
55
Está bien si lo cambias; No me importaría (la mayor parte de mi presentación permanecería sin cambios).
— Pomo de la puerta
44
Estoy de acuerdo con DenkerAffe: tener las posibles contraseñas como entrada en lugar de una lista estática es un desafío mucho más interesante.
— Mego
55
También podría simplificar las cosas si usa la lista de cadenas como una segunda entrada, ya que deja en claro qué bytes cuentan. No estaba seguro de si contar <en mi solución Bash, por ejemplo.
— Pomo de la puerta

Respuestas:

6

Pyth, 13 bytes

:#%*"[%s]"5Q0c"ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE"5

Banco de pruebas.

 #             filter possible words on
:           0  regex match, with pattern
  %        Q   format input as
    "[%s]"     surround each group of letters with brackets (regex char class)
   *      5    repeat format string 5 times for 5 groups of letters
— Pomo de la puerta
fuente
Olvidó actualizar su primer bloque de código: P
— Downgoat
@Downgoat ¿Qué olvidé actualizar? Me parece bien.
— Pomo de la puerta
Extraño, el primer bloque de código parece no coincidir con el ejemplo (¿parece ser una revisión antigua?)
— Downgoat
1
— Leaky Nun
6

Bash, 22 bytes

grep `printf [%s] $@`< <(echo ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE | sed 's/...../&\n/g')

Corre así:

llama@llama:~$ bash passwords.sh FGARTW LKSIRE UHRKPA TGYSTG LUOTEU
FIRST

      printf [%s] $@    surround all command line args with brackets
grep `              `   output all input lines that match this as a regex
                     <  use the following file as input to grep
— Pomo de la puerta
fuente
No hay diferencia en su puntaje, pero todavía no pude resistirme a este golf:fold -5<<<ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE|grep `printf [%s] $@`
— Digital Trauma
2

JavaScript (ES6), 62 bytes

(l,p)=>p.find(w=>l.every((s,i)=>eval(`/[${s}]/i`).test(w[i])))

53 bytes en Firefox 48 o anterior:

(l,p)=>p.find(w=>l.every((s,i)=>~s.search(w[i],"i")))

Hubiera sido de 49 bytes si no fuera por ese requisito de insensibilidad de caso:

(l,p)=>p.find(w=>l.every((s,i)=>~s.search(w[i])))

Mostrar fragmento de código

— Neil
fuente
2

Brachylog , 25 bytes

:@laL,["about":"after":"again":"below":"could":"every":"first":"found":"great":"house":"large":"learn":"never":"other":"place":"plant":"point":"right":"small":"sound":"spell":"still":"study":"their":"there":"these":"thing":"think":"three":"water":"where":"which":"world":"would":"write"]:Jm.'(:ImC,L:Im'mC)

Los bytes no contados son el conjunto de palabras, incluidos los corchetes.

Explicación

:@laL                          Unifies L with the input where each string is lowercased
     ,[...]:Jm.                Unifies the Output with one of the words
               '(            ) True if what's in the parentheses is false,
                               else backtrack and try another word
                 :ImC          Unify C with the I'th character of the output
                     ,L:Im'mC  True if C is not part of the I'th string of L
— Fatalizar
fuente
2

Ruby, 48 42 39 bytes

Ahora que está hecho, es muy similar a la solución Pyth, pero sin %sformatear hasta el punto de que ahora es básicamente un puerto directo.

Si solo genera el resultado puts, no necesita [0]el final, ya que putsse ocupará de eso por usted.

->w,l{w.grep(/#{'[%s]'*l.size%l}/i)[0]}

Con casos de prueba:

f=->w,l{w.grep(/#{'[%s]'*l.size%l}/i)[0]}

w = %w{about after again below could
every first found great house
large learn never other place
plant point right small sound
spell still study their there
these thing think three water
where which world would write}

puts f.call(w, ["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"]) # first
puts f.call(w, ["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"]) # large
puts f.call(w, ["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"]) # still
— Tinta de valor
fuente
1

JavaScript (ES6), 71 bytes

w=>l=>w.filter(s=>eval("for(b=1,i=5;i--;)b&=!!~l[i].indexOf(s[i])")[0])

Uso:

f=w=>l=>w.filter(s=>eval("for(b=1,i=5;i--;)b&=!!~l[i].indexOf(s[i])")[0])
f(array_of_words)(array_of_letters)
— Patrick Roberts
fuente
1

Python, 64 60 57 bytes

Código para crear la lista de palabras wcomo una cadena, las palabras están separadas por espacios (los bytes se descuentan de la longitud del código de la solución):

w="about after again below could every first found great house large learn never other place plant point right small sound spell still study their there these thing think three water where which world would write"

Solución actual (57 bytes): guardado 3 bytes gracias a @RootTwo

import re;f=lambda a:re.findall("(?i)\\b"+"[%s]"*5%a,w)[0]

Esta función toma un tuple(nolist ¡ !) De exactamente 5 cadenas que representan las letras posibles para cada carácter de contraseña como entrada.

Vea este código ejecutándose en ideone.com

Segunda versión (60 bytes):

import re;f=lambda a:re.findall("\\b"+"[%s]"*5%a+"(?i)",w)[0]

Esta función toma un tuple(nolist ¡ !) De exactamente 5 cadenas que representan las letras posibles para cada carácter de contraseña como entrada.

Vea este código ejecutándose en ideone.com

Primera versión (64 bytes):

import re;f=lambda a:re.findall("\\b["+"][".join(a)+"](?i)",w)[0]

Esta función toma cualquier iterable (por ejemplo, listotuple ) de exactamente 5 cadenas que representan las letras posibles para cada carácter de contraseña como entrada.

Vea este código ejecutándose en ideone.com

— Byte Commander
fuente
1
Ahorre tres bytes utilizando esta expresión regular:"(?i)\\b"+"[%s]"*5%a
— RootTwo
Por supuesto, qué "error" obvio de mi parte ... Gracias por señalar esto @RootTwo, edité mi respuesta y le di créditos.
— Byte Commander
@ByteCommander No veo ningún crédito en absoluto.
— Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Justo debajo de la w=...línea de código: " La solución real (57 bytes, guardada 3 bytes gracias a @RootTwo): "
— Byte Commander
@ByteCommander Tal vez hice una vista previa de una versión anterior después de despertar mi PC de la hibernación.
— Erik the Outgolfer
0

Hoon , 125 bytes

|=
r/(list tape)
=+
^=
a
|-
?~
r
(easy ~)
;~
plug
(mask i.r)
(knee *tape |.(^$(r t.r)))
==
(skip pass |*(* =(~ (rust +< a))))

Sin golf:

|=  r/(list tape)
=+  ^=  a
|-
  ?~  r
    (easy ~)
  ;~  plug
    (mask i.r)
    (knee *tape |.(^$(r t.r)))
  ==
(skip pass |*(* =(~ (rust +< a))))

Hoon no tiene expresiones regulares, solo un sistema combinador de analizador sintáctico. Esto hace que sea bastante complicado hacer que todo funcione: (mask "abc")aproximadamente se traduce en expresiones regulares.[abc] , y es el núcleo del analizador que estamos construyendo.

;~(plug a b) es un enlace monádico de dos analizadores bajo ++plug , que tiene que analizar el primero y luego el segundo, o de lo contrario falla.

++kneese usa para construir un analizador recursivo; le damos un tipo ( *tape) del resultado y una devolución de llamada para llamar para generar el analizador real. En este caso, la devolución de llamada es "volver a llamar al cierre completo, pero con el final de la lista". La ?~prueba de runas es que la lista está vacía y da (easy ~)(no analice nada y devuelva ~) o agrega otra masky vuelve a aparecer.

Una vez construido el analizador, podemos comenzar a usarlo. ++skipelimina todos los elementos de la lista para los que la función devuelve yes para. ++rustintenta analizar el elemento con nuestra regla, devolviendo uno unitque sea uno [~ u=result]o ~(nuestra versión de Haskell's Maybe). Si es ~(Ninguno, y la regla no pudo analizar o no analizó todo el contenido), la función devuelve verdadero y el elemento se elimina.

Lo que queda es una lista, que contiene solo la palabra donde cada letra es una de las opciones en la lista dada. Supongo que la lista de contraseñas ya está en el contexto bajo el nombre pass.

> =pass %.  :*  "ABOUT"  "AFTER"   "AGAIN"   "BELOW"   "COULD"
   "EVERY"   "FIRST"   "FOUND"   "GREAT"   "HOUSE"
   "LARGE"   "LEARN"   "NEVER"   "OTHER"   "PLACE"
   "PLANT"   "POINT"   "RIGHT"   "SMALL"   "SOUND"
   "SPELL"   "STILL"   "STUDY"   "THEIR"   "THERE"
   "THESE"   "THING"   "THINK"   "THREE"   "WATER"
   "WHERE"   "WHICH"   "WORLD"   "WOULD"   "WRITE"
   ~  ==  limo
> %.  ~["SHWYEU" "YEUTLS" "IHEWRA" "HWULER" "EUELJD"]
  |=
  r/(list tape)
  =+
  ^=
  a
  |-
  ?~
  r
  (easy ~)
  ;~
  plug
  (mask i.r)
  (knee *tape |.(^$(r t.r)))
  ==
  (skip pass |*(* =(~ (rust +< a))))
[i="STILL" t=<<>>]
— RenderSettings
fuente
0

Python 3, 81 bytes

from itertools import*
lambda x:[i for i in map(''.join,product(*x))if i in l][0]

Una función anónima que toma la entrada de una lista de cadenas xy devuelve la contraseña.

La lista de posibles contraseñas lse define como:

l=['ABOUT', 'AFTER', 'AGAIN', 'BELOW', 'COULD',
   'EVERY', 'FIRST', 'FOUND', 'GREAT', 'HOUSE',
   'LARGE', 'LEARN', 'NEVER', 'OTHER', 'PLACE',
   'PLANT', 'POINT', 'RIGHT', 'SMALL', 'SOUND',
   'SPELL', 'STILL', 'STUDY', 'THEIR', 'THERE',
   'THESE', 'THING', 'THINK', 'THREE', 'WATER',
   'WHERE', 'WHICH', 'WORLD', 'WOULD', 'WRITE']

Esta es una fuerza bruta simple; Me interesaba ver cuán corto podría obtener esto sin expresiones regulares.

Cómo funciona

from itertools import*  Import everything from the Python module for iterable generation
lambda x                Anonymous function with input list of strings x
product(*x)             Yield an iterable containing all possible passwords character by
                        character
map(''.join,...)        Yield an iterable containing all possible passwords as strings by
                        concatenation
...for i in...          For all possible passwords i...
i...if i in l           ...yield i if i is in the password list
:[...][0]               Yield the first element of the single-element list containing the
                        correct password and return

Pruébalo en Ideone

— TheBikingViking
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.