Aktualizacje: Usunięto limit czasu. Musisz umieć opisać wynik - patrz nowa reguła.

Pangram jest zdanie, że wykorzystuje każdą literę w alfabecie przynajmniej raz, takie jak:

Szybki brązowy lis przeskakuje nad leniwym psem.

Idealny pangram wykorzystuje każdą literę dokładnie raz.

Rozważ napisanie programu, który jest idealnym pangramem, używając 95 alfabetu znaków drukowalnych ASCII (kody szesnastkowe od 20 do 7E) jako alfabetu:

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

Taki program musi zawierać dokładnie 95 znaków, przy czym każdy znak ASCII do wydruku występuje dokładnie raz, ale w dowolnej kolejności. (Zatem istnieje 95! = 1,03 × 10 ¹⁴⁸ możliwości.)

Twoim zadaniem jest napisanie tego programu w taki sposób, aby liczba drukowalnych znaków ASCII drukowanych na standardowym wyjściu była jak najwyższa (tj. Płodna).

Twój wynik to liczba drukowalnych znaków ASCII, które program wypisuje ( łączna kwota, a nie liczba odrębna : AABCwyniki 4, a ABCwyniki 3) . Najwyższy wynik wygrywa.

Detale

• Wynik może zawierać dowolne znaki (w tym duplikaty), ale tylko wystąpienia 95 drukowanych znaków ASCII liczą się do wyniku.
  • Za pomocą tego JSFiddle można policzyć liczbę drukowalnych znaków ASCII w dowolnym ciągu.
• Jeśli twój język nie ma standardowego, użyj najbardziej odpowiedniej alternatywy.
• Twój program ...
  • musi mieć skończony czas wykonywania (limit czasu został usunięty)
  • musi mieć skończoną wydajność
  • może zawierać komentarze
  • musi się kompilować i uruchamiać bez (nieprzechwyconych) błędów
  • nie może pytać ani wymagać danych wejściowych
  • muszą być niezmienne w czasie i deterministyczne
  • nie wolno używać bibliotek zewnętrznych
  • nie może wymagać połączenia sieciowego
  • nie wolno wykorzystywać plików zewnętrznych
    • (możesz użyć samego pliku programu, o ile zmiana nazwy pliku nie zmienia zachowania programu)
• Jeśli to zadanie jest niemożliwe, to jest jakiś zły język.
• Musisz podać dokładny wynik lub dokładnie go opisać, jeśli jest zbyt duży, aby zmieścił się w poście . W rzeczywistości nie musisz uruchamiać programu. Tak długo, jak będzie działał przez określony czas na komputerze z nieograniczoną ilością pamięci, jest poprawny.

Przykład

Ten uproszczony program w języku Python 2 jest możliwym rozwiązaniem:

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

Wyprowadza, 9876543210który zawiera 10 znaków ASCII do wydrukowania, co daje wynik 10.

GolfScript, ponad 2 ↑↑↑ (9871 ↑↑ 2) znaki

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

Wyświetla liczbę całkowitą. Skorzystaj z nieograniczonej wielkości rejestru procesora (która określa maksymalną długość łańcucha w Rubim), pamięci i czasu działania. Kanał służy wyłącznie do odczytu.

Kod

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

Wynik

Zdefiniuj b = 9871 ↑↑ 2 (patrz notacja Knutha w górę ).

• .? wykonuje f: x ↦ x ↑ x .

• Blok wewnętrzny wykonuje g: x ↦ f ^x (x) .

  Ponieważ 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 i tak dalej, mamy
  g (x)> x ↑↑ (x + 1)> x ↑↑ x .

• Blok zewnętrzny wykonuje h: x ↦ g ^b (x) .

  Ponieważ 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 i tak dalej, mamy h (x)> x ↑↑↑ (b + 1) .

• Zaczynamy od liczby całkowitej 2 na stosie, więc kod oblicza h (2)> 2 ↑↑↑ (b + 1).

• Wynik to liczba cyfr dziesiętnych h (2) , czyli log (h (2)) + 1> log (2 ↑↑↑ (b + 1))> 2 ↑↑↑ b .

Zatem wynik jest większy niż 2 ↑↑↑ (9871 ↑↑ 2) .

2 ↑↑↑ n rośnie w absurdalnym tempie, gdy n rośnie . 2 ↑↑↑ 4: = 2 ↑↑ 2 ↑↑ 2 ↑↑ 2 = 2 ↑↑ 2 ↑↑ 4 = 2 ↑↑ 65536 , która jest prawostronną wieżą mocy 65536 kopii 2 :

Podobnie, 2 ↑↑↑ 5: = 2 ↑↑↑ (2 ↑↑↑ 4) , czyli wieża mocy 2 ↑↑↑ 4 kopie 2 .

Teraz wynik nie wynosi 2 ↑↑↑ 4 lub 2 ↑↑↑ 5 , jest większy niż 2 ↑↑↑ b , gdzie b> 2 × 10 ^{39 428} . To duża liczba ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

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

Wydajność:

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

powtórzone 18446744073709551615 * 10 ^ 987654320 razy.

$[jest domyślnie 0, więc ~$[jest równoważne z 18446744073709551615.

Na marginesie zabrakło mi pamięci, próbując utworzyć numer 10^987654320.

Stara odpowiedź (7703703696):

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

Dane wyjściowe to:

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

powtórzone 98765432 razy.

Uwaga: Uruchom wszystkie próbki za pomocą perl -Mbignum -E

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

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

Wysyła liczby całkowite od 1 do 9x10 ¹⁵ , po jednej w wierszu. Zabiera dużo czasu.

Dlaczego 9E15? Okazuje się, że GNU seqwydaje się używać 64-bitowych liczb zmiennoprzecinkowych (podwójnych) wewnętrznie. Największa liczba całkowita, jaką możemy reprezentować w tym typie, zanim przyrost o jeden przestanie działać z powodu braku precyzji, to 2 ⁵³ lub 9007199254740992. Najbliżej tego możemy uzyskać z notacją wykładniczą 9E15 lub 9000000000000000.

Aby obliczyć wynik, używam sumowania wszystkich liczb z podaną liczbą cyfr i dodawania 9E15, ponieważ między każdą liczbą jest nowa linia:

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

Mógłbym przesłać dane wyjściowe odo dodatkowy rząd wielkości, ale to znacznie utrudnia obliczanie wyniku.

Odpowiedź przed zmianą reguły:

Bash + coreutils, 18 926 221,380

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

Wyjścia 1 do 1592346780. Na moim MacBooku z połowy 2012 roku (który nie jest tak daleko od powiązanego testu porównawczego), zajmuje to około 9m45.

_{Nie mogłem się oprzeć zoptymalizowaniu go trochę bardziej, chociaż to chyba nie ma sensu.}

Wydajność:

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

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

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

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

Jak to działa

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

Oto Xliczba znaków (długość) reprezentacji ciągu tablicy, [0, 1, 2..,(87^9654321) - 1]która będzie podobna[0 1 2 3 4 ... (87^9654321) - 1]

Próbuję Xtu obliczyć , aby znaleźć swój wynik. (87^9654321) - 1jest w przybliżeniu 10^(10^7.272415829713899)z 18724742cyfr dziesiętnych.

Xjest mniej więcej 3*10^(2*10^7)tak X*Xsamo jest również tylko. Zauważ, że te wartości są na bardzo niższej stronie, ponieważ ze względu na ograniczenia obliczeniowe (nawet) wolframa , nie byłem w stanie obliczyć, sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)która jest prawdziwa wartośćX

MATLAB, 95

Kod

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

Wydajność

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

Dane wyjściowe zawierają wszystkie określone znaki ASCII, każdy dokładnie raz i w kolejności.

Ruby, 89

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

Wydajność:

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

Zawiera wszystkie znaki ASCII z wyjątkiem p, , %, q, {, i }.

GolfScript, 93

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

Wydajność:

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

Zawiera wszystkie znaki ASCII oprócz "i '.

Golfscript - 27 * 2 ^{6543 9870}

To moje pierwsze zgłoszenie do Golfscript! :)

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

Wyjaśnienie:

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

Dane wyjściowe to ładunek list liczb. Rozważ następujący kod:

12,`{.+}1*

Dzięki 12,niemu powstaje następująca tablica:

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

Strzałka wsteczna zamienia to w ciąg, przekazując do bloku {.+}. To powiela ciąg, a następnie konkatenuje oba, tworząc:

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

1*Mówi interpreter do wykonania poprzedniego czasu jednego bloku (2 ¹ = 2).

Opierając się na tym:

 12,`{.+}n*

Wysyła wynik 12,`2 ⁿ razy.