Programmes Prolific Perfect Pangram relatifs aux ASCII imprimables

23

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 148 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.

Loisirs de Calvin
la source
14
Aussi étonnamment admirable que puisse paraître l'allitération, les pangrams sont tout simplement puissants, car ils sont assez vexants.
Geobits
2
Je viens aussi de relire la règle du total non distinct. Je l'avais survolé plus tôt, concluant que c'était évidemment une règle distincte et non totale, car l'alternative conduirait à des constructions absurdes telles que l'impression de la lettre asix quadrillions de fois, où il n'est même pas possible d'obtenir une limite supérieure précise sur nombre de caractères. Quoi qu'il en soit, je suis toujours fier de mon 95, même s'il est un peu petit. La taille n'est pas tout, vous savez.
COTO
Pourquoi pensez-vous que cette tâche est impossible dans HQ9 +?
Peter Taylor
Je vais essayer de le faire dans FORTRAN (donc je peux utiliser l'insensibilité à la casse). --- ET grattez ça. J'ai besoin de la lettre O 4 fois: 2 fois pour la déclaration de programme et 2 fois pour ma déclaration de boucle.
Nzall
1
@Dennis No. 5more
Calvin's Hobbies

Réponses:

12

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 2 (x) = (x ↑ x) ↑ (x ↑ x)> x ↑ x ↑ x = x ↑↑ 3 ,
    f 3 (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 2 (x) = (x ↑↑ x) ↑↑ (x ↑↑ x)> x ↑↑ x ↑↑ x = x ↑↑↑ 3 ,
    g 3 (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 :

                                                                2 ↑↑↑ 4                                                                 

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 ...

Dennis
la source
@DigitalTrauma - Vous devriez vérifier le mien;)
Optimizer
@Dennis - Combien ça coûte à peu près?
Optimizer
@Optimizer You got me ;-)
Digital Trauma
Impressionnant! Cela me rappelle le numéro de Graham ... C'est énorme!
réécrit
3
Notez que, bien que cela devrait théoriquement imprimer un très grand nombre de zéros, en pratique, cela plante simplement l'interpréteur avec in `*': bignum too big to convert into `long' (RangeError).
Ilmari Karonen
22

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

es1024
la source
agréable! mais je me demande si on pourrait utiliser la récursivité ... (pas possible de s'appeler soi-même si vous devez utiliser votre propre nom, car cela représenterait les caractères du nom ... mais le nom de votre fonction ne pourrait-il pas finir dans $ _ ou une autre variable de Perl?) .. ou utilisez intelligemment les appels $ 0 (sans remplir le tas)
Olivier Dulac
Si vous aviez assez de mémoire, vous pourriez le faireperl -E'say qw{m}x(9876543210*ord$")'
hmatt1
2
Si cela aide, il n'y a plus de limite de temps ou de mémoire.
Les loisirs de Calvin le
2
Il est regrettable que Perl utilise ** plutôt que ^ pour l'exponentiation.
Mark
11

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 15 , 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 53 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
$ 
Traumatisme numérique
la source
pourquoi tu ne fais pas seq 9876543210;?
durron597
@ durron597 Parce que cela prend trop de temps - probablement environ une heure. Il doit se terminer en moins de 10 minutes.
Digital Trauma
mais le seul facteur limitant de ce programme est sûrement les E / S ... aucun autre programme dans une autre langue ne pourrait vraiment battre cela.
durron597
@ durron597 Oui, je pense que c'est vrai. Bien que je ne serais pas surpris si quelqu'un dans cette communauté trouve un moyen intelligent ...
Digital Trauma
1
@DigitalTrauma Je supprime en fait la limite de temps pour m'assurer que ce n'est pas l'avant-dernière réponse (aucune infraction, je ne veux tout simplement pas que le concours se termine si tôt: P), alors n'hésitez pas à l'utiliser 9876543210. Vous voudrez peut-être lire la nouvelle dernière règle.
Calvin's Hobbies
6

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

Optimiseur
la source
En théorie, il y aurait plusieurs façons de rendre ce même hewuger, mais malheureusement, le BigNum de Ruby a des limites et 87 9654321?est juste Infinity.
Dennis
Oh! ? Connaissez-vous le maximum? ;)
Optimizer
Pas exactement. Semble dépendre de la machine, car l'entier doit tenir dans la RAM. Avec une mémoire illimitée, je ne sais pas où serait la limite. Probablement 2**(2**64)-1pour Ruby 64 bits.
Dennis
Nous avons une quantité illimitée de RAM
Optimizer
Oui, c'est pourquoi j'ai clarifié. Pour CJam, il existe une limite fixe et l'interprète se bloque simplement lorsque vous épuisez la mémoire. Ruby semble être différent.
Dennis
4

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.

COTO
la source
1
Note aux téléspectateurs: Cette réponse a été soumise lorsque la spécification a demandé de maximiser les caractères uniques . Ce n'est plus le but, mais ça va si cette réponse reste car elle est valide.
Calvin's Hobbies
2

Rubis, 89

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

Sortie:

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

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

Poignée de porte
la source
1
Note aux téléspectateurs: Cette réponse a été soumise lorsque la spécification a demandé de maximiser les caractères uniques . Ce n'est plus le but, mais ça va si cette réponse reste car elle est valide.
Calvin's Hobbies
2

GolfScript, 93

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

Sortie:

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

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

Poignée de porte
la source
6
Votre programme n'est cependant pas un pangram parfait, n'est-ce pas? Il ne semble pas contenir "ni l' 'un ni l' autre.
Martin Ender
Note aux téléspectateurs: Cette réponse a été soumise lorsque la spécification a demandé de maximiser les caractères uniques . Ce n'est plus le but, mais ça va si cette réponse reste si elle est validée.
Calvin's Hobbies
1
Il est assez facile de le rendre valide selon les nouvelles règles: il suffit de le retirer #de sa position actuelle et de l'ajouter #"'à la fin. Le score baissera cependant de un.
Ilmari Karonen
2

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 1 = 2).

Donc, sur cette base:

 12,`{.+}n*

Sort la sortie de 12,`2 n fois.

Beta Decay
la source