Votre défi est de mot de passe la chaîne! Qu'est-ce que la mot de passe, demandez-vous?

Prenez une chaîne en entrée. Cette chaîne ne contiendra que des lettres majuscules, des lettres minuscules, des chiffres et des espaces.

Vous devez remplacer tous les espaces par des traits de soulignement et déplacer tous les nombres à la fin de la chaîne dans l'ordre dans lequel ils apparaissent de gauche à droite. Ensuite, pour chaque lettre de la chaîne, changez-la au hasard en majuscule ou en minuscule.

Exemples (la casse des caractères doit varier à chaque fois):

Input
Hello world
Output
HElLo_wORld

Input
pa55 w0rd
Output
pA_Wrd550

Input
14 35
Output
_1435

Input
0971
Output
0971

Input
[space]
Output
_

Le code le plus court en octets gagne!

Celui qui demande à Information Security SE si c'est un bon algorithme de hachage gagne! - Ne vous inquiétez pas, suzerains SE, je plaisante.

Pyth, 15 octets

s}D`MTrRO2Xzd\_

Manifestation

s}D`MTrRO2Xzd\_
                   Implicit: z = input(), d = ' '
          Xzd\_    In z, replace ' ' with '_'.
      rR           To each character, apply r-function
        O2         Randomly 0 or 1. r 0 is lowercase, r 1 is uppercase.
 }D                Order the characters based on presence in
   `MT             The strings of the numbers 0 to 9.
s                  Concatenate into a string.

Labyrinthe , 76 octets

 `:_64/"32}
,`    (3  :=-{
"`{"; _v2$  ;`3
"`".:@ ; ".5(`3.
<       "" `^`;>

Une autre collaboration avec @ MartinBüttner et du côté le plus fou du spectre du Labyrinthe - pour la première fois, nous avons tous les quatre ^>v<dans le même programme. Essayez-le en ligne!

Explication

L'algorithme général, qui s'exécute en boucle, est le suivant:

 1.   Read a char
 2.   If EOF:
 3.     Move all digits from auxiliary stack to main
 4.     Output all digits on main stack
 5.     Halt
      Otherwise:
 6.     If char is a letter (c >= 64):
 7.       If random turns left:
 8.         Output char XOR 32
          Otherwise:
 9.         Output char
        Otherwise:
10.       Shift char to auxiliary stack
11.       If char is space (c-32 == 0):
12.         Pull char back from auxiliary stack
13.         Output underscore
          Otherwise:
14.         Continue loop

Pour garder l'explication compacte, voici à peu près comment chaque partie du programme correspond au pseudocode ci-dessus:

Voici les parties intéressantes.

Obtenir l'aléatoire dans le labyrinthe

Il n'y a qu'une seule façon d'obtenir l'aléatoire dans Labyrinth, et c'est quand l'IP essaie d'avancer mais 1) il n'y a ni chemin en avant ni en arrière et 2) il y a des chemins disponibles à gauche et à droite. Dans ce cas, l'IP choisit au hasard entre les routes gauche et droite.

Cela n'est possible qu'en utilisant les ^>v<opérateurs, qui font apparaître net décaler la ligne / colonne nde 1. Par exemple, le programme ( Essayez-le en ligne! )

" 1
""v!@
  2
   !@

renvoie 1 ou 2 de façon aléatoire, car la vcolonne décale de 0 (c'est-à-dire la colonne sur laquelle l'IP est activée) de 1, ce qui donne

"
""1!@
  v
  2!@

L'IP est orienté vers la droite et essaie d'avancer (le haut de la pile est nul) mais ne peut pas. Il ne peut pas non plus reculer, il choisit donc aléatoirement entre gauche ou droite.

Astuces de golf

• Le programme démarre à partir du premier caractère dans l'ordre de lecture, ce que vous remarquerez en fait à l'étape 6. Cependant, le saut à partir d'une pile de labyrinthe vide donne 0, donc les étapes 10 et 14 se produisent, décalant un zéro vers la pile auxiliaire, ce qui est effectivement un no-op.

