Trong Keep Talking và Nobody Explodes , người chơi có nhiệm vụ gỡ bom dựa trên thông tin từ "chuyên gia" của họ (những người khác có hướng dẫn sử dụng). Mỗi quả bom được tạo thành từ các mô-đun, một trong số đó có thể là mật khẩu, trong đó chuyên gia được cung cấp danh sách mật khẩu có thể này, tất cả dài năm chữ cái:

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

Và người chơi được cung cấp một danh sách 6 chữ cái có thể cho mỗi nơi trong mật khẩu. Cho các kết hợp chữ cái có thể, xuất mật khẩu chính xác. Đầu vào có thể ở bất kỳ định dạng hợp lý nào (mảng 2D, chuỗi được phân tách bằng dòng mới, v.v.) Bạn có thể giảm giá mã mà bạn sử dụng để nén / tạo danh sách / chuỗi / mảng / bất kỳ mật khẩu nào. (Cảm ơn @DenkerAffe)

LƯU Ý: Mật khẩu không phân biệt chữ hoa chữ thường. Bạn có thể cho rằng đầu vào sẽ chỉ giải quyết được một mật khẩu.

Ví dụ / Trường hợp kiểm tra

Đầu vào ở đây sẽ được biểu diễn dưới dạng một chuỗi các chuỗi.

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

Bình thường, 13 byte

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

Bộ thử nghiệm.

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

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

Chạy như vậy:

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 byte trên Firefox 48 trở về trước:

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

Sẽ là 49 byte nếu không có yêu cầu không nhạy cảm trong trường hợp đó:

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

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

Các byte không đếm được là mảng các từ, bao gồm cả dấu ngoặc vuông.

Giải trình

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

Bây giờ nó đã được thực hiện, nó rất giống với giải pháp Pyth, nhưng không %sđịnh dạng đến mức về cơ bản nó là một cổng trực tiếp.

Nếu bạn chỉ đưa ra kết quả với puts, cuối cùng bạn sẽ không cần điều [0]đó vì putsbạn sẽ giải quyết vấn đề đó cho bạn.

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

Với các trường hợp thử nghiệm:

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

Sử dụng:

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 byte

Mã để tạo danh sách từ wdưới dạng chuỗi, các từ được phân tách bằng dấu cách (byte được chiết khấu từ độ dài mã giải pháp):

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"

Giải pháp hiện tại (57 byte): đã lưu 3 byte nhờ @RootTwo

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

Hàm này lấy một tuple(không list!) Chính xác 5 chuỗi đại diện cho các chữ cái có thể có cho mỗi ký tự mật khẩu làm đầu vào.

Xem mã này đang chạy trên ideone.com

Phiên bản thứ hai (60 byte):

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

Hàm này lấy một tuple(không list!) Chính xác 5 chuỗi đại diện cho các chữ cái có thể có cho mỗi ký tự mật khẩu làm đầu vào.

Xem mã này đang chạy trên ideone.com

Phiên bản đầu tiên (64 byte):

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

Hàm này lấy bất kỳ số lặp (ví dụ listhoặc tuple) chính xác của 5 chuỗi đại diện cho các chữ cái có thể có cho mỗi ký tự mật khẩu làm đầu vào.

Xem mã này đang chạy trên ideone.com

Hoon , 125 byte

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

Ung dung:

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

Hoon không có regex, chỉ có một hệ thống kết hợp trình phân tích cú pháp. Điều này làm cho nó khá phức tạp để khiến mọi thứ hoạt động: (mask "abc")tạm dịch là regex [abc]và là cốt lõi của trình phân tích cú pháp mà chúng tôi đang xây dựng.

;~(plug a b)là một liên kết đơn âm của hai trình phân tích cú pháp bên dưới ++plug, phải phân tích cú pháp đầu tiên và sau đó lần thứ hai nếu không nó sẽ thất bại.

++kneeđược sử dụng để xây dựng một trình phân tích cú pháp đệ quy; chúng tôi cung cấp cho nó một loại ( *tape) kết quả và gọi lại để gọi để tạo trình phân tích cú pháp thực tế. Trong trường hợp này, cuộc gọi lại là "gọi lại toàn bộ lần đóng, nhưng với phần đuôi của danh sách thay thế". Các ?~bài kiểm tra rune là danh sách trống, và đưa ra (easy ~)(không phân tích bất cứ điều gì và trả về ~) hoặc thêm vào một bài kiểm tra khác maskvà lặp lại.

Khi đã xây dựng trình phân tích cú pháp, chúng ta có thể sử dụng nó. ++skiploại bỏ tất cả các thành phần của danh sách mà hàm trả về có cho. ++rustcố gắng để phân tích nguyên tố này với nguyên tắc của chúng tôi, trả lại một unitmà là một trong hai [~ u=result]hoặc ~(phiên bản của chúng ta về Haskell của lẽ). Nếu nó ~(Không có và quy tắc không thể phân tích cú pháp hoặc không phân tích toàn bộ nội dung), thì hàm trả về true và phần tử bị xóa.

Những gì còn lại là một danh sách, chỉ chứa từ mà mỗi chữ cái là một trong các tùy chọn trong danh sách được cung cấp. Tôi giả sử rằng danh sách mật khẩu đã có trong ngữ cảnh dưới tên 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 byte

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

Một hàm ẩn danh nhận đầu vào của một danh sách các chuỗi xvà trả về mật khẩu.

Danh sách các mật khẩu có thể lđược xác định 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']

Đây là một lực lượng vũ phu đơn giản; Tôi đã quan tâm để xem làm thế nào ngắn tôi có thể nhận được điều này mà không cần regexes.

Làm thế nào nó hoạt động

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

Hãy thử nó trên Ideone