In Keep Talking und Nobody Explodes müssen die Spieler Bomben entschärfen, basierend auf Informationen ihrer "Experten" (andere Personen mit einem Handbuch). Jede Bombe besteht aus Modulen, von denen eines Passwörter sein können, wobei der Experte diese Liste möglicher Passwörter erhält, die alle fünf Buchstaben lang sind:

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

Und der Spieler erhält eine Liste mit 6 möglichen Buchstaben für jede Stelle im Passwort. Geben Sie angesichts der möglichen Buchstabenkombinationen das richtige Passwort aus. Die Eingabe kann in jedem vernünftigen Format erfolgen (2D-Array, durch Zeilenumbruch getrennte Zeichenfolge usw.). Sie können den Code, den Sie zum Komprimieren / Generieren der Liste / Zeichenfolge / des Arrays / eines beliebigen Kennworts verwenden, rabattieren. (Danke @DenkerAffe)

HINWEIS: Bei Passwörtern wird die Groß- und Kleinschreibung nicht berücksichtigt. Sie können davon ausgehen, dass die Eingabe nur für ein Kennwort aufgelöst wird.

Beispiele / Testfälle

Die Eingabe hier wird als Array von Zeichenfolgen dargestellt.

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

Pyth, 13 Bytes

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

Testsuite.

 #             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 Bytes

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

Lauf so:

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 Byte

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

53 Bytes in Firefox 48 oder früher:

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

Wäre 49 Bytes gewesen, wenn nicht für diesen Fall Unempfindlichkeitsanforderung:

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

Die nicht gezählten Bytes sind das Array von Wörtern, einschließlich der eckigen Klammern.

Erläuterung

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

Ruby, 48 42 39 Bytes

Jetzt, da es fertig ist, ist es der Pyth-Lösung sehr ähnlich, aber ohne %sFormatierung bis zu dem Punkt, an dem es jetzt im Grunde ein direkter Port ist.

Wenn Sie nur das Ergebnis mit ausgeben puts, brauchen Sie das [0]am Ende nicht, da dies putsfür Sie erledigt wird.

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

Mit Testfällen:

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 Byte

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

Verwendungszweck:

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 Bytes

Code zum Erstellen einer Wortliste wals Zeichenfolge, Wörter werden durch Leerzeichen getrennt (Bytes werden von der Länge des Lösungscodes abgezogen):

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"

Aktuelle Lösung (57 Bytes): 3 Bytes dank @RootTwo gespart

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

Diese Funktion verwendet ein tuple(Nein list!) Von genau 5 Zeichenfolgen, die die möglichen Buchstaben für jedes Kennwortzeichen als Eingabe darstellen.

Sehen Sie diesen Code auf ideone.com

Zweite Version (60 Bytes):

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

Diese Funktion verwendet ein tuple(Nein list!) Von genau 5 Zeichenfolgen, die die möglichen Buchstaben für jedes Kennwortzeichen als Eingabe darstellen.

Sehen Sie diesen Code auf ideone.com

Erste Version (64 Bytes):

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

Diese Funktion verwendet eine beliebige Iteration (z. B. listoder tuple) von genau 5 Zeichenfolgen, die die möglichen Buchstaben für jedes Kennwortzeichen als Eingabe darstellen.

Sehen Sie diesen Code auf ideone.com

Hoon , 125 Bytes

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

Ungolfed:

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

Hoon hat keinen regulären Ausdruck, nur ein Parser-Kombinatorsystem. Dies macht es ziemlich kompliziert, alles (mask "abc")zum Laufen zu bringen: übersetzt grob in Regex [abc]und ist der Kern des Parsers, den wir erstellen.

;~(plug a b)ist eine monadische Bindung von zwei Parsern unter ++plug, die den ersten und dann den zweiten analysieren muss, sonst schlägt sie fehl.

++kneewird verwendet, um einen rekursiven Parser zu erstellen; Wir geben ihm einen Typ ( *tape) des Ergebnisses und einen Rückruf zum Aufrufen, um den eigentlichen Parser zu generieren. In diesem Fall lautet der Rückruf "Rufen Sie den gesamten Abschluss erneut auf, stattdessen jedoch mit dem Ende der Liste". Der ?~Runentest ist, dass die Liste leer ist und gibt (easy ~)(nichts analysieren und ~ zurückgeben) oder einen anderen hinzufügt maskund erneut wiederholt.

Nachdem wir den Parser erstellt haben, können wir ihn verwenden. ++skipEntfernt alle Elemente der Liste, für die die Funktion yes zurückgibt. ++rustversucht, das Element mit unserer Regel zu analysieren und unitgibt ein entweder [~ u=result]oder zurück ~(unsere Version von Haskells Vielleicht). Wenn dies der ~Fall ist (Keine, und die Regel konnte entweder nicht oder nicht den gesamten Inhalt analysieren), gibt die Funktion true zurück und das Element wird entfernt.

Was übrig bleibt, ist eine Liste, die nur das Wort enthält, bei dem jeder Buchstabe eine der Optionen in der angegebenen Liste ist. Ich gehe davon aus, dass sich die Liste der Passwörter bereits im Kontext unter dem Namen befindet 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 Bytes

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

Eine anonyme Funktion, die eine Liste von Zeichenfolgen xeingibt und das Kennwort zurückgibt.

Die Liste der möglichen Passwörter list wie folgt definiert:

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

Dies ist eine einfache rohe Kraft; Ich war interessiert zu sehen, wie kurz ich das ohne Regexe bekommen könnte.

Wie es funktioniert

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

Probieren Sie es auf Ideone