Au sujet des mots de passe

10

Dans Keep Talking and Nobody Explodes , les joueurs sont chargés de désamorcer les bombes sur la base des informations de leurs "experts" (d'autres personnes avec un manuel). Chaque bombe est composée de modules, dont l'un peut être un mot de passe, où l'expert reçoit cette liste de mots de passe possibles, de cinq lettres:

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

Et le joueur reçoit une liste de 6 lettres possibles pour chaque place dans le mot de passe. Étant donné les combinaisons de lettres possibles, sortez le mot de passe correct. L'entrée peut être dans n'importe quel format raisonnable (tableau 2D, chaîne séparée par un retour à la ligne, etc.) Vous pouvez réduire le code que vous utilisez pour compresser / générer la liste / chaîne / tableau / quel que soit le mot de passe. (Merci @DenkerAffe)

REMARQUE: les mots de passe ne respectent pas la casse. Vous pouvez supposer que la saisie ne résoudra que pour un seul mot de passe.

Exemples / cas de test

L'entrée ici sera représentée comme un tableau de chaînes. 

["FGARTW","LKSIRE","UHRKPA","TGYSTG","LUOTEU"] => first
["ULOIPE","GEYARF","SHRGWE","JEHSDG","EJHDSP"] => large
["SHWYEU","YEUTLS","IHEWRA","HWULER","EUELJD"] => still
code-golf 
— MayorMonty
source
— Rɪᴋᴇʀ
8
Je suggère d'autoriser la liste des mots de passe possibles en entrée du programme. Sinon, cela revient à la langue qui a la meilleure compression de chaînes.
— Denker
5
C'est bien si vous le changez; Cela ne me dérangerait pas (l'essentiel de ma soumission resterait inchangé).
— Poignée de porte
4
Je suis d'accord avec DenkerAffe - avoir les mots de passe possibles donnés en entrée plutôt qu'une liste statique rend le défi beaucoup plus intéressant.
— Mego
5
Cela pourrait simplifier les choses si vous utilisez également la liste de chaînes comme deuxième entrée, car cela indique clairement le nombre d'octets. Je ne savais pas s'il fallait compter le <dans ma solution Bash, par exemple.
— Poignée de porte

Réponses:

6

Pyth, 13 octets

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

Suite de tests.

 #             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
— Poignée de porte
source
Vous avez oublié de mettre à jour votre premier bloc de code: P
— Downgoat
@Downgoat Qu'est-ce que j'ai oublié de mettre à jour? Cela me semble juste.
— Poignée de porte
Bizarre, le premier bloc de code ne semble pas correspondre à l'exemple (il semble que ce soit une ancienne révision?)
— Downgoat
1
— Leaky Nun
6

Bash, 22 octets

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

Courez comme ça:

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
— Poignée de porte
source
Cela ne fait aucune différence pour votre score, mais je n'ai toujours pas pu résister à ce golf:fold -5<<<ABOUTAFTERAGAINBELOWCOULDEVERYFIRSTFOUNDGREATHOUSELARGELEARNNEVEROTHERPLACEPLANTPOINTRIGHTSMALLSOUNDSPELLSTILLSTUDYTHEIRTHERETHESETHINGTHINKTHREEWATERWHEREWHICHWORLDWOULDWRITE|grep `printf [%s] $@`
— Digital Trauma
2

JavaScript (ES6), 62 octets

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

53 octets sur Firefox 48 ou version antérieure:

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

Aurait été de 49 octets sans cette exigence d'insensibilité à la casse:

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

Afficher l'extrait de code

— Neil
source
2

Brachylog , 25 octets

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

Les octets non comptés sont le tableau de mots, y compris les crochets.

Explication

:@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
— Fatalize
source
2

Rubis, 48 42 39 octets

Maintenant que c'est fait, c'est très similaire à la solution Pyth, mais sans %sformatage au point où c'est fondamentalement un port direct maintenant.

Si vous sortez uniquement le résultat avec puts , vous n'avez pas besoin du [0]à la fin car putsvous vous en occuperez.

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

