Mises à jour: délai supprimé. Vous devez pouvoir décrire la sortie - voir la nouvelle règle.

Un pangram est une phrase qui utilise au moins une fois chaque lettre de l'alphabet, comme:

Le renard brun rapide saute par-dessus le chien paresseux.

Un pangram parfait utilise chaque lettre exactement une fois.

Envisagez d'écrire un programme qui est un pangram parfait, en utilisant les 95 caractères ASCII imprimables (codes hexadécimaux 20 à 7E) comme alphabet:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Un tel programme doit contenir exactement 95 caractères, chaque caractère ASCII imprimable apparaissant exactement une fois, mais dans n'importe quel ordre. (Il y a donc 95! = 1,03 × 10 ¹⁴⁸ possibilités.)

Votre tâche consiste à écrire ce programme de sorte que le nombre de caractères ASCII imprimables imprimés sur stdout soit aussi élevé que possible (c'est-à-dire prolifique).

Votre score est le nombre de caractères ASCII imprimables générés par votre programme (le montant total , pas le montant distinct : AABCscores 4 tandis que ABCscores 3) . Le score le plus élevé l'emporte.

Détails

• La sortie peut contenir n'importe quel caractère (y compris les doublons) mais seules les instances des 95 caractères ASCII imprimables comptent pour votre score.
  • Vous pouvez utiliser ce JSFiddle pour compter le nombre de caractères ASCII imprimables dans n'importe quelle chaîne.
• Si votre langue n'a pas stdout, utilisez l'alternative la plus appropriée.
• Votre programme ...
  • doit avoir un temps d'exécution fini (le délai a été supprimé)
  • doit avoir une sortie finie
  • peut contenir des commentaires
  • doit compiler et s'exécuter sans erreur (non interceptée)
  • ne doit pas demander ou exiger d'entrée
  • doit être invariant dans le temps et déterministe
  • ne doit pas utiliser de bibliothèques externes
  • ne doit pas nécessiter de connexion réseau
  • ne doit pas utiliser de fichiers externes
    • (vous pouvez utiliser le fichier programme lui-même tant que la modification du nom du fichier ne modifie pas le comportement du programme)
• Si cette tâche est impossible, c'est un langage qui est tout simplement trop mauvais.
• Vous devez donner votre sortie exacte ou la décrire précisément si elle est trop grande pour tenir dans un message . Vous n'avez pas réellement besoin d'exécuter votre programme. Tant qu'il serait exécuté dans un laps de temps fini sur un ordinateur avec une quantité illimitée de la mémoire est valide.

Exemple

Ce programme simpliste Python 2 est une solution possible:

print 9876543210#!"$%&'()*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghjklmoqsuvwxyz{|}~

Il génère 987654321010 caractères ASCII imprimables, soit 10.

GolfScript, plus de 2 ↑↑↑ (9871 ↑↑ 2) caractères

2 9871.?,{;0$[45)63]n+*~}/
#!"%&'(-:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ\^_`abcdefghijklmopqrstuvwxyz|

Imprime un entier. Profitez de la taille illimitée du registre CPU (qui détermine la longueur de chaîne maximale dans Ruby), de la mémoire et de la durée d'exécution. Le saut de ligne est uniquement destiné à la lisibilité.

Le code

2             # Push 2.
9871.?        # Push b := 9871↑↑2 = 9871↑9871 = 9871**9871.
,{            # For each i from 0 to b - 1:
  ;0$         #   Discard i and duplicate the integer on the stack.
  [45)63]n+*  #   Replicate ".?\n" that many times.
  ~           #   Evaluate.
 }/           #

Le score

Définissez b = 9871 ↑↑ 2 (voir la notation de la flèche vers le haut de Knuth ).

• .? exécute f: x ↦ x ↑ x .

