W Keep Talking and Nobody Explodes gracze mają za zadanie rozbroić bomby na podstawie informacji od swoich „ekspertów” (innych osób posiadających instrukcję). Każda bomba składa się z modułów, z których jednym mogą być hasła, przy czym ekspert otrzymuje listę możliwych haseł o długości wszystkich pięciu liter:

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

Gracz otrzymuje listę 6 możliwych liter dla każdego miejsca w haśle. Biorąc pod uwagę możliwe kombinacje liter, wpisz poprawne hasło. Dane wejściowe mogą mieć dowolny rozsądny format (tablica 2D, ciąg oddzielony znakiem nowej linii itp.) Możesz zdyskontować kod, którego używasz do kompresowania / generowania listy / łańcucha / tablicy / dowolnego hasła. (Dzięki @DenkerAffe)

UWAGA: Hasła nie uwzględniają wielkości liter. Możesz założyć, że dane wejściowe rozwiążą się tylko dla jednego hasła.

Przykłady / przypadki testowe

Dane wejściowe będą reprezentowane jako tablica ciągów.

["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"] => first
["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"] => large
["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"] => still

Pyth, 13 bajtów

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

Zestaw testowy.

 #             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

Bash, 22 bajty

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

Uruchom tak:

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

JavaScript (ES6), 62 bajty

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

53 bajty w przeglądarce Firefox 48 lub wcześniejszej:

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

Byłoby 49 bajtów, gdyby nie wymóg rozróżniania wielkości liter:

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

f=
  (l,p)=>p.find(w=>l.every((s,i)=>eval(`/[${s}]/i`).test(w[i])))
;
p=["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"];
o1.value=f(["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"],p)
o2.value=f(["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"],p)
o3.value=f(["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"],p)

<input id=o1><input id=o2><input id=o3>

Brachylog , 25 bajtów

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

Niepoliczone bajty to tablica słów, w tym nawiasy kwadratowe.

Wyjaśnienie

:@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

Rubinowy, 48 42 39 bajtów

Po zakończeniu jest bardzo podobny do rozwiązania Pyth, ale bez %sformatowania do tego stopnia, że ​​jest to w zasadzie bezpośredni port.

Jeśli podajesz tylko wynik puts, nie potrzebujesz go [0]na końcu, ponieważ putssobie z tym poradzisz.

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

W przypadkach testowych:

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

JavaScript (ES6), 71 bajtów

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

Stosowanie:

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)

Python, 64 60 57 bajtów

Kod, aby utworzyć listę słów wjako ciąg, słowa są rozdzielane spacjami (bajty są pomijane od długości kodu rozwiązania):

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"

Aktualne rozwiązanie (57 bajtów): zapisane 3 bajty dzięki @RootTwo

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

Ta funkcja przyjmuje tuple(nie list!) Dokładnie 5 ciągów, które reprezentują możliwe litery dla każdego znaku hasła jako dane wejściowe.

Zobacz ten kod działający na ideone.com

Druga wersja (60 bajtów):

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

Ta funkcja przyjmuje tuple(nie list!) Dokładnie 5 ciągów, które reprezentują możliwe litery dla każdego znaku hasła jako dane wejściowe.

Zobacz ten kod działający na ideone.com

Pierwsza wersja (64 bajty):

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

Ta funkcja pobiera dowolną iterowalną (np. listLub tuple) dokładnie 5 ciągów, które reprezentują możliwe litery dla każdego znaku hasła jako dane wejściowe.

Zobacz ten kod działający na ideone.com

Hoon , 125 bajtów

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

Nie golfowany:

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

Hoon nie ma wyrażenia regularnego, tylko system kombinatora parserów. To sprawia, że ​​wszystko jest dość skomplikowane: z (mask "abc")grubsza przekłada się na wyrażenia regularne [abc]i jest rdzeniem parsera, który budujemy.

;~(plug a b)jest monadycznym połączeniem dwóch parserów ++plug, które musi parsować pierwszy, a następnie drugi, bo inaczej się nie powiedzie.

++kneesłuży do budowy rekurencyjnego analizatora składni; dajemy mu typ ( *tape) wyniku i wywołanie zwrotne do wywołania w celu wygenerowania rzeczywistego analizatora składni. W takim przypadku wywołanie zwrotne to „ponownie wywołać całe zamknięcie, ale zamiast tego z ogonem listy”. W ?~runiczne testy lista jest pusta, a daje (easy ~)(nie robić nic i zwrot składniowy ~) lub dodaje na inny maski recurse ponownie.

Po zbudowaniu parsera możemy zacząć z niego korzystać. ++skipusuwa wszystkie elementy listy, dla których funkcja zwraca „tak”. ++rustpróbuje przeanalizować element z naszą regułą, zwracając unitktóra jest albo [~ u=result]albo ~(nasza wersja Haskella może). Jeśli jest ~(Brak, a reguła albo nie parsowała albo nie parsowała całej zawartości), wówczas funkcja zwraca true, a element jest usuwany.

Pozostała tylko lista zawierająca tylko słowo, w którym każda litera jest jedną z podanych opcji. Zakładam, że lista haseł znajduje się już w kontekście pod nazwą 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=<<>>]

Python 3, 81 bajtów

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

Anonimowa funkcja, która pobiera dane z listy ciągów xi zwraca hasło.

Lista możliwych haseł ljest zdefiniowana jako:

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']

To prosta brutalna siła; Byłem zainteresowany, aby zobaczyć, jak krótko mogę to zrobić bez wyrażeń regularnych.

Jak to działa

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

Wypróbuj na Ideone