Zum Thema Passwörter

10

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
code-golf BürgermeisterMonty
quelle
Verbunden.
Rɪᴋᴇʀ
8
Ich schlage vor, die Liste möglicher Passwörter als Eingabe für das Programm zuzulassen. Andernfalls hängt es davon ab, welche Sprache die beste Zeichenfolgenkomprimierung aufweist.
Denker
5
Es ist in Ordnung, wenn Sie es ändern; Ich hätte nichts dagegen (der Großteil meiner Einreichung würde unverändert bleiben).
Türknauf
4
Ich stimme DenkerAffe zu - die Angabe der möglichen Passwörter als Eingabe anstelle einer statischen Liste ist eine viel interessantere Herausforderung.
Mego
5
Es könnte die Dinge vereinfachen, wenn Sie die Liste der Zeichenfolgen auch als zweite Eingabe verwenden, da dadurch klar wird, welche Bytes zählen. Ich war mir <zum Beispiel nicht sicher, ob ich das in meiner Bash-Lösung zählen sollte.
Türknauf

Antworten:

6

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
Türknauf
quelle
Sie haben vergessen, Ihren ersten Codeblock zu aktualisieren: P
Downgoat
@Downgoat Was habe ich vergessen zu aktualisieren? Es sieht für mich richtig aus.
Türknauf
Seltsamerweise
1
8 Bytes
Leaky Nun
6

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
Türknauf
quelle
Es macht keinen Unterschied zu Ihrer Punktzahl, aber ich konnte diesem Golf immer noch nicht widerstehen:fold -5<<<ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE|grep `printf [%s] $@`
Digital Trauma
2

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

Code-Snippet anzeigen

Neil
quelle
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)

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
Fatalisieren
quelle
2

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
Wert Tinte
quelle
1

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)
Patrick Roberts
quelle
1

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

Byte Commander
quelle
1
Speichern Sie drei Bytes mit diesem "(?i)\\b"+"[%s]"*5%a
regulären Ausdruck
Natürlich, was für ein offensichtlicher "Fehler" von meiner Seite ... Vielen Dank, dass Sie auf @RootTwo hingewiesen haben. Ich habe meine Antwort bearbeitet und Ihnen Credits gegeben.
Byte Commander
@ByteCommander Ich sehe überhaupt keine Gutschrift.
Erik der Outgolfer
@ ΈρικΚωνσταντόπουλος Direkt unter der w=...Codezeile: " Die eigentliche Lösung (57 Bytes, 3 Bytes dank @RootTwo gespeichert): "
Byte Commander
@ByteCommander Vielleicht habe ich eine Vorschau einer früheren Version angezeigt, nachdem ich meinen PC aus dem Ruhezustand geweckt habe.
Erik der Outgolfer
0

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=<<>>]
RenderSettings
quelle
0

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

TheBikingViking
quelle