introduction

Apparemment, cette question a été posée ici et elle a malheureusement été fermée. Je pensais que c'était une bonne idée d'essayer à nouveau, mais j'ai bien fait.

XKCD examine la manière dont nous sommes formés pour utiliser des mots de passe difficiles à retenir. Il pense que c'est sécurisé, mais prendrait 3 jours pour craquer un ordinateur. D'un autre côté, se souvenir de 4 ou 5 mots apporte l'intropie du mot de passe de Kuan et est facile à retenir. C'est fou comment ça marche, hein?

Défi

Le travail actuel consiste à créer 5 mots de passe en utilisant des mots. 4 mots par mot de passe et un minimum de 4 lettres par mot, mais pas de maximum. L'intropie du mot de passe de Kuan devra être calculée pour chaque mot de passe, mais aucun minimum forcé ne sera défini.

Qu'est-ce que l'intropie du mot de passe de Kuan?

L'intropie de mots de passe de Kuan est une mesure de l'imprévisibilité d'un mot de passe, selon Kuan. Il y a un calcul simple: E = log ₂ (R) * L . E étant l'intropie du mot de passe de Kuan, R étant la plage de caractères disponibles et L la longueur du mot de passe.

La gamme de caractères disponibles est explicite. C'est la gamme de caractères qu'un mot de passe peut avoir, en l'occurrence les majuscules et les minuscules. Comme il y a 26 caractères dans l'alphabet, 26 x 2 = 52 caractères dans toute la plage du mot de passe.

La longueur du mot de passe est également explicite. C'est la longueur totale du mot de passe après la création.

Contraintes

• Pas d'entrée.
• Un mot ne peut pas réapparaître dans le même mot de passe.
• Aucun symbole ou nombre autorisé dans un mot de passe.
• 4 mots par mot de passe, mais un minimum forcé de 4 lettres par mot.
• Pas d'espaces entre les mots.
• Vous ne pouvez pas générer le même mot de passe encore et encore.
• Chaque mot doit être mis en majuscule dans un mot de passe.
• La sortie doit être lisible par l'homme et doit être espacée. Doit également inclure l'intropie du mot de passe de Kuan du mot de passe en utilisant l'équation de l'intropie du mot de passe de Kuan ci-dessus.
• Dictionnaire . Vous devez l’utiliser, le télécharger en tant que fichier texte et l’intégrer en conséquence. Ce sera la liste à partir de laquelle vous récupérerez des mots. Votre code devrait supposer qu'il est disponible.
• C'est le code-golf , la plus courte victoire d'octets.

Sortie

TriedScarProgressPopulation 153.9
TryingPastOnesPutting 119.7
YearnGasesDeerGiven 108.3
DoubtFeetSomebodyCreature 142.5
LiquidSureDreamCatch 114.0

Python 2, 102 101 97 91 octets

from random import*
exec"x=''.join(x.title()for x in sample(f,4));print(x,57*len(x)/10);"*5

Suppose que le dictionnaire est une liste nommée f.

Peut être testé en enregistrant le fichier sous dict.txtet en appelant

f = open('dict.txt').readlines()

PowerShell (3.0+), 77 octets

1..5|%{($p=-join($d|random -c 4|%{culture|% te*|% tot* $_}));57*$p.Length/10}

Essayez-le en ligne!

En utilisant le truc de Jonathan Allan57*len/10 .

$dcontient le dictionnaire sous forme de tableau de mots. Si vous jouez à la maison et que vous voulez combler $d:

$d=-split(irm pastebin.com/raw/eMRSQ4u2)

Utiliser une version golfée de (Get-Culture).TextInfo.ToTitleCase()pour capitaliser la première lettre; Je ne pense pas qu'il y ait un moyen plus court de faire cela dans PowerShell.

Le reste est assez simple, je pense.

Le lien TIO contient l’ensemble du dictionnaire; désactivez le cache et allez fou!

Gelée , 22 octets

Ẋḣ4ŒtFµL×57÷⁵⁸,K
çЀ5Y

Un lien monadique prenant une liste de caractères, le dictionnaire analysé (comme autorisé dans le chat ).

