关于密码的主题

10

在Keep Talking和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
code-golf 
— 蒙蒂市长
source
— Rɪᴋᴇʀ
8
我建议允许将可能的密码列表作为程序的输入。否则，这取决于哪种语言具有最佳的字符串压缩。
— Denker
5
如果您更改它，那很好。我不介意（我提交的大部分内容将保持不变）。
— 门把手
4
我同意DenkerAffe的观点-将可能的密码作为输入而不是静态列表来提供，这将带来更加有趣的挑战。
— Mego，2016年
5
如果还使用字符串列表作为第二个输入，则可能会简化事情，因为它可以清楚地计数哪个字节。例如，我不确定是否<在我的Bash解决方案中计算。
— 门把手

Answers:

6

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
— 门把手
source
您忘了更新您的第一个代码块了：P
— Downgoat '16
@Downgoat我忘记更新了什么？在我看来不错。
— 门把手
奇怪的是，第一个代码块似乎与示例不匹配（它似乎是旧版本？）
— Downgoat
1
— Leaky Nun
6

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
— 门把手
source
这对您的得分没有影响，但我仍然无法抗拒此高尔夫运动：fold -5<<<ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE|grep `printf [%s] $@`
— Digital Trauma
2

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

显示代码段

— 尼尔
source
2

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
— 致命
source
2

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
— 价值墨水
source
1

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)
— 帕特里克·罗伯茨
source
1

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字节）： 由于使用了@RootTwo，节省了3个字节

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上运行

— 字节指挥官
source
1
使用此正则表达式保存三个字节："(?i)\\b"+"[%s]"*5%a
— RootTwo 2016年
当然，这对我来说是一个明显的“错误”……感谢您指出@RootTwo，我编辑了答案并给了您荣誉。
— 字节指挥官
@ByteCommander我一点都看不到。
— 暴民埃里克
@ΈρικΚωωσταντόπουλος在w=...代码行的正下方：“ 实际解决方案（57字节，由于@RootTwo而节省了3个字节）： ”
— Byte Commander
@ByteCommander也许我从休眠状态唤醒计算机后预览了早期版本。
— 大公埃里克
0

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")大致翻译为regex的[abc]，并且是我们正在构建的解析器的核心。

;~(plug a b)是在下的两个解析器的单子绑定++plug，必须先解析第一个然后解析第二个，否则将失败。

++knee用于构建递归解析器；我们给它一个类型（*tape）的结果，并给它调用一个回调以生成实际的解析器。在这种情况下，回调是“再次调用整个闭包，但使用列表的末尾”。该?~符文的测试是列表是空的，并给出了(easy ~)（不解析任何事情，回报〜）或另一增加mask，并再次递归。

构建解析器之后，我们就可以开始使用它了。++skip删除函数为其返回“是”的列表中的所有元素。++rust尝试与我们的规则解析元素，返回unit其是[~ u=result]或~（我们Haskell的版本也许）。如果是~（无，规则解析失败或未解析全部内容），则该函数返回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=<<>>]
— 渲染设置
source
0

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上尝试

— 骑自行车的维京人
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.