Ho tanti segreti e nessun posto dove conservarli!

L'obiettivo è semplice: scrivere un programma che ti consenta di salvare una stringa e di proteggerla con una password.

Il programma prenderà un alias, una password e un segreto (opzionale) come parametri.

Se è la prima volta che il programma viene chiamato con un determinato alias, allora memorizzerà / ricorderà il segreto e produrrà quello che vuoi.

Se il programma viene chiamato con un alias che è stato utilizzato in precedenza, verrà generato il segreto per tale alias se la password è la stessa della prima volta che il programma è stato eseguito con tale alias.

Altri casi

• Se è la prima volta che viene chiamato con un certo alias e non viene dato alcun segreto, non conservare nulla.

• Se il programma viene chiamato con un alias che è stato utilizzato e la password non è corretta, restituire qualsiasi tipo di errore o nulla.

• Se il programma viene chiamato con un alias che è stato utilizzato, la password è corretta e viene fornito un nuovo segreto: emette il vecchio segreto e sostituiscilo con quello nuovo in modo che la prossima volta venga emesso solo il nuovo segreto.

• Se il programma viene chiamato con un alias che è stato utilizzato, la password è corretta e non viene fornito alcun nuovo segreto: emettere il vecchio segreto e assicurarsi che non venga sostituito.

Nota: questi segreti / password non devono essere archiviati in modo sicuro

Nota anche: qualsiasi input alfanumerico per password e segreti degli alias deve essere accettato

Si applicano le regole standard, buona fortuna!

JavaScript (ES6),  60  50 byte

10 byte salvati grazie a @JonasWilms !

Accetta input come (alias,password,secret)o (alias,password). Restituisce indefinito la prima volta che viene memorizzato un segreto o falso se la password non è corretta.

f=(a,p,s,[P,v]=f[a]||[p])=>p==P&&(f[a]=[P,s||v],v)

Prova un primo caso di test online!

Prova un secondo caso di test online!

Come?

$f$

Commentate

f = (             // f = named function whose underlying object is used for storage
  a,              // a = alias
  p,              // p = password
  s,              // s = optional secret
  [P, v] = f[a]   // if f[a] is defined, retrieve the password P and the secret v
           || [p] // otherwise, copy p in P
) =>              //
  p == P && (     // if p is not equal to P, yield false; else:
    f[a] = [      //   update f[a]:
      P,          //     save the new password (or leave it unchanged)
      s || v      //     save the new secret if it's defined, or keep the previous one
    ],            //
    v             //   return the previous secret
  )               //

Python 2 , 94 93 byte

def f(a,p,s=0,d={}):
 q,t=d.get(a,(0,0))
 if q==p:d[a]=p,s or t;return t
 elif q<1<s:d[a]=p,s

Provalo online!

Per una volta, lo strano parametro dict predefinito di Python funziona a mio favore ...

Rubino , 64 byte

Crea un hash per gli alias in un'unica coppia di chiavi password => secret. Probabilmente potrebbe essere più elegante.

->a,w,s=p{@q||={};(b=@q[a])?s&&b[w]?b[w]=s:b[w]:s&&@q[a]={w=>s}}

Provalo online!

Wolfram Language (Mathematica) , 34 byte

(c=#~g~#2;#3!=##3||(#~g~#2=#3);c)&

Provalo online!

C # (compilatore interattivo Visual C #) , 140 138 134 byte

^{-2 byte grazie a @Expired Data}

a=>p=>s=>(a=P.ContainsKey(a)?P[a]:P[a]=new[]{p,s},o:p==a[0]?a[1]:p,s==""?s:p==a[0]?a[1]=s:s).o;var P=new Dictionary<string,string[]>()

Provalo online!

Python 2 , 77 byte

def f(a,p,s=0,d={}):
 P,S=d.get(a,(p,0))
 if p==P:
	if s>0:d[a]=p,s
	return S

Provalo online!

Simile al metodo di Chas Brown .