• Le bloc interne exécute g: x ↦ f ^x (x) .

  Puisque f (x) = x ↑ x = x ↑↑ 2 , f ² (x) = (x ↑ x) ↑ (x ↑ x)> x ↑ x ↑ x = x ↑↑ 3 ,
  f ³ (x) = ((x ↑ x) ↑ (x ↑ x)) ↑ ((x ↑ x) ↑ (x ↑ x))> (x ↑ x ↑ x) ↑ (x ↑ x ↑ x)> x ↑ x ↑ x ↑ x = x ↑↑ 4 et ainsi de suite, nous avons
  g (x)> x ↑↑ (x + 1)> x ↑↑ x .

• Le bloc externe exécute h: x ↦ g ^b (x) .

  Puisque g (x) = x ↑↑ x = x ↑↑↑ 2 , g ² (x) = (x ↑↑ x) ↑↑ (x ↑↑ x)> x ↑↑ x ↑↑ x = x ↑↑↑ 3 ,
  g ³ (x) = ((x ↑↑ x) ↑↑ (x ↑↑ x)) ↑↑ ((x ↑↑ x) ↑↑ (x ↑↑ x))> (x ↑↑ x ↑↑ x) ↑ (x ↑↑ x ↑↑ x)> x ↑↑ x ↑↑ x ↑↑ x = x ↑↑↑ 4 et ainsi de suite, nous avons h (x)> x ↑↑↑ (b + 1) .

• Nous commençons par l'entier 2 sur la pile, donc le code calcule h (2)> 2 ↑↑↑ (b + 1).

• Le score est le nombre de chiffres décimaux de h (2) , qui est log (h (2)) + 1> log (2 ↑↑↑ (b + 1))> 2 ↑↑↑ b .

Ainsi, le score est supérieur à 2 ↑↑↑ (9871 ↑↑ 2) .

2 ↑↑↑ n croît à un rythme ridicule à mesure que n grandit. 2 ↑↑↑ 4: = 2 ↑↑ 2 ↑↑ 2 ↑↑ 2 = 2 ↑↑ 2 ↑↑ 4 = 2 ↑↑ 65536 , qui est une tour de puissance associative droite de 65536 copies de 2 :

De même, 2 ↑↑↑ 5: = 2 ↑↑ (2 ↑↑↑ 4) , qui est une tour de puissance de 2 ↑↑↑ 4 exemplaires de 2 .

Maintenant, le score n'est pas 2 ↑↑↑ 4 ou 2 ↑↑↑ 5 , il est supérieur à 2 ↑↑↑ b , où b> 2 × 10 ^{39 428} . C'est un gros chiffre ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