Avec les cas de test:

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
— Encre de valeur
source
1

JavaScript (ES6), 71 octets

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

Usage:

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
source
1

Python, 64 60 57 octets

Code pour créer une liste de mots wsous forme de chaîne, les mots sont séparés par des espaces (les octets sont actualisés de la longueur du code de la solution):

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"

Solution actuelle (57 octets): économisé 3 octets grâce à @RootTwo

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

Cette fonction prend un tuple(non list!) D'exactement 5 chaînes qui représentent les lettres possibles pour chaque caractère de mot de passe en entrée.

Voir ce code en cours d'exécution sur ideone.com

Deuxième version (60 octets):

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

Cette fonction prend un tuple(non list!) D'exactement 5 chaînes qui représentent les lettres possibles pour chaque caractère de mot de passe en entrée.

Voir ce code en cours d'exécution sur ideone.com

Première version (64 octets):

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

Cette fonction prend tout itérable (par exemple listoutuple ) d'exactement 5 chaînes qui représentent les lettres possibles pour chaque caractère de mot de passe en entrée.

Voir ce code en cours d'exécution sur ideone.com

— Byte Commander
source
1
Économisez trois octets en utilisant cette expression "(?i)\\b"+"[%s]"*5%a
— régulière
Bien sûr, quelle "erreur" évidente de mon côté ... Merci d'avoir signalé @RootTwo, j'ai édité ma réponse et je vous ai donné des crédits.
— Byte Commander
@ByteCommander Je ne vois aucun crédit du tout.
— Erik the Outgolfer
@ ΈρικΚωνσταντόπουλος Juste en dessous de la w=...ligne de code: " La solution actuelle (57 octets, économisés 3 octets grâce à @RootTwo): "
— Byte Commander
@ByteCommander J'ai peut-être prévisualisé une version antérieure après avoir réveillé mon ordinateur de l'hibernation.
— Erik the Outgolfer
0

Hoon , 125 octets

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

Non golfé:

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

Hoon n'a pas d'expression régulière, seulement un système de combinateur d'analyseur. Cela rend assez compliqué de tout faire fonctionner: (mask "abc")se traduit en gros par des regex [abc], et est le cœur de l'analyseur que nous construisons.

;~(plug a b) est une liaison monadique de deux analyseurs sous ++plug , qui doit analyser le premier puis le deuxième, sinon il échoue.

++kneeest utilisé pour construire un analyseur récursif; nous lui donnons un type ( *tape) du résultat, et un rappel à appeler pour générer l'analyseur réel. Dans ce cas, le rappel est "appeler à nouveau la fermeture entière, mais avec la queue de la liste". La ?~rune teste la liste est vide et donne (easy ~)(ne pas analyser quoi que ce soit et retourner ~) ou ajoute une autremask et recurse à nouveau.

Une fois l'analyseur construit, nous pouvons l'utiliser. ++skipsupprime tous les éléments de la liste pour lesquels la fonction renvoie oui pour. ++rustessaie d'analyser l'élément avec notre règle, renvoyant un unitqui est soit [~ u=result]ou ~(notre version de Peut-être de Haskell). Si c'est~ (Aucun, et que la règle n'a pas réussi à analyser ou n'a pas analysé l'intégralité du contenu), la fonction renvoie true et l'élément est supprimé.

Ce qui reste est une liste, contenant uniquement le mot où chaque lettre est l'une des options de la liste donnée. Je suppose que la liste des mots de passe est déjà dans le contexte sous le nom 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
source
0

Python 3, 81 octets

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

Une fonction anonyme qui prend l'entrée d'une liste de chaînes xet renvoie le mot de passe.

La liste des mots de passe possibles lest définie comme suit:

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

Il s'agit d'une simple force brute; J'étais intéressé de voir combien de temps je pouvais obtenir cela sans regex.

Comment ça fonctionne

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

Essayez-le sur Ideone

— TheBikingViking
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.