에서 보관할 이야기하고 아무도 폭발한다 , 선수 (수동 다른 사람들이) 자신의 "전문가"의 정보를 기반으로 폭탄을 해체하는 임무된다. 각 폭탄은 모듈로 구성되어 있으며, 그 중 하나는 암호 일 수 있으며, 전문가는 5 자 길이의 가능한 암호 목록을받습니다.

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

자바 스크립트 (ES6), 62 바이트

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

Firefox 48 이하에서 53 바이트 :

(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

루비, 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

자바 스크립트 (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 바이트) : @RootTwo 덕분에 3 바이트 절약

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

이 함수는 각 암호 문자의 가능한 문자를 입력으로 나타내는 정확히 5 개의 문자열 tuple( list!)을 취합니다 .

ideone.com에서 실행되는이 코드를보십시오

두 번째 버전 (60 바이트) :

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

이 함수는 각 암호 문자의 가능한 문자를 입력으로 나타내는 정확히 5 개의 문자열 tuple( list!)을 취합니다 .

ideone.com에서 실행되는이 코드를보십시오

첫 번째 버전 (64 바이트) :

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

이 함수는 각 암호 문자의 가능한 문자를 입력으로 나타내는 정확히 5 개의 문자열 중 반복 가능 (예 : list또는 tuple)을 사용합니다.

ideone.com에서 실행되는이 코드를보십시오

Hoon , 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함수가 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=<<>>]

파이썬 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에서 사용해보십시오