Aiuto! Ho appena effettuato l'accesso a Stack Exchange, ma ho dimenticato quale sia la mia password! Ho bisogno di un modo per risolverlo prima di disconnettermi.

Fortunatamente, sono un eccellente hacker. Non solo sono riuscito a trovare l'hash della mia password, ma ho anche trovato l'algoritmo di hashing di Stack Exchange! Prende il valore ASCII di ogni cifra moltiplicato per la posizione di quella cifra, quindi somma tutti questi valori insieme. Per esempio:

"135" -> 1*49 + 2*51 + 3*53 = 310

Ricordo che la mia password è lunga 3 cifre e che ogni carattere ha un numero compreso tra 0 e 5 inclusi (in modo che corrisponda alla regex:) ^[0-5]{3}$, ma sono ancora troppe possibilità da indovinare. Ho bisogno di un programma in grado di convertire un hash in potenziali password, ma nonostante sia un hacker esperto, non posso programmare per salvarmi la vita! Sono stato in grado di scrivere questi test a mano però:

input -> output
288   -> 000                      // lowest possible hash
290   -> 200, 010
298   -> 022, 050, 103, 131, 212, 240, 321, 402, 430, 511   
318   -> 555                      // highest possible hash

Uno di voi può scrivere un programma per me che prenderà un hash e stamperà tutte le possibili password che avrei potuto usare?

L'input sarà sempre in grado di produrre almeno una password valida. È consentito qualsiasi formato di output, purché le stringhe possano essere chiaramente identificate. Inoltre non sono preoccupato per gli zero iniziali, quindi se una potenziale password è 001, accetterò anche 01o 1.

Ti prego, aiutami a essere bloccato fuori dallo scambio di stack!

punteggio

Questo è code-golf , quindi vince la risposta più breve in ogni lingua!

05AB1E , 9 byte

5Ý3ãʒÇƶOQ

Provalo online!

Restituisce un elenco di elenchi di cifre.

C , 113 108 byte

f(int h){int i=47,j,k;while(++i<54)for(j=47;++j<54)for(k=47;++k<54;)if(h==i+j+j+k*3)printf("%c%c%c",i,j,k);}

È unico per vedere cosa si intende per output, l'output è nel formato: 200010

Tutte le password sono scritte a 3 cifre senza delimitatore.

Gelatina , 16 byte

Ṿ€Oæ.J
6Ḷṗ3Ç⁼¥Ðf

Un collegamento monadico che restituisce un elenco di elenchi di cifre.

Provalo online!

Come?

Ṿ€Oæ.J - Link 1, hash: list of integers (the digits of a password)
Ṿ€     - unevaluate €ach (giving a list of characters)
  O    - cast to ordinals (Ṿ€O could actually be replaced with +48 too)
     J - range of length (i.e. [1,2,3] in all use-cases)
   æ.  - dot product

6Ḷṗ3Ç⁼¥Ðf - Main link: number, n
6Ḷ        - lowered range of 6 = [0,1,2,3,4,5]
  ṗ3      - Cartesian power with 3 = [[0,0,0],[0,0,1],...,[5,5,5]] (all passwords)
       Ðf - filter keep if:
      ¥   -   last two links as a dyad (right implicitly n):
    Ç     -     call last link (1) as a monad
     ⁼    -     equals right?

Python 2 , 126 75 byte

-2 grazie a @ArnoldPalmer

lambda h:[(P/36,P%36/6,P%6)for P in range(216)if P/36+P%36/6*2+P%6*3==h&31]

Provalo online!

MATL , 20 byte

'0':'5'3Z^t3:*!si=Y)

Provalo online!

Spiegazione

'0':'5'   % Push inclusive range from '0' to '5', that is, '012345'
3Z^       % Cartesian power with exponent 3. Each Cartesian tuple is a row
t         % Duplicate
3:        % Push [1 2 3]
*         % Multiply element-wise with broadcast
!s        % Sum of each row
i         % Input number
=         % Logical mask of values that equal the input
Y)        % Use as logical index into the rows of the matrix. Implicit display

Python 2 , 81 byte

lambda h:[(a,b,c)for a in r for b in r for c in r if a+2*b+3*c+288==h]
r=range(6)

Provalo online!

Haskell, 71 70 64 61 byte

l=[0..5]
f p=[show=<<[a,b,c]|a<-l,b<-l,c<-l,p-288==a+2*b+3*c]

Provalo online!

C # (.NET Core) , 133 131 125 123 byte

n=>{int i,j,k;for(i=48;i<54;++i)for(j=48;j<54;++j)for(k=48;k<54;++k)if(i+j*2+k*3==n)Console.Write($"{i%48}{j%48}{k%48},");}

Provalo online!

Carbone , 33 byte

Ｆ⁶Ｆ⁶Ｆ⁶¿⁼⁺℅Ｉι⁺×℅Ｉκ²×℅Ｉλ³Ｉθ«ＩιＩκＩλ⸿

Provalo online!

Un approccio simile ad altre risposte: esegui il loop tre volte da 0 a 5, calcola l'hash e stampa lo stato delle variabili di iterazione se coincide con l'hash di input.

Link alla versione dettagliata .

CJam , 26 25 byte

-1 byte grazie a Challenger5

{:H;6Zm*{s:i3,:).*:+H=},}

Blocco anonimo in attesa dell'hash nello stack (come numero intero) e lascia il risultato nello stack (come elenco di stringhe).

Provalo online!

Spiegazione

:H;    e# Store the hash in H.
6Zm*   e# 3rd Cartesian power of [0 1 2 3 4 5].
{      e# For each tuple in the power:
 s     e#  Stringify the tuple.
 :i    e#  Get the code point of each digit.
 3,:)  e#  Push [1 2 3].
 .*    e#  Element-wise multiplication of the two lists.
 :+    e#  Sum the result.
 H=    e#  Check if it's equal to the hash.
},     e# Filter the tuples to only ones for which this block gave a truthy result.

Java, 162 byte

static void f(int n){for(int i=48;i<54;i++){for(int j=48;j<54;j++){for(int k=48;k<54;k++){if(i+j*2+k*3==n)System.out.println((char)i+""+(char)j+""+(char)k);}}}}

JavaScript (Firefox 30-57), 72 byte

n=>[for(i of s="012345")for(j of s)for(k of s)if(n-i-j*2-k*3==288)i+j+k]

Pyth, 18 byte

fqQs*VS3CMT^jkU6 3

QBIC , 40 byte

[0,5|[0,5|[0,5|~a+b+b+c+c+c+288=:\?a,b,c

Spiegazione

[0,5|                Make a FOR loop run through the possible digits for pos 1, called a
[0,5|                Loop for #2, b
[0,5|                Loop for #3, c
                     Calculate the hash by taking a once, b twice and c thrice, 
                     and raising all to their ASCII codepoints
 a+b+b+c+c+c+288       
~               =:   IF thta is euqal to the given hash (read from cmd line)
\?a,b,c              THEN print the digits
                     (the IF and the FOR loops are auto-closed by QBIC)

R , 67 62 61 byte

-5 byte grazie a Jarko Dubbeldam

b=t(t(expand.grid(rep(list(0:5),3))));b[b%*%1:3==scan()-288,]

Provalo online!

legge il numero da stdin ; restituisce una matrice in cui le righe sono i caratteri.

Genera tutti i possibili trii di cifre in un formato matrice ( b), calcola il prodotto matrice b * [1,2,3], prende le righe di bcui corrispondono (sottraendo 288dall'input che è 1*48+2*28+3*48) e le restituisce.