say q{!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|}x(1e987654320*~$[)

Sortie:

!"#%&'+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ\]^_`bcdfghijklmnoprtuvwz|

répété 18446744073709551615 * 10 ^ 987654320 fois.

$[est par défaut 0, ~$[est donc équivalent à 18446744073709551615.

En remarque, j'ai manqué de mémoire en essayant de créer le numéro 10^987654320.

Ancienne réponse (7703703696):

say qw(!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10)x98765432

La sortie est:

!"#$%&'*+,-./:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bcdefghijklmnoprtuvz{|}~10

répété 98765432 fois.

Remarque: exécutez tous les échantillons avec perl -Mbignum -E

Bash + coreutils, 151 888 888 888 888 905 (1,5 * 10 ^ 17)

seq 9E15;#\!%*+,-./2346780:=@ABCDFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[

Produit des entiers de 1 à 9 x 10 ¹⁵ , un par ligne. Prend beaucoup de temps.

Pourquoi 9E15? Il s'avère que GNU seqsemble utiliser des flottants 64 bits (double) en interne. Le plus grand nombre entier que nous pouvons représenter avec ce type, avant que l'incrémentation ne cesse de fonctionner en raison d'un manque de précision, est 2 ⁵³ ou 9007199254740992. Le plus proche que nous pouvons obtenir avec la notation exponentielle est 9E15 ou 9000000000000000.

Pour calculer le score, j'utilise en additionnant tous les nombres avec un nombre donné de chiffres et en ajoutant 9E15, car il y a une nouvelle ligne entre chaque nombre:

8000000000000001*16 + 900000000000000*15 + 90000000000000*14 + 9000000000000*13 + 900000000000*12 + 90000000000*11 + 9000000000*10 + 900000000*9 + 90000000*8 + 9000000*7 + 900000*6 + 90000*5 + 9000*4 + 900*3 + 90*2 + 9 + 9000000000000000

Je pourrais diriger cette sortie odpour un ordre de grandeur supplémentaire, mais cela rend le calcul du score beaucoup plus difficile.

Réponse au changement de pré-règle:

Bash + coreutils, 18 926 221 380

seq 1592346780;#\!%*+,-./:=@ABCDEFGHIJKLMNOPQRSTUVWXYZ]^_abcdfghijklmnoprtuvwxyz~"'$&()?<>`{}|[

Sorties 1 à 1592346780. Sur mon macbook mi-2012 (qui n'est pas si loin du benchmark lié), cela prend environ 9m45s.

_{Je n'ai pas pu résister à l'optimiser un peu plus, même si cela n'a probablement aucun sens.}

Sortie:

$ time ./pangram.sh | wc
 1592346780 1592346780 18926221380

real    9m46.564s
user    11m7.419s
sys 0m10.974s
$ 

GolfScript, ≈ 3 * 10 ^ (2 * 10 ^ 7) soit ≈ 3x10 ^20000000

 87 9654321?,`0${;.p}/#!"%&'()*+-9:<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnoqrstuvwxyz|~

Comment ça marche

87 9654321?                "Pushes 87^9654321 to stack";
           ,               "Pushes an array [0, 1, 2 ... (87^9654321) - 1] to stack";
            `              "Creates a string representation of the array like "[0 1 2...]";
             0$            "Copies the string";
               {;.p}/      "Print the string wrapped in quotes X times";
                     #...  "This is all comment";

Voici Xle nombre de caractères (longueur) de la représentation sous forme de chaîne du tableau [0, 1, 2..,(87^9654321) - 1]qui sera comme[0 1 2 3 4 ... (87^9654321) - 1]

J'essaie de calculer Xici pour trouver mon score. (87^9654321) - 1est à peu près 10^(10^7.272415829713899)avec 18724742des chiffres décimaux.

Xest à peu près 3*10^(2*10^7)ainsi X*Xest également le même. Notez que ces valeurs sont sur un côté très inférieur car en raison des limitations de calcul de (même) wolframa , je n'ai pas pu calculer sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)quelle est la vraie valeur deX

MATLAB, 95

Code

char(37-5:126)% !"#$&'*+,./0489;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`bdefgijklmnopqstuvwxyz{|}~

Sortie

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

La sortie contient tous les caractères ASCII spécifiés, chacun exactement une fois, et dans l'ordre.

Rubis, 89

p %q{!"#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnorstuvwxyz|~}

Sortie:

"!\"\#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnorstuvwxyz|~"

Contient tous les caractères ASCII à l' exception, p, , %, q, {et }.

GolfScript, 93

{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}

Sortie:

{ !#$%&()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz|~}
}

Contient tous les caractères ASCII sauf "et '.

Golfscript - 27 * 2 ^{6543 9870}

C'est ma première soumission Golfscript! :)

12,`{.+}6543 9870?*#!"$%&'()-/:;<=>@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz|~

Explication:

12,                     - Creates an array of ascending numbers from 0 to 11
   `                    - Converts the array to a string
    {.+}                - Duplicates the string on the stack and concatenates the two
        6543 9870?      - Calculates 6543^9870 and pushes it to the stack
                  *     - Repeat the block 6543^9870 times
                   #... - The rest is a comment

La sortie est une charge de listes de nombres. Considérez le code suivant:

12,`{.+}1*

Avec 12,elle produit le tableau suivant:

[0 1 2 3 4 5 6 7 8 9 10 11]

Le backtick transforme cela en chaîne, en le passant au bloc {.+}. Cela duplique la chaîne, puis concatène les deux, produisant:

[0 1 2 3 4 5 6 7 8 9 10 11][0 1 2 3 4 5 6 7 8 9 10 11]

Le 1*dit à l'interpréteur d'exécuter le bloc précédent une fois (2 ¹ = 2).

Donc, sur cette base:

 12,`{.+}n*

Sort la sortie de 12,`2 ⁿ fois.