La tua sfida è di passwordificare la stringa! Cosa si sta chiedendo la password, chiedi?

Prendi una stringa come input. Questa stringa conterrà solo lettere maiuscole, lettere minuscole, cifre e spazi.

È necessario sostituire tutti gli spazi con caratteri di sottolineatura e spostare tutti i numeri alla fine della stringa nell'ordine in cui appaiono da sinistra a destra. Quindi, per ogni lettera nella stringa, cambiarla in modo casuale in maiuscolo o minuscolo.

Esempi (il caso dei caratteri dovrebbe variare ogni volta):

Input
Hello world
Output
HElLo_wORld

Input
pa55 w0rd
Output
pA_Wrd550

Input
14 35
Output
_1435

Input
0971
Output
0971

Input
[space]
Output
_

Vince il codice più corto in byte!

Chiunque chieda a Information Security SE se questo è un buon algoritmo di hashing vince! - Non preoccuparti dei signori SE, sto solo scherzando.

Pyth, 15 byte

s}D`MTrRO2Xzd\_

Dimostrazione

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.

Labyrinth , 76 byte

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

Un'altra collaborazione con @ MartinBüttner e sul lato più folle dello spettro Labyrinth - per la prima volta abbiamo tutti e quattro ^>v<in un unico programma. Provalo online!

Spiegazione

L'algoritmo generale, che viene eseguito in un ciclo, è il seguente:

 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

Per mantenere la spiegazione compatta, ecco approssimativamente come ogni parte del programma corrisponde allo pseudocodice sopra:

Ecco le parti interessanti.

Ottenere casualità in Labyrinth

C'è solo un modo per ottenere casualità in Labyrinth, ed è quando l'IP cerca di andare avanti ma 1) non c'è né un percorso in avanti né indietro e 2) ci sono percorsi disponibili a destra e a sinistra. In questo caso, l'IP sceglie casualmente tra le rotte sinistra e destra.

Questo è possibile solo usando gli ^>v<operatori, che pop ne spostano la riga / colonna ndi 1. Per esempio, il programma ( Provalo online! )

" 1
""v!@
  2
   !@

genera 1 o 2 in modo casuale, poiché vsposta la colonna con offset 0 (ovvero la colonna su cui si trova l'IP) di 1, ottenendo

"
""1!@
  v
  2!@

L'IP è rivolto a destra e cerca di andare avanti (la parte superiore dello stack è zero) ma non ci riesce. Inoltre, non può spostarsi all'indietro, quindi sceglie casualmente tra sinistra o destra.

Trucchi da golf

• Il programma inizia dal primo carattere in ordine di lettura, che noterai in realtà è il passaggio 6. Tuttavia, spuntare da uno stack Labyrinth vuoto produce 0, quindi si verificano i passaggi 10 e 14, spostando uno zero nello stack ausiliario, che è effettivamente un no-op.

• Lo stack principale è effettivamente vuoto dopo ogni iterazione, il che ci consente di giocare a golf con il layout del codice usando >e <sugli zero impliciti in basso. Il >avvolge la riga in basso intorno in modo che le mosse IP dal basso a destra in basso a sinistra, e gli <spostamenti sul retro fila. L'IP si sposta quindi felicemente verso l'alto nella colonna di sinistra per continuare il ciclo.

• Le cifre in Labyrinth pop ne push 10*n + <digit>. Inoltre, i caratteri sono presi modulo 256 prima di essere emessi. Mettere insieme questi due ci permette di produrre 95 (trattino basso) facendo `3332 (spazio), che funziona perché -3233 % 256 = 95. Anche se ci sono altri modi per trasformare 32 in 95 ( ;95essendo il più semplice), lavorare con un numero negativo qui ci consente di compattare un po 'il codice con le svolte a sinistra.

05AB1E , 22 21 20 byte

Codice:

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

Utilizza la codifica CP-1252 .

Provalo online!

CJam , 25 byte

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

Provalo online!

Spiegazione

Traduzione della mia risposta 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 byte

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

Provalo qui.

Spiegazione

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 byte

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

Un miglioramento rispetto alle altre due risposte di Python perché:

• [...,'_'][c<'!']viene utilizzato al posto di s.replace(' ','_')e
• choice(c+c.swapcase()) viene utilizzato al posto di choice([c.upper(),c.lower()])

JavaScript (ES6), 114 101 byte

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

47 byte solo per randomizzare il caso di un personaggio ...

Modifica: salvato ben 13 byte grazie a @ edc65.

MATL , 27 byte

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

Provalo online!

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 118 caratteri

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

Grazie a xnor per la rasatura di 6 byte.

Perl 6, 77 75 61 byte

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

S///è come s///se non si modificasse $_sul posto

Pyth, 17 byte