• La pile principale est effectivement vide après chaque itération, ce qui nous permet de jouer la disposition du code en utilisant >et <sur les zéros implicites en bas. L' >encapsule la ligne du bas de façon à ce que l'IP se déplace du bas à droite vers le bas à gauche, et le <fait reculer la ligne. L'IP se déplace ensuite joyeusement vers le haut de la colonne de gauche pour continuer la boucle.

• Les chiffres dans Labyrinth pop net push 10*n + <digit>. De plus, les caractères sont pris modulo 256 avant d'être sortis. Mettre ces deux ensemble nous permet de sortir 95 (soulignement) en faisant `3332 (espace), ce qui fonctionne parce que -3233 % 256 = 95. Même s'il existe d'autres façons de transformer 32 en 95 ( ;95étant la plus simple), travailler avec un nombre négatif ici nous permet de compacter un peu le code avec des virages à gauche.

05AB1E , 22 21 20 octets

Code:

þ¹žh-s«ð'_:vyždÈiš}?

Utilise le codage CP-1252 .

Essayez-le en ligne!

CJam , 25 octets

lelS'_er{58<}${2mr{eu}&}%

Essayez-le en ligne!

Explication

Traduction de ma réponse MATL.

l                            e# read line as a string
 el                          e# make lowercase
   S'_er                     e# replace spaces by underscores
        {58<}$               e# (stable) sort with key "is digit"
              {        }%    e# map block over the string
               2mr           e# generate 0 or 1 equiprobably
                  {eu}&      e# if it's 1, make uppercase

CJam, 23 octets

lS'_er{60<}${eu_el+mR}%

Testez-le ici.

Explication

l       e# Read input.
S'_er   e# Turn spaces into underscores.
{60<}$  e# Sort (stably) by whether the character is a digit or not. This moves digits
        e# to the end, without changing the relative order within digits or non-digits.
{       e# Map this block over the characters...
  eu    e#   Convert to upper case.
  _el   e#   Make a copy and convert to lower case.
  +     e#   Join them into one string.
  mR    e#   Randomly choose one of the characters. Of course, this entire block is a
        e#   no-op for non-letter characters.
}%

Python, 107 octets

from random import*
lambda s:''.join([choice(c+c.swapcase()),'_'][c<'!']for c in sorted(s,key=str.isdigit))

Une amélioration par rapport aux deux autres réponses Python car:

• [...,'_'][c<'!']est utilisé à la place de s.replace(' ','_'), et
• choice(c+c.swapcase()) est utilisé au lieu de choice([c.upper(),c.lower()])

JavaScript (ES6), 114 101 octets

s=>s.replace(/./g,c=>c>'9'?c[`to${Math.random()<.5?"Low":"Upp"}erCase`]():c>' '?(s+=c,''):'_',s='')+s

47 octets juste pour randomiser la casse d'un caractère ...

Edit: enregistré un énorme 13 octets grâce à @ edc65.

MATL , 27 octets

k32'_'XEt58<2$S"@rEk?Xk]]v!

Essayez-le en ligne!

k         % implicit input. Make lowercase. Non-lettters are not affected
32'_'XE   % replace spaces by underscores
t58<      % duplicate. Create logical index: true for digits, false otherwise
2$S       % sort first string according to second. Sort is stable
"         % for each character in that string
  @       %   push that character
  rEk     %   generate 0 or 1 with 1/2 probability each
  ?       %   if it's a 1
    Xk    %     make uppercase. Non-letters are not affected
  ]       %   end if
]         % end for each
v         % vertically concatenate all stack contents
!         % transpose into a row char array, i.e. a string. Implicit display

Python 3, 128 122 122 118 caractères

from random import*
s=lambda x:''.join(choice(i.upper()+i.lower())for i in sorted(x.replace(' ','_'),key=str.isdigit))