Essayez-le en ligne! (Cliquez sur "Arguments" pour masquer le dictionnaire et réduire le besoin de défilement.)

Comment?

Comme le dictionnaire ne contient que des mots valides ( 4caractères ou plus, uniquement [a-z]), il n’est pas nécessaire de vérifier cette condition.

Étant donné que tous les mots du dictionnaire ont une longueur, [4-8]les longueurs de mot de passe possibles sont [16,32]comprises et les entropies possibles ne seront jamais arrondies différemment à une décimale supérieure à celle du remplacement log(52,2)par 5.7. Le seul problème est que l' utilisation d' une valeur en virgule flottante 5.7donnera des erreurs d' arrondi en virgule flottante pour les longueurs 18, 26et 31. Cependant, multiplier par 57, puis diviser par 10utiliser ×57÷⁵permet d'éviter ce problème (tout en restant un octet plus court que l'impression de la valeur de précision de virgule flottante complète ×52l2¤).

çЀ5Y - Main link: list of list of characters (the parsed dictionary)
   5  - literal 5
 Ѐ   - map across the implicit range [1,2,3,4,5]:
ç     -   last link (1) as a dyad
    Y - join with newlines
      - implicit print

Ẋḣ4ŒtFµL×57÷⁵⁸,K - Link 1, get password and entropy: list of lists of characters, number
Ẋ                - shuffle the list of lists (shuffle all the words)
 ḣ4              - head to 4 (the first four words)
   Œt            - title case (make the first letter of each uppercase)
     F           - flatten into one list of characters
      µ          - monadic chain separation, call that p
       L         - length of p
         57      - 57
        ×        - multiply
            ⁵    - 10
           ÷     - divide -> entropy to 1 decimal place
             ⁸   - link's left argument, p
              ,  - pair -> [p, entropy]
               K - join with (a) space(s)

Ruby, 89 83 octets

d.select!{|w|w[3]}
5.times{p w=d.sample(4).map(&:capitalize)*'',5.700439718*w.size}

Suppose que les mots de passe sont stockés dans la variable d. Vous pouvez ajouter cette ligne avant le code:

d=$<.map(&:chomp)

et appelez le script par exemple comme ceci:

$ ruby generate_passwords.rb < dictionary_file.txt

Exemple de sortie:

"MarginStarvedOnusInsulted"
142.51099295
"KitchenMiseryLurkJoints"
131.110113514
"InducesNotablePitfallsPrecede"
165.312751822
"FarmersAbortFutileWrapper"
142.51099295
"RoutesBishopGlowFaithful"
136.81055323200002

KitchenMiseryLurkJoints ... wow.

-6 octets de Ajedi32

Mathematica, 178 octets

t=1;l=Length;While[t<6,s=RandomChoice[Import["https://pastebin.com/raw/eMRSQ4u2"],4];c=Capitalize/@s;f=Flatten@Characters[c];Print[StringJoin[c]," ",Log[2,l@Union@f]*l@f//N];t++]

Essayez-le en ligne

copier et coller en utilisant ctrl-v et appuyer sur Maj + Entrée pour exécuter

Mathematica, 136 octets

en supposant que m est le dictionnaire, le code est

m=ImportString[Import["C:\a.txt"]]

.

t=1;l=Length;While[t<6,s=RandomChoice[m,4];c=Capitalize/@s;f=Flatten@Characters[c];Print[StringJoin[c]," ",Log[2,l@Union@f]*l@f//N];t++]

Bash ,66 65 octets

for w in `shuf -n4 -`;{((l+=${#w}));printf ${w^};};bc<<<$l*5.7004

Essayez-le en ligne!

Le dictionnaire est recived par STDIN. Mélange tous les mots du dictionnaire et affiche les premiers 4.

Pour chaque mot, additionne sa longueur dans la variable et rappelle le mot en majuscule. En fin de compte, appelle BC pour faire le calcul.

Solution Awk, 112 octets, quatre mots de passe:

shuf -n16 -|xargs -n4|awk '{for(i=1;i<5;i++)printf toupper(substr($i,1,1))substr($i,2);print(length($0)-3)*5.7}'

(Ceci est une adaptation de la réponse des martistes, mais je n'ai pas le représentant à commenter)

Python, 88 86 octets

g={*f}
exec('x="".join(g.pop().title()for i in "a"*4);print(x,len(x)*5.700439718);'*5)

En exploitant le caractère setnon déterministe, vous évitez d'importer des bibliothèques aléatoires.

Japt , 30 octets

5Ç[V=Uö4 ®g u +Zt1ìMm52 *Vl]¸

Essayez-le en ligne!

JavaScript (ES6), 164 octets

d=>{for(i=5;i--;)console.log(p="....".replace(/./g,_=>(w=d.splice(Math.random()*d.length|0,1)[0])[0].toUpperCase()+w.slice(1)),(Math.log2(52)*p.length).toFixed(1))}

Suppose que le dictionnaire est passé à la fonction en tant que tableau.

Test Snippet

Mathematica, 71 octets

En supposant que le dictionnaire est déjà chargé dans un tableau appelé d.

Table[{#,Log[2,52]StringLength[#]}&[""<>Capitalize@d~RandomSample~4],5]

Explication:

                                        Capitalize@d                    - Capitalize all the dictionary
                                                    ~RandomSample~4     - make an array with 4 values. By default values can not repeat.
                                    ""<>                                - Concatenate with empty string to turn array into single string.
      {#,Log[2,52]StringLength[#]}&[                               ]    - Put current string next to log(2,52) times length of current string
Table[                                                              ,5] - Repeat this 5 times.

ColdFusion 216 octets

p={};z=arrayLen(c);for(x=0;x<5;x++){pw="";r={};while(structCount(r)<4){n=RandRange(1,z);r.append({"#c[n]#":true});}for(w in structKeyList(r)){pw&=REReplace(w,"\b(\w)","\u\1","All");};p.append({"#pw#":57*len(pw)/10})}

Cela fonctionne dans ColdFusion 11+ et Lucee 4.5+

Pour l'exécuter: https://trycf.com/gist/ff14e2b27d66f28ff69ab90365361b12/acf11?theme=monokai

Le lien TryCF a moins de golf, mais le même code.

Je ne m'attendais pas vraiment à avoir une réponse compétitive au golf; Je voulais juste voir ce qu'il faudrait faire pour relever ce défi dans ColdFusion. Surtout qu'il n'y a pas beaucoup de FC dans ces réponses. :-) Après l'installation, c'était étonnamment plus court que prévu.

Ma première tentative a été un peu plus courte jusqu'à ce que je me souvienne que le même mot ne peut pas être utilisé plus d'une fois. Même s'il est très improbable que le randomiseur sélectionne le même index plusieurs fois, je dépose les index dans les clés d'une structure, ce qui évite les doublons. Ensuite, j'utilise cette liste de clés pour construire ma chaîne de mot de passe finale. J'ai aussi utilisé le truc mathématique pour trouver l'entropie.

PHP , 136 129 octets

-7 octets, merci Jörg

for(shuffle($a);$i++<5;){for($s='',$c=0;$c<4;)strlen($w=$a[$k++])<4?:$s.=ucfirst($w).!++$c;echo$s.' '.log(52, 2)*strlen($s)."
";}

Essayez-le en ligne!

Python 3, 252 octets

C’est mon tout premier défi de golf de code que j’ai fait! Je sais qu'il existe d'autres réponses Python ici (qui sont probablement meilleures que les miennes), mais cela avait l'air amusant, et je voulais donc l'essayer de toute façon. Voici la version golfée:

import random, math
with open("d") as f: d=f.read()
l=d.split()
for a in range(5):
 u=[]
 p=""
 for b in range(4):
  w=random.choice([w for w in l if not w in u and len(w)>=4])
  u.append(w)
  w=w.title()
  p+=w
 print("%s %s"%(p,math.log2(52)*len(p)))

Je posterais un Essayez-le en ligne! lien, mais cela ne supporte pas plusieurs fichiers. Alors, voici un lien de repl.it: https://repl.it/InIl/0

En outre, voici la version sans golf:

import random
import math
with open("d") as f:
    dictionary = f.read() #this is the dictionary text file, simply saved as "d" as to use as few bytes as possible
words = dictionary.split() #here we turn that dictionary string into a list
for a in range(5): #here we iterate through 5 passwords
    used_words = []
    password = ""
    for b in range(4): #here we iterate through the 4 words in each password
        word = ""
        word = random.choice([word for word in words if not word in used_words and len(word) >= 4]) #Thanks to blackadder1337 from #python on freenode IRC for helping me with this.
        used_words.append(word)
        word = word.title()
        password = password + word
    print("%s %s"%(password, math.log2(52) * len(password)))

Comme je l’ai dit, c’est ma première fois dans le code gofling, alors je suis sûr que cela pourrait être beaucoup amélioré.

tcl, 137

Pas un gagnant à coup sûr, mais je pense que ça peut être un peu plus joué au golf.

time {set p "";time {set p [string totitle [lindex $d [expr int(rand()*[llength $d])]]]$p} 4;puts $p\ [expr 5.7004*[string length $p]]} 5

demo - Le but de la ligne 1 est seulement de mettre le contenu du dictionnaire dans la variabled

Vim, 87 frappes

qq:r!echo "$RANDOM"l<CR>D:w o|e w<CR>@"ev4bd:w|bp<CR>p0~wX~wX~wX~Y:.!wc -c<CR>A*5.7003<Esc>:.!bc<CR>PJq4@q

Suppose que le dictionnaire est dans un fichier nommé w. Utilisera toujours 4 mots consécutifs

Explication:

qq                       Start recording a macro named 'q'
:r!echo "$RANDOM"l<CR>   Append the result of the shell command `echo "$RANDOM"l`
D                        Delete what you just appended
:w o|                    Save the buffer to the file 'o' and ..
e w<CR>                  Open the file 'w'
@"                       Execute the text we deleted as a normal-mode command
                         This will move the cursor a random number of characters
                         to the right
e                        Go to the end of the next word
v4bd                     Delete 4 words backwards
:w|                      Save the file and ..
bp<CR>                   Open the last buffer (the 'o' file)
p                        Paste the 4 words we deleted
0                        Move the cursor to the beginning of the line
~wX~wX~wX~               Remove the spaces between the words and capitalize
Y                        Copy current line
:.!wc -c<CR>             Pipe the current line through 'wc -c'
A*5.7003<Esc>            Append "*5.7003" to the end of the line
:.!bc<CR>                Pipe the current line through 'bc'
P                        Paste the password above the current line
J                        Join with line bellow
q                        Stop recording the 'q' macro
4@q                      Run the 'q' macro 4 times

q / kdb +, 76 74 65 56 octets

Solution:

{(x;5.70044*(#)x)}(,/)@[;0;upper]each -4?" "vs(*)(0:)`:w

Exemple:

q){(x;5.70044*(#)x)}(,/)@[;0;upper]each -4?" "vs(*)(0:)`:w
"RulingOverheadSaddensPriest"
153.9119

Explication:

Lire dans la liste de mots, se séparer de "", choisir 4 mots au hasard dans cette liste, mettre la première lettre en majuscule de chaque mot, puis se joindre. Introduisez ceci dans une fonction lambda qui renvoie le mot de passe et l’entropie calculée:

                                                     `:w / the wordlist is a file called 'w'
                                                 (0:)    / read in the file list (\n separated list)
                                              (*)        / take first (and only) item in the list
                                         " "vs           / split this on " "
                                      -4?                / take 4 random items from this list, neg means 'dont put back'
                      @[; ;     ]                        / apply a function to variable at indices (variable is implicit)
                           upper                         / uppercase (the function being applied)
                         0                               / index 0, the first character
                                 each                    / each of the 4 random items
                  (,/)                                   / 'raze' (flatten lists)
{                }                                       / anonymous lambda function
 (x;            )                                        / a 2-item list, x is first item
            (#)x                                         / count x, return the length of the list
    5.70044*                                             / multiply by 5.70044

Remarques:

J'ai cédé et utilisé 5.70044 au lieu de 2 xlog 52 xexp...