smrdO2o}N`UT:zd\_

Provalo qui!

Spiegazione

smrdO2o} N`UT: zd \ _ # z = input

            : zd \ _ # sostituisce gli spazi con caratteri di sottolineatura
      o # Ordina ^ con la funzione chiave (N)
       } N`UT # N in "0123456789", fornisce 1 per i numeri in modo che vengano ordinati a destra
 m # mappa ogni carattere d di ^
  rdO2 # Converte d randoms in maiuscolo o minuscolo
s # elenco di join in una stringa

Mathematica, 86 byte

Grazie a Sp3000 per il salvataggio di 1 byte.

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

Ahhh, l'elaborazione delle stringhe Mathematica ... non è adorabile. Questa è una funzione senza nome che accetta e restituisce una stringa.

A causa di tutto lo zucchero sintattico, l'ordine di lettura è un po 'divertente:

Characters@#

Dividi la stringa in caratteri, altrimenti non possiamo davvero farci nulla.

...~SortBy~{DigitQ}

Ordina le cifre fino alla fine. Avvolgendo la funzione di test in un elenco, rendiamo stabile l'ordinamento.

...&/@...

Mappa la funzione della mano sinistra su ogni carattere nell'elenco.

RandomChoice[{ToLowerCase,Capitalize}]

Scegli una funzione di cambio maiuscolo / minuscolo casuale per il personaggio corrente.

...@#...

Lo applica al personaggio attuale.

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

Sostituisce gli spazi con caratteri di sottolineatura.

...<>""

Alla fine unisce nuovamente tutti i personaggi in una stringa.

PowerShell, 113 byte

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

PowerShell sta per orribile linguaggio del golf. Dividi in array di caratteri e sostituisci gli spazi con caratteri di sottolineatura. Prendi ogni personaggio e processo. Raccogliere i numeri nella variabile $ d per l'output successivo. Ogni altro carattere viene casualmente trasformato in maiuscolo o minuscolo invocando un'espressione usando 'char'.ToLower()o 'char'.ToUpper(). Se sono state raccolte delle cifre, allegarle alla fine.

Julia, 88 87 78 byte

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

Questa è una funzione anonima che accetta una stringa e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Per prima cosa spezziamo la stringa di input in una matrice dei suoi caratteri e ordiniamo la matrice a seconda che ogni carattere sia una cifra. Ciò mantiene l'ordine nel testo e nelle cifre ma spinge le cifre fino alla fine. Quindi, per ogni personaggio dell'array, controlliamo se si tratta di uno spazio. In tal caso, sostituiscilo con un carattere di sottolineatura, altrimenti scegli casualmente uno ucfirsto lcfirstda applicare al personaggio, convertendolo in maiuscolo o minuscolo, rispettivamente. Unisci l'array in una stringa e il gioco è fatto!

Provalo qui

Risparmiato 9 byte grazie a Sp3000!

Perl, 51 48 byte

Include +2 per -lp

Esegui con l'input su STDIN:

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

passwordify.pl:

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

Fattore, 154 byte

o 222 con importazione 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 ;

Non sono troppo bravo a giocare a golf in fattore, e non sono sicuro di aver adottato l'approccio migliore qui, ma ho pensato di provarlo

Rubino, 84 byte

Funzione anonima. La rimozione dello spazio prima c.downcasecausa un errore di sintassi per qualche motivo e non sono sicuro del perché.

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

Lua, 125 byte

Quando l'oggetto incontra funzionale, puoi fare delle cose carine, anche in lua! Non credo di poter giocare a golf, è già un gran casino e sono già felice di battere la maggior parte delle risposte di 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)

Ungolfed e spiegazioni

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

Scherzi a parte, 25 byte

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

Provalo online!

Spiegazione:

,`'_' (Æ≈"ûù"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 concorrenziale, 14 byte

S'_RE`N-`dE!k?

Sì, ho aggiunto i builtin per questa sfida, ma quelli non sono particolarmente mirati a questo problema.

Funziona con la versione 0.1 dell'interprete .

Esempio di esecuzione

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

Spiegazione

     # Implicito: posiziona l'input nello stack (C)
S # Sposta uno spazio nello stack (B)
'_ # Inserisci un carattere di sottolineatura nello stack (A)
R # In C sostituisci B con A -> sostituisci i trattini bassi con gli spazi
     # lo stack contiene ora solo la stringa sostituita (C)
E # Spingere una stringa vuota (B)
`# Avvia un comando letterale,
     # lo stack per questo viene inizializzato con un singolo carattere (B) in seguito
N # Spingi le cifre 0-9 come stringa nello stack (A)
- # Rimuovi ogni carattere da B che si trova in A
`# Termina comando letterale (A)
d # dividere C su B, ordinare le parti in ordine decrescente con il tasto A e ricollegare su B.
     # La funzione chiave A trasforma ogni carattere della stringa in una stringa vuota se si tratta di una cifra.
     # Poiché il carattere risultante non contiene una cifra, il suo valore chiave è la lunghezza.
     # Questo associa il tasto 0 alle cifre e il tasto 1 alle non cifre. Ordinamento in ordine decrescente
     L'ordine # sposta le cifre verso destra e lascia le cifre non numeriche nell'ordine precedente.
E # Spingere una stringa vuota
! k # Premi il comando k (= swapcase)
? # Applica ^ a ogni personaggio in modo casuale
     # Implicito: contenuto dello stack di output

PHP, 368 byte

$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;

Codice Ungolfed:

$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 byte

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)

Probabilmente qui c'è molto margine di miglioramento che elaborerò in seguito.

AWK, 128 byte

{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}

Il srand()che serve per darci diversi numeri casuali ogni volta che viene eseguito.
Perché questo funzioni correttamente con l'input multilinea, dovremmo mettere qualcosa come A=N=""prima del forloop.

Python 3.5 - 118 byte:

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

Come puoi vedere, sto fondamentalmente usando la choicefunzione del modulo casuale per scegliere una funzione casuale (.upper () o .lower ()) per ogni lettera nella versione ordinata della stringa fornita, in cui tutte le cifre vanno al fine. Inoltre, ogni spazio viene sostituito con un trattino basso nella stringa ordinata.

PHP, 164 158 caratteri / byte

Questo è meglio dell'altro golf PHP , perché:

• Ci vogliono input
• È più corto

copione

<?$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;

Esempio

php password.php 'thats some 1337 shit'

ThATs_Some__sHiT1337

> <> , 73 byte

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

Niente di pazzo qui:

• stampa _quando incontra 
• prende il mod 32 di lettere, quindi aggiunge casualmente 8 * 8 o 12 * 8 prima di stamparle
• impila il numero e li stampa una volta raggiunta la fine dell'input

Puoi provarlo qui !

Python 3, 151 byte

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)