Merci à xnor d'avoir rasé 6 octets.

Perl 6, 77 75 61 octets

{[~] |S:g/' '/_/.comb(/\D/)».&{(.lc,.uc).pick},|.comb(/\d/)}

S///est comme s///sauf qu'il ne modifie pas $_en place

Pyth, 17 octets

smrdO2o}N`UT:zd\_

Essayez-le ici!

Explication

smrdO2o} N`UT: zd \ _ # z = entrée

            : zd \ _ # remplace les espaces par des traits de soulignement
      o # Tri ^ avec fonction de touche (N)
       } N`UT # N dans "0123456789", donne 1 pour les nombres afin qu'ils soient triés vers la droite
 m # mappe chaque caractère d de ^
  rdO2 # Convertit les aléas d en majuscules ou minuscules
s # rejoindre la liste en une seule chaîne

Mathematica, 86 octets

Merci à Sp3000 pour avoir économisé 1 octet.

RandomChoice[{ToLowerCase,Capitalize}]@#/." "->"_"&/@Characters@#~SortBy~{DigitQ}<>""&

Ahhh, le traitement des chaînes Mathematica ... n'est-il pas beau. Il s'agit d'une fonction sans nom qui prend et renvoie une chaîne.

En raison de tout le sucre syntaxique, l'ordre de lecture est un peu drôle:

Characters@#

Divisez la chaîne en caractères, sinon nous ne pourrons vraiment rien faire du tout.

...~SortBy~{DigitQ}

Trie les chiffres jusqu'à la fin. En enveloppant la fonction de test dans une liste, nous rendons le tri stable.

...&/@...

Mappe la fonction de gauche sur chaque caractère de la liste.

RandomChoice[{ToLowerCase,Capitalize}]

Choisit une fonction de changement de casse aléatoire pour le personnage actuel.

...@#...

S'applique au caractère actuel.

.../." "->"_"

Remplace les espaces par des traits de soulignement.

...<>""

Rejoint enfin tous les caractères dans une chaîne.

PowerShell, 113 octets

-join([char[]]$args[0]-replace" ","_"|%{if($_-match"\d"){$d+=$_}else{"'$_'.To$("Low","Upp"|random)er()"|iex}})+$d

PowerShell est synonyme de langage de golf horrible. Divisez en tableau de caractères et remplacez les espaces par des traits de soulignement. Prenez chaque personnage et processus. Collectez les nombres dans la variable $ d pour une sortie ultérieure. Chaque autre caractère est transformé au hasard en majuscules ou en minuscules en appelant une expression à l'aide de 'char'.ToLower()ou 'char'.ToUpper(). Si des chiffres ont été collectés, ajoutez-les à la fin.

Julia, 88 87 78 octets

s->join([c<33?'_':rand([ucfirst,lcfirst])("$c")for c=sort([s...],by=isdigit)])

Il s'agit d'une fonction anonyme qui accepte une chaîne et retourne une chaîne. Pour l'appeler, assignez-le à une variable.

Nous divisons d'abord la chaîne d'entrée en un tableau de ses caractères et trions le tableau selon que chaque caractère est un chiffre. Cela maintient l'ordre dans le texte et les chiffres mais pousse les chiffres jusqu'à la fin. Ensuite, pour chaque caractère du tableau, nous vérifions s'il s'agit d'un espace. Si tel est le cas, remplacez-le par un trait de soulignement, sinon choisissez au hasard l'un des caractères ucfirstou lcfirstà appliquer au caractère, le convertissant ainsi en majuscules ou minuscules, respectivement. Joignez le tableau en une chaîne et nous avons terminé!

Essayez-le ici

9 octets enregistrés grâce au Sp3000!

Perl, 51 48 octets

Comprend +2 pour -lp

Exécutez avec l'entrée sur STDIN:

perl -lp passwordify.pl <<< "Hel1lo wo4rld"

passwordify.pl:

s%\pL%$&^$"x rand 2%eg;$_=y/ 0-9/_/dr.s/\D//gr

Facteur, 154 octets

ou 222 avec importation kernel splitting sequences ascii combinators.random regexp

: f ( x -- y ) R/ \d/ R/ \D/ [ all-matching-subseqs ] bi-curry@ bi [ { [ >upper ] [ >lower ] } call-random ] map [ "" join ] bi@ " " "_" replace prepend ;

Je ne suis pas trop doué pour jouer au golf, et je ne sais pas si j'ai adopté la meilleure approche ici, mais j'ai pensé que j'allais essayer

Rubis, 84 octets

Fonction anonyme. La suppression de l'espace avant c.downcaseprovoque une erreur de syntaxe pour une raison quelconque et je ne sais pas pourquoi.

->s{q="";s.gsub(/./){|c|c=~/\d/?(q+=c;p):c==" "??_:rand<0.5?c.upcase: c.downcase}+q}

Lua, 125 octets

Lorsque l'objet rencontre le fonctionnel, vous pouvez faire de jolies choses, même en lua! Je ne pense pas pouvoir jouer au golf, c'est déjà un énorme gâchis, et je suis déjà heureux de battre la plupart des réponses en python: D.

s=""print((...):gsub("%d",function(d)s=s..d return""end):gsub("%s","_"):gsub("%a",1<math.random(2)and s.upper or s.lower)..s)

Non golfé et explications

s=""                       -- Initialise the string that will contains the digits
print((...)                -- apply the following to the argument then print it
  :gsub("%d",function(d)   -- iterate over the digits
    s=s..d                 -- concatenate them in s
    return""               -- remove them from the arg
   end)
  :gsub("%s","_")          -- replace spaces by underscores
  :gsub("%a",              -- iterate over letters
    1<math.random(2)       -- pick a random integer between 1 and 2
      and s.upper          -- if it is 2, use the function upper() of object s
      or s.lower)          -- else, use the function lower() of object s
  ..s)                     -- concatenate with s

Sérieusement, 25 octets

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ

Essayez-le en ligne!

Explication:

,`'_' (Æ≈"ûù"J£ƒ`M;ì;(-+Σ
,`              `M         map over input:
  '_' (Æ                     replace spaces with underscores
        ≈                    cast to int (does nothing if cast fails)
         "ûù"J£ƒ             randomly upper- or lowercase it (does nothing if not letter)
                  ;ì;(-+   move ints to back
                        Σ  join

IPOS - non concurrent, 14 octets

S'_RE`N-`dE!k?

Oui, j'ai ajouté des buildins pour ce défi, mais ceux-ci ne sont pas spécialement ciblés sur ce problème.

Cela fonctionne avec la version 0.1 de l'interpréteur .

Exemple d'exécution

> python IPOS.py S'_RE`N-`dE! k? -i "pa55 w0rd"
Pa_WrD550

Explication

     # Implicite: placez l'entrée sur la pile (C)
S # Poussez un espace vers la pile (B)
'_ # Poussez un trait de soulignement dans la pile (A)
R # Dans C remplacer B par A -> remplacer les traits de soulignement par des espaces
     # la pile ne contient plus que la chaîne remplacée (C)
E # Appuyez sur une chaîne vide (B)
`# Lancer un littéral de commande,
     # la pile pour cela est initialisée avec un seul caractère (B) plus tard
N # Poussez les chiffres 0-9 sous forme de chaîne vers la pile (A)
- # Supprimez tous les caractères de B qui se trouvent dans A
`# Commande de fin littérale (A)
d # divisez C sur B, triez les pièces en ordre décroissant avec la clé A et rejoignez-les sur B.
     # La fonction clé A transforme chaque caractère de la chaîne en une chaîne vide s'il s'agit d'un chiffre.
     # Puisque le caractère résultant ne contient pas de chiffre, sa valeur clé est sa longueur.
     # Ceci mappe la clé 0 aux chiffres et la clé 1 aux non-chiffres. Tri par ordre décroissant
     # order déplace les chiffres vers la droite et laisse les non-chiffres dans l'ordre où ils étaient auparavant.
E # Poussez une chaîne vide
! k # Appuyez sur la commande k (= swapcase)
? # Appliquer ^ à chaque caractère au hasard
     # Implicite: contenu de la pile de sortie

PHP, 368 octets

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$output AND $numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<strlen($str);$i++){
    in_array($str[$i],$numArray)?($numStr = $numStr.$str[$i]):((rand(10,100)%2==0)?$str[$i] = strtoupper($str[$i]) AND $output = $output.$str[$i]:$output = $output.$str[$i]);
}
echo $output = $output.$numStr;

Code non golfé:

$str = "pa55 w0rd";
$str = str_replace(" ","_",$str);
$len = strlen($str);
$output = "";
$numStr = "";
$numArray = ['0','1','2','3','4','5','6','7','8','9'];
for($i=0;$i<$len;$i++){
  if(in_array($str[$i],$numArray)){
    $numStr = $numStr.$str[$i];
  }else {
      if(rand(10,100)%2==0)
      {
        $str[$i] = strtoupper($str[$i]);
      }
      $output = $output.$str[$i];
  }
}
$output = $output.$numStr;
echo $output;

Python 2, 179 octets

from random import*
f=lambda s,a=[str.upper,str.lower],n='0123456789':''.join(map(lambda x:choice(a)(x),filter(lambda x:x not in n,s).replace(' ','_')))+filter(lambda x:x in n,s)

Il y a probablement beaucoup de place à l'amélioration ici que je développerai plus tard.

AWK, 128 octets

{srand();for(;++i<=split($0,a,"");){s=a[i];if(s!=s+0){o=s==" "?"_":rand()>0.5?tolower(s):toupper(s);A=A o}else{N=N s}}print A N}

Le srand()est nécessaire pour nous donner des nombres aléatoires différents à chaque exécution.
Pour que cela fonctionne correctement avec une entrée multiligne, nous devons mettre quelque chose comme A=N=""avant la forboucle.

Python 3.5 - 118 octets:

from random import*
lambda y:''.join(choice([q.upper(),q.lower()])for q in sorted(y.replace(' ','_'),key=str.isdigit))

Comme vous pouvez le voir, j'utilise essentiellement la choicefonction du module aléatoire pour choisir une fonction aléatoire (soit .upper () ou .lower ()) pour chaque lettre dans la version triée de la chaîne donnée, dans laquelle tous les chiffres vont à la fin. En outre, chaque espace est remplacé par un trait de soulignement dans la chaîne triée.

PHP, 164158 caractères / octets

C'est mieux que l'autre golf PHP , car:

• Il faut des entrées
• C'est plus court

Scénario

<?$a=$b='';foreach(str_split(strtolower($argv[1]))as$c){if($c==' ')$c='_';if(preg_match("/[0-9]/",$c))$a.=$c;else$b.=(rand(0,1)?$c:strtoupper($c));}echo$b.$a;

Exemple

php password.php 'thats some 1337 shit'

ThATs_Some__sHiT1337

> <> , 73 octets

 i:"@")?v:" ")?v0) ?\rl?!;o01!.<
 v8<    8>00.! <o"_"/
8<>x<%*4/^o+*
 ^c<

Rien de fou ici, ça:

• imprime _quand il rencontre 
• prend le mod 32 de lettres, puis ajoute au hasard 8 * 8 ou 12 * 8 avant de les imprimer
• empile le numéro et l'imprime une fois la fin de l'entrée atteinte

Vous pouvez l'essayer ici !

Python 3, 151 octets

import random as r
x=input();s="";n=""
for c in x:
 if c.isdigit():n+=c
 else:s+=c.upper() if r.randint(0,1) else c.lower()
print(s.replace(" ","_")+n)