Dans le protocole Bitcoin, 2016 est un numéro très spécial. La «difficulté» de trouver un hachage pour créer un nouveau bloc est ajustée tous les 2 016 blocs pour changer approximativement une fois toutes les deux semaines.

Ce nombre a été choisi parce que la difficulté s'ajuste pour que chaque bloc prenne environ 10 minutes à trouver, et en deux semaines, il y a 2 × 7 × 24 × 6 = 2 016 périodes de dix minutes.

Pour commémorer cette coïncidence numérique, le problème du Nouvel An de cette année concerne le Bitcoin - en particulier, l'algorithme de hachage qu'il utilise pour signer les blocs, SHA-256.

Votre tâche consiste à créer un programme qui prendra des octets en entrée (au moins en ASCII) et produira un nonce en octets (au format de votre choix) qui produira un hachage SHA-256 contenant 2016dans sa représentation base64 lorsqu'il sera ajouté à l'original entrée octet.

Voici quelques exemples de solutions valables, gracieuseté des moteurs que les gens ont déjà générés, ainsi que des hachages qu'ils ont produits:

> foo
Nonce: 196870
SHA256 hash: OCUdDDtQ42wUlKz2016x+NROo8P2lbJf8F4yCKedTLE=

> bar
Nonce: 48230
SHA256 hash: CNcaOCQgT7bnlQzQPXNwuBu8/LYEdk2016khRaROyZk=

> happynewyear
Nonce: 1740131
SHA256 hash: XsKke6z2016BzB+wRNCm53LKJ6TW6ir66GwuC8oz1nQ=

> 2016
Nonce: 494069
SHA256 hash: rWAHW2YFhHCr22016zw+Sog6aW76eImgO5Lh72u6o5s=

(note: the nonces don't actually have to be ASCII numbers; you can do
 any byte input you find convenient.)

La seule bibliothèque prédéfinie (autre que les fonctions d'entrée et de sortie standard) que votre programme peut utiliser est une SHA256(bytes)fonction qui accepte des octets et renvoie un hachage SHA256, dans n'importe quel format, y compris base64.

Le programme pour ce faire dans le moins d'octets de code source gagne.

Perl 5.10+, 39 + 18 = 57 octets

sha256_base64($_.++$i)!~2016?redo:say$i

Cela doit être exécuté avec le -nMDigest::SHA=/./commutateur de ligne de commande, qui est inclus dans le nombre d'octets. Il utilise également la fonctionnalité Perl 5.10+ say, et doit donc être exécuté avec le commutateur de ligne de commande -M5.010(ou -E), qui est considéré comme gratuit. L'entrée doit être fournie sur stdin, sans retour à la ligne (sauf si vous voulez que le retour à la ligne soit considéré comme faisant partie de l'entrée).

Exemples:

$ echo -n foo | perl -nMDigest::SHA=/./ -E 'sha256_base64($_.++$i)!~2016?redo:say$i'
196870
$ echo -n bar | perl -nMDigest::SHA=/./ -E 'sha256_base64($_.++$i)!~2016?redo:say$i'
48230
$ echo -n happynewyear | perl -nMDigest::SHA=/./ -E 'sha256_base64($_.++$i)!~2016?redo:say$i'
1740131
$ echo -n 2016 | perl -nMDigest::SHA=/./ -E 'sha256_base64($_.++$i)!~2016?redo:say$i'
494069

Mathematica, 94

(For[i=0,IntegerDigits[4Hash[#<>ToString@++i,"SHA256"],64]~SequenceCount~{54,52,53,58}<1,];i)&

Cette fonction essaiera des entiers positifs comme candidats. Cela prend plus de 4 minutes sur mon ordinateur portable pour obtenir la bonne réponse.

%["foo"]
(* 196870 *)

Une ~5ximplémentation plus longue mais plus rapide ( ) utilise la parallélisation:

f[k_]:=
    Do[If[Length@#>0,Return[i+#[[1,1]]]]&@
        Position[ParallelMap[IntegerDigits[4Hash[k<>ToString@#,"SHA256"],64]
            ~SequenceCount~{54,52,53,58}&,i+Range@1*^4],1]
        ,{i,0,∞,1*^4}]

Rubis, 87 86 octets

Je ne sais pas si j'ai bien compris le défi, mais il trouve 196870en quelques secondes si vous entrez foo.

require"digest"
gets.chop!
$.+=1until/2016/=~Digest::SHA256.base64digest("#$_#$.")
p$.

PowerShell, 150 152 153 octets

while([Convert]::ToBase64String([Security.Cryptography.SHA256]::Create().ComputeHash([Text.Encoding]::UTF8.GetBytes("$args$i")))-notmatch2016){$i++}$i

Exemple

PS > .\BitCoin.ps1 foo
196870

PS > .\BitCoin.ps1 bar
48230

PS > .\BitCoin.ps1 happynewyear
1740131

PS > .\BitCoin.ps1 2016
494069

C #, 179 octets

s=>{int i=0;while(!System.Convert.ToBase64String(System.Security.Cryptography.SHA256.Create().ComputeHash(System.Text.Encoding.UTF8.GetBytes(s+i))).Contains("2016"))i++;return i;}

Semblable à la solution PowerShell, juste plus longtemps.