ในKeep Talking and Nobody Explodesผู้เล่นจะได้รับมอบหมายให้ปลดชนวนระเบิดตามข้อมูลจาก "ผู้เชี่ยวชาญ" ของพวกเขา (คนอื่น ๆ ที่มีคู่มือ) การวางระเบิดแต่ละครั้งประกอบด้วยโมดูลซึ่งหนึ่งในนั้นอาจเป็นรหัสผ่านซึ่งผู้เชี่ยวชาญจะได้รับรายการรหัสผ่านที่เป็นไปได้นี้มีความยาวห้าตัวอักษร:

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

และผู้เล่นจะได้รับรายชื่อตัวอักษรที่เป็นไปได้ 6 ตัวสำหรับแต่ละสถานที่ในรหัสผ่าน เมื่อได้รับการผสมผสานตัวอักษรที่เป็นไปได้ส่งออกรหัสผ่านที่ถูกต้อง อินพุตอาจอยู่ในรูปแบบที่สมเหตุสมผล (อาเรย์ 2 มิติ, สตริงคั่นด้วยบรรทัดใหม่, ฯลฯ ) คุณสามารถลดรหัสที่คุณใช้ในการบีบอัด / สร้างรายการ / สตริง / อาร์เรย์ / สิ่งใด ๆ ของรหัสผ่าน (ขอบคุณ @DenkerAffe)

หมายเหตุ: รหัสผ่านไม่ตรงตามตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก คุณอาจสันนิษฐานว่าอินพุตจะแก้ไขได้เพียงรหัสเดียวเท่านั้น

ตัวอย่าง / กรณีทดสอบ

อินพุตที่นี่จะแสดงเป็นอาร์เรย์ของสตริง

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

Pyth, 13 ไบต์

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

ชุดทดสอบ

 #             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 ไบต์

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

ทำงานอย่างนั้น:

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 ไบต์

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

53 ไบต์บน Firefox 48 หรือเร็วกว่า:

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

น่าจะเป็น 49 ไบต์หากไม่ใช่เพราะข้อกำหนดเรื่องความรู้สึกไว

(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 ไบต์

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

ไบต์ที่ไม่ได้นับเป็นอาร์เรย์ของคำรวมถึงวงเล็บเหลี่ยม

คำอธิบาย

:@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 ไบต์

ตอนนี้เสร็จแล้วมันคล้ายกับโซลูชัน Pyth มากแต่ไม่มี%sการจัดรูปแบบจนถึงจุดที่เป็นพอร์ตโดยตรงในขณะนี้

หากคุณส่งออกผลลัพธ์เพียงอย่างเดียวputsคุณไม่จำเป็นต้องใช้[0]ที่สิ้นสุดเนื่องจากputsจะจัดการกับสิ่งนั้นให้คุณ

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

กับกรณีทดสอบ:

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 ไบต์

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

การใช้งาน:

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)

งูหลาม64 60 57 ไบต์

รหัสเพื่อสร้างรายการคำ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"

โซลูชันปัจจุบัน (57 ไบต์): บันทึกไว้ 3 ไบต์ด้วย@RootTwo

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

ฟังก์ชั่นนี้ใช้สตริงtuple(ไม่ใช่list!) ของ 5 สตริงซึ่งแสดงถึงตัวอักษรที่เป็นไปได้สำหรับอักขระรหัสผ่านแต่ละตัวเป็นอินพุต

ดูรหัสนี้ทำงานบน ideone.com

รุ่นที่สอง (60 ไบต์):

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

ฟังก์ชั่นนี้ใช้สตริงtuple(ไม่ใช่list!) ของ 5 สตริงซึ่งแสดงถึงตัวอักษรที่เป็นไปได้สำหรับอักขระรหัสผ่านแต่ละตัวเป็นอินพุต

ดูรหัสนี้ทำงานบน ideone.com

รุ่นแรก (64 ไบต์):

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

ฟังก์ชั่นนี้ใช้ทุก iterable (เช่นlistหรือtuple) ของ 5 สายตรงซึ่งแสดงถึงตัวอักษรที่เป็นไปได้สำหรับอักขระรหัสผ่านแต่ละตัวเป็นอินพุต

ดูรหัสนี้ทำงานบน ideone.com

ฮุน , 125 ไบต์

|=
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 ไม่มี regex เพียงระบบตัวแยกวิเคราะห์ parser สิ่งนี้ทำให้มันค่อนข้างซับซ้อนในการทำให้ทุกอย่างทำงาน: (mask "abc")แปลโดยประมาณเป็น regex [abc]และเป็นแกนหลักของตัวแยกวิเคราะห์ที่เรากำลังสร้าง

;~(plug a b)คือการโยงแบบ monadic ของ parsers สองอันภายใต้++plugซึ่งจะต้องวิเคราะห์คำแรกและสองหรืออย่างอื่นที่ล้มเหลว

++kneeใช้ในการสร้างตัวแยกวิเคราะห์ซ้ำ เราให้ผลเป็นประเภท ( *tape) กับผลลัพธ์และการโทรกลับเพื่อโทรหาเพื่อสร้างตัวแยกวิเคราะห์จริง ในกรณีนี้การโทรกลับคือ "เรียกการปิดทั้งหมดอีกครั้ง แต่ใช้ส่วนท้ายของรายการแทน" การ?~ทดสอบ rune คือรายการว่างเปล่าและให้(easy ~)(ไม่แยกวิเคราะห์อะไรเลยและส่งคืน ~) หรือเพิ่มในรายการอื่นmaskและเรียกคืนอีกครั้ง

เมื่อสร้าง parser แล้วเราสามารถใช้มันได้ ++skipลบองค์ประกอบทั้งหมดของรายการที่ฟังก์ชันคืนค่าใช่ ++rustพยายามแยกวิเคราะห์องค์ประกอบด้วยกฎของเราคืนหนึ่งunitซึ่งเป็น[~ u=result]หรือ~(อาจเป็นเวอร์ชัน Haskell ของเรา) ถ้าเป็น~(ไม่มีและกฎไม่สามารถแยกวิเคราะห์หรือไม่แยกเนื้อหาทั้งหมด) ดังนั้นฟังก์ชันจะส่งกลับค่าจริงและองค์ประกอบจะถูกลบออก

สิ่งที่เหลืออยู่คือรายการที่มีเฉพาะคำที่แต่ละตัวอักษรเป็นหนึ่งในตัวเลือกในรายการที่กำหนด ฉันสมมติว่ารายการรหัสผ่านอยู่ในบริบทภายใต้ชื่อ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 ไบต์

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

ฟังก์ชันที่ไม่ระบุชื่อที่รับอินพุตของรายการสตริง xและส่งคืนรหัสผ่าน

รายการรหัสผ่านที่เป็นไปได้lถูกกำหนดเป็น:

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

นี่คือกำลังดุร้ายอย่างง่าย ฉันสนใจที่จะดูว่าฉันจะได้รับเพียงสั้น ๆ โดยไม่ต้อง regexes

มันทำงานอย่างไร

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

ลองใช้กับ Ideone