Updates: Zeitlimit entfernt. Sie müssen in der Lage sein, die Ausgabe zu beschreiben - siehe neue Regel.

Ein Pangram ist ein Satz, der jeden Buchstaben des Alphabets mindestens einmal verwendet, z.

Der schnelle braune Fuchs springt über den faulen Hund.

Ein perfekter Pangram benutzt jeden Buchstaben genau einmal.

Erwägen Sie, ein Programm zu schreiben, das ein perfekter Pangram ist und das 95 druckbare ASCII- Zeichen (Hex-Codes 20 bis 7E) als Alphabet verwendet:

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

Ein solches Programm muss genau 95 Zeichen enthalten, wobei jedes druckbare ASCII-Zeichen genau einmal vorkommt, jedoch in beliebiger Reihenfolge. (Somit gibt es 95! = 1,03 × 10 ¹⁴⁸ Möglichkeiten.)

Ihre Aufgabe ist es, dieses Programm so zu schreiben, dass die Anzahl der druckbaren ASCII-Zeichen, die auf stdout gedruckt werden, so hoch wie möglich (dh produktiv) ist.

Ihr Ergebnis ist die Anzahl der druckbaren ASCII - Zeichen Ihres Programm gibt (die Gesamtmenge, nicht die unterschiedliche Menge: AABCNoten 4 während ABCPartituren 3) . Die höchste Punktzahl gewinnt.

Einzelheiten

• Die Ausgabe kann beliebige Zeichen (einschließlich Duplikate) enthalten, aber nur Instanzen der 95 druckbaren ASCII-Zeichen werden für Ihre Punktzahl berücksichtigt.
  • Mit diesem JSFiddle können Sie die Anzahl der druckbaren ASCII-Zeichen in einer beliebigen Zeichenfolge zählen.
• Wenn Ihre Sprache keine Standardsprache ist, verwenden Sie die am besten geeignete Alternative.
• Ihr Programm ...
  • muss eine begrenzte Laufzeit haben (das Zeitlimit wurde entfernt)
  • muss endliche Ausgabe haben
  • Kann Kommentare enthalten
  • muss ohne (nicht erfasste) Fehler kompiliert und ausgeführt werden
  • Darf nicht zur Eingabe auffordern oder eine Eingabe erfordern
  • muss zeitinvariant und deterministisch sein
  • darf keine externen Bibliotheken verwenden
  • darf keine Netzwerkverbindung erfordern
  • darf keine externen Dateien verwenden
    • (Sie können die Programmdatei selbst verwenden, solange das Ändern des Dateinamens das Verhalten des Programms nicht verändert.)
• Wenn diese Aufgabe nicht möglich ist, ist eine Sprache einfach zu schlecht.
• Sie müssen Ihre genaue Ausgabe angeben oder genau beschreiben, wenn sie zu groß ist, um in einen Beitrag zu passen . Sie müssen Ihr Programm nicht unbedingt ausführen. Solange es würde in einer endlichen Menge an Zeit auf einem Computer mit einer unbegrenzten Menge an Speicher ausgeführt ist es gültig.

Beispiel

Dieses vereinfachte Python 2-Programm ist eine mögliche Lösung:

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

Es gibt 987654321010 druckbare ASCII-Zeichen aus und erhält somit 10 Punkte.

GolfScript, über 2 ↑↑↑ (9871 ↑↑ 2) Zeichen

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

Gibt eine ganze Zahl aus. Profitieren Sie von der unbegrenzten CPU-Registergröße (die die maximale Stringlänge in Ruby bestimmt), dem Arbeitsspeicher und der Laufzeit. Der Zeilenumbruch dient ausschließlich der Lesbarkeit.

Der 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.
 }/           #

Die Punktzahl

Definieren Sie b = 9871 ↑↑ 2 (siehe Knuths Aufwärtspfeil-Notation ).

• .? führt f aus: x ↦ x ↑ x .

• Der innere Block führt g aus: x ↦ f ^x (x) .

  Da 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 und so weiter haben wir
  g (x)> x ↑↑ (x + 1)> x ↑↑ x .

• Der äußere Block führt h aus: x ↦ g ^b (x) .

  Da 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 und so weiter haben wir h (x)> x ↑↑↑ (b + 1) .

• Wir beginnen mit der Ganzzahl 2 auf dem Stapel, sodass der Code h (2)> 2 ↑↑↑ (b + 1) berechnet .

• Die Punktzahl ist die Anzahl der Dezimalstellen von h (2) , dh log (h (2)) + 1> log (2 ↑↑↑ (b + 1))> 2 ↑↑↑ b .

Daher ist die Punktzahl größer als 2 ↑↑↑ (9871 ↑↑ 2) .

2 ↑↑↑ n wächst lächerlich schnell , wenn n größer wird. 2 ↑↑↑ 4: = 2 ↑↑ 2 ↑↑ 2 ↑↑ 2 = 2 ↑↑ 2 ↑↑ 4 = 2 ↑↑ 65536 , ein rechtsassoziativer Machtturm mit 65536 Exemplaren von 2 :

In ähnlicher Weise ist 2 ↑↑↑ 5: = 2 ↑↑ (2 ↑↑↑ 4) , ein Kraftturm von 2 ↑↑↑ 4 Kopien von 2 .

Jetzt ist die Punktzahl nicht 2 ↑↑↑ 4 oder 2 ↑↑↑ 5 , sondern größer als 2 ↑↑↑ b , wobei b> 2 × 10 ^{39 428 ist} . Das ist eine große Zahl ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

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

Ausgabe:

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

18446744073709551615 * 10 ^ 987654320 mal wiederholt .

$[ist standardmäßig 0, ~$[entspricht also 18446744073709551615.

Als Randnotiz ging mir der Speicher aus, als ich versuchte, die Nummer zu erstellen 10^987654320.

Alte Antwort (7703703696):

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

Ausgabe ist:

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

98765432 mal wiederholt.

Hinweis: Führen Sie alle Proben mit perl -Mbignum -E

Bash + Coreutils, 151.888.888.888.888.905 (1,5 * 10 ^ 17)

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

Gibt ganze Zahlen von 1 bis 9x10 ^{15 aus} , eine pro Zeile. Es dauert lange.

Warum 9E15? Es stellt sich heraus, dass GNU seq64-Bit-Floats (double) intern verwendet. Die größte ganze Zahl, die wir mit diesem Typ darstellen können, bevor das Inkrementieren um eins aufgrund mangelnder Präzision aufhört zu arbeiten, ist 2 ⁵³ oder 9007199254740992. Mit Exponentialschreibweise können wir dem am nächsten kommen: 9E15 oder 900000000000000000.

Um die Punktzahl zu berechnen, addiere ich alle Zahlen mit einer bestimmten Anzahl von Ziffern und addiere 9E15, da zwischen jeder Zahl eine neue Zeile steht:

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

Ich könnte diese Ausgabe odfür eine zusätzliche Größenordnung weiterleiten, aber das erschwert die Berechnung der Punktzahl erheblich.

Antwort vor Regeländerung:

Bash + Coreutils, 18.926.221.380

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

Ausgabe 1 bis 1592346780. Auf meinem Macbook von Mitte 2012 (das nicht weit vom verknüpften Benchmark entfernt ist) dauert dies ungefähr 9:45 Minuten.

_{Ich konnte nicht widerstehen, es ein bisschen weiter zu optimieren, obwohl es wahrscheinlich bedeutungslos ist.}

Ausgabe:

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

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

GolfScript, ≤ 3 × 10 ^ (2 ^× 10 ^ 7), dh ^≤ 3 × 10 ^20000000

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

Wie es funktioniert

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";

Hier Xist die Zeichenanzahl (Länge) der Zeichenfolgendarstellung des Arrays, [0, 1, 2..,(87^9654321) - 1]die gleich sein wird[0 1 2 3 4 ... (87^9654321) - 1]

Ich versuche hier zu berechnen X, um meine Punktzahl zu finden. (87^9654321) - 1ist ungefähr 10^(10^7.272415829713899)mit 18724742Dezimalstellen.

Xist ungefähr 3*10^(2*10^7)so X*Xist auch nur dasselbe. Beachten Sie, dass diese Werte sehr niedrig sind , da ich aufgrund der Berechnungseinschränkungen von (gerade) wolframa nicht berechnen konnte, sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)welcher der wahre Wert von istX

MATLAB, 95

Code

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

Ausgabe

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

Die Ausgabe enthält alle angegebenen ASCII-Zeichen, jeweils genau einmal und in der angegebenen Reihenfolge.

Ruby, 89

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

Ausgabe:

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

Enthält alle ASCII - Zeichen außer p, , %, q, {, und }.

GolfScript, 93

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

Ausgabe:

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

Enthält alle ASCII-Zeichen außer "und '.

Golfscript - 27 * 2 ^{6543 9870}

Dies ist meine erste Golfscript Einreichung! :)

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

Erläuterung:

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

Die Ausgabe ist eine Ladung von Nummernlisten. Betrachten Sie den folgenden Code:

12,`{.+}1*

Damit 12,ergibt sich folgendes Array:

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

Der Backtick wandelt das in einen String um und übergibt ihn an den Block {.+}. Dies dupliziert die Zeichenkette und verkettet dann die beiden, was ergibt:

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

Das 1*sagt dem Interpreter den vorherigen Block einmal (2 auszuführen , ¹ = 2).

Darauf aufbauend:

 12,`{.+}n*

Gibt die Ausgabe von 12,`2 ^n- mal aus.