Sobre o assunto das senhas

10

Em Keep Talking and Nobody Explodes , os jogadores são encarregados de desarmar bombas com base nas informações de seus "especialistas" (outras pessoas com um manual). Cada bomba é composta de módulos, um dos quais podem ser senhas, onde o especialista recebe essa lista de senhas possíveis, com as cinco letras:

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

E o jogador recebe uma lista de 6 letras possíveis para cada local na senha. Dadas as combinações possíveis de letras, produza a senha correta. A entrada pode estar em qualquer formato razoável (matriz 2D, sequência separada por nova linha etc.) Você pode descontar o código usado para compactar / gerar a lista / sequência / matriz / qualquer que seja a senha. (Obrigado @DenkerAffe)

NOTA: As senhas não diferenciam maiúsculas de minúsculas. Você pode assumir que a entrada resolverá apenas uma senha.

Exemplos / Casos de Teste

A entrada aqui será representada como uma matriz de seqüências de caracteres. 

["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"] => first
["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"] => large
["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"] => still
code-golf 
— MayorMonty
fonte
— Rɪᴋᴇʀ
8
Eu sugiro permitir a lista de senhas possíveis como entrada para o programa. Caso contrário, é o idioma que tem a melhor compactação de string.
— Denker 23/05
5
Tudo bem se você mudar; Eu não me importaria (a maior parte do meu envio permaneceria inalterada).
— Maçaneta
4
Concordo com a DenkerAffe - ter as senhas possíveis como entrada, em vez de uma lista estática, cria um desafio muito mais interessante.
— Mego 23/05
5
Isso pode simplificar as coisas se você também usar a lista de cadeias de caracteres como uma segunda entrada, pois deixa claro quais bytes contam. Eu não tinha certeza se deveria contar <na minha solução Bash, por exemplo.
— Maçaneta

Respostas:

6

Pitão, 13 bytes

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

Suíte de teste.

 #             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
— Maçaneta da porta
fonte
Você esqueceu de atualizar seu primeiro bloco de código: P
— Downgoat
@Downgoat O que eu esqueci de atualizar? Parece certo para mim.
— Maçaneta
Estranho, o primeiro bloco de código parece não coincidir com o exemplo (que parece ser uma revisão antiga?)
— Downgoat
11
— Freira vazada
6

Bash, 22 bytes

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

Execute assim:

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
— Maçaneta da porta
fonte
Não faz diferença na sua pontuação, mas ainda assim não pude resistir a este golfe:fold -5<<<ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE|grep `printf [%s] $@`
— Digital Trauma
2

JavaScript (ES6), 62 bytes

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

53 bytes no Firefox 48 ou anterior:

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

Teria 49 bytes se não fosse o requisito de insensibilidade a esse caso:

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

Mostrar snippet de código

— Neil
fonte
2

Braquilog , 25 bytes

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

Os bytes não contados são a matriz de palavras, incluindo os colchetes.

Explicação

:@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
— Fatalizar
fonte
2

Ruby, 48 42 39 bytes

Agora que está pronto, é muito parecido com a solução Pyth, mas sem %sformatar até o ponto em que é basicamente uma porta direta agora.

Se você produzir apenas o resultado puts, não precisará [0]do final, pois putsele lidará com isso para você.

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

Com casos de teste:

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
— Value Ink
fonte
1

JavaScript (ES6), 71 bytes

w=>l=>w.filter(s=>eval("for(b=1,i=5;i--;)b&=!!~l[i].indexOf(s[i])")[0])

Uso:

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)
— Patrick Roberts
fonte
1

Python, 64 60 57 bytes

Código para criar a lista de palavras wcomo sequência, as palavras são separadas por espaço (os bytes são descontados do comprimento do código da solução):

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"

Solução atual (57 bytes): salvou 3 bytes graças a @RootTwo

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

Esta função usa um tuple(não list!) De exatamente 5 strings que representam as letras possíveis para cada caractere de senha como entrada.

Veja este código em execução no ideone.com

Segunda versão (60 bytes):

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

Esta função usa um tuple(não list!) De exatamente 5 strings que representam as letras possíveis para cada caractere de senha como entrada.

Veja este código em execução no ideone.com

Primeira versão (64 bytes):

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

Esta função aceita qualquer iterável (por exemplo, listou tuple) de exatamente 5 strings que representam as letras possíveis para cada caractere de senha como entrada.

Veja este código em execução no ideone.com

— Byte Commander
fonte
11
Salve três bytes usando este regex:"(?i)\\b"+"[%s]"*5%a
— RootTwo 23/05
Claro, que óbvio "erro" do meu lado ... Obrigado por apontar isso para @RootTwo, editei minha resposta e dei créditos a você.
— Byte Commander
@ByteCommander Não vejo nenhum crédito.
— Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Logo abaixo da w=...linha de código: " A solução real (57 bytes, salvou 3 bytes graças a @RootTwo): "
— Byte Commander
@ByteCommander Talvez eu tenha visualizado uma versão anterior depois de acordar meu PC da hibernação.
— Erik the Outgolfer
0

Hoon , 125 bytes

|=
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 não possui regex, apenas um sistema combinador de analisador. Isso torna bastante complicado fazer tudo funcionar: (mask "abc")traduz-se aproximadamente para regex [abc]e é o núcleo do analisador que estamos construindo.

;~(plug a b)é um vínculo monádico de dois analisadores abaixo ++plug, que deve analisar o primeiro e depois o segundo, caso contrário ele falha.

++kneeé usado para criar um analisador recursivo; fornecemos a ele um tipo ( *tape) do resultado e um retorno de chamada para gerar o analisador real. Nesse caso, o retorno de chamada é "chamar o fechamento inteiro novamente, mas com o final da lista". O ?~teste de runas é que a lista está vazia e fornece (easy ~)(não analise nada e retorne ~) ou acrescente outra maske recue novamente.

Tendo construído o analisador, podemos usá-lo. ++skipremove todos os elementos da lista para os quais a função retorna sim. ++rusttenta analisar o elemento com nossa regra, retornando um unitque é [~ u=result]ou ~(nossa versão do Talvez de Haskell). Se for ~(Nenhum, e a regra falhou ao analisar ou não analisou todo o conteúdo), a função retornará true e o elemento será removido.

O que resta é uma lista, contendo apenas a palavra em que cada letra é uma das opções da lista fornecida. Estou assumindo que a lista de senhas já está no contexto sob o nome 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=<<>>]
— RenderSettings
fonte
0

Python 3, 81 bytes

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

Uma função anônima que recebe entrada de uma lista de seqüências de caracteres x e retorna a senha.

A lista de senhas possíveis lé definida como:

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

Esta é uma força bruta simples; Eu estava interessado em ver quão curto eu poderia conseguir isso sem regexes.

Como funciona

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

Experimente no Ideone

— TheBikingViking
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.