В играх «Продолжай говорить» и «Никто не взрывается» игрокам поручено обезвреживать бомбы на основе информации, полученной от их «экспертов» (других людей с руководством). Каждая бомба состоит из модулей, одним из которых могут быть пароли, где эксперту выдается этот список возможных паролей длиной всего пять букв:

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)

Python, 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))))

Ungolfed:

|=  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удаляет все элементы списка, для которых функция возвращает yes. ++rustпытается проанализировать элемент с нашим правилом, возвращая либо, unitчто либо, [~ u=result]либо ~(наша версия Haskell's Maybe). Если это ~(Нет, и правило либо не смогло проанализировать, либо не проанализировало все содержимое), то функция возвращает 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