У програмі 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 можливих літер для кожного місця в паролі. Враховуючи можливі комбінації літер, виведіть правильний пароль. Введення може бути у будь-якому розумному форматі (2D масив, рядок, розділений новим рядком тощо). Ви можете знизити код, який ви використовуєте для стиснення / створення списку / рядка / масиву / будь-яких паролів. (Дякую @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

Баш, 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>

Брахілог , 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

Рубі, 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]

Ця функція приймає будь-які ітерабельні (наприклад, 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))))

Безголівки:

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

У Hoon немає регулярного вираження, лише система комбінаторів парсера. Це робить досить складним, щоб все працювало: (mask "abc")грубо перекладається на регулярні вирази [abc], і це ядро ​​аналізатора, який ми будуємо.

;~(plug a b)є монадичним зв'язуванням двох парсерів під ++plug, яке має розібрати перший, а потім другий, інакше воно провалиться.

++kneeвикористовується для побудови рекурсивного аналізатора; ми надаємо йому тип ( *tape) результату та зворотний виклик для виклику для створення фактичного аналізатора. У цьому випадку зворотний виклик - це "зателефонуйте все закриття ще раз, але замість хвоста списку". В ?~руно тестів список порожній, і дають (easy ~)(НЕ розбір нічого і повернення ~) або додає інші maskі рекурсію знову.

Побудувавши аналізатор, ми можемо перейти до його використання. ++skipвидаляє всі елементи списку, для яких функція повертає так для. ++rustнамагається розібрати елемент із нашим правилом, повернувши a, unitщо є [~ u=result]або ~(нашою версією Haskell's Maybe). Якщо це ~(None, і правило або не вдалося проаналізувати або не проаналізував весь вміст), функція повертає true та елемент видаляється.

Залишився список - це лише те слово, де кожна літера є одним із параметрів у наведеному списку. Я припускаю, що список паролів вже в контексті під назвою 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']

Це проста груба сила; Мені було цікаво подивитися, як коротко я можу це отримати без регулярних виразів.

Як це працює

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