Cập nhật: Giới hạn thời gian loại bỏ. Bạn phải có thể mô tả đầu ra - xem quy tắc mới.

Một pangram là một câu sử dụng mỗi chữ cái trong bảng chữ cái ít nhất một lần, chẳng hạn như:

The quick brown fox jumps over the lazy dog.

Một pangram hoàn hảo sử dụng mỗi chữ cái chính xác một lần.

Hãy xem xét việc viết một chương trình là một pangram hoàn hảo, sử dụng 95 ký tự ASCII có thể in (mã hex 20 đến 7E) làm bảng chữ cái:

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

Một chương trình như vậy phải chứa chính xác 95 ký tự, với mỗi ký tự ASCII có thể in được xảy ra chính xác một lần, nhưng theo bất kỳ thứ tự nào. (Như vậy, có 95! = 1.03 × 10 ¹⁴⁸ khả năng.)

Nhiệm vụ của bạn là viết chương trình này sao cho số lượng ký tự ASCII có thể in được in ra thiết bị xuất chuẩn càng cao càng tốt (tức là sinh sôi nảy nở).

Điểm của bạn là số ký tự ASCII có thể in được mà chương trình của bạn xuất ra ( tổng số tiền, không phải số lượng riêng biệt : AABCđiểm 4 trong khi ABCđiểm 3) . Điểm cao nhất sẽ thắng.

Chi tiết

• Đầu ra có thể chứa bất kỳ ký tự nào (bao gồm cả các bản sao) nhưng chỉ các phiên bản của 95 ký tự ASCII có thể in được tính vào điểm số của bạn.
  • Bạn có thể sử dụng JSFiddle này để đếm số lượng ký tự ASCII có thể in trong bất kỳ chuỗi nào.
• Nếu ngôn ngữ của bạn không có thiết bị xuất chuẩn, hãy sử dụng giải pháp thay thế phù hợp nhất.
• Chương trình của bạn ...
  • phải có thời gian chạy hữu hạn (giới hạn thời gian đã được gỡ bỏ)
  • phải có đầu ra hữu hạn
  • có thể chứa ý kiến
  • phải biên dịch và chạy mà không có (chưa) lỗi
  • không được nhắc hoặc yêu cầu đầu vào
  • phải bất biến thời gian và xác định
  • không được sử dụng các thư viện bên ngoài
  • không được yêu cầu kết nối mạng
  • không được sử dụng các tập tin bên ngoài
    • (bạn có thể sử dụng chính tệp chương trình miễn là thay đổi tên tệp không làm thay đổi hành vi của chương trình)
• Nếu nhiệm vụ này là không thể thì một số ngôn ngữ quá tệ.
• Bạn phải cung cấp đầu ra chính xác của bạn hoặc mô tả chính xác nếu nó quá lớn để phù hợp với bài viết . Bạn không thực sự phải chạy chương trình của bạn. Miễn là nó sẽ chạy trong một khoảng thời gian hữu hạn trên một máy tính có dung lượng bộ nhớ không giới hạn, nó là hợp lệ.

Thí dụ

Chương trình Python 2 đơn giản này là một giải pháp khả thi:

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

Nó xuất ra 987654321010 ký tự ASCII có thể in, do đó đạt 10 điểm.

GolfScript, ký tự trên 2 (9871 2)

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

In một số nguyên. Tận dụng kích thước thanh ghi CPU không giới hạn (xác định độ dài chuỗi tối đa trong Ruby), bộ nhớ và thời gian chạy. Nguồn cấp dữ liệu chỉ dành cho khả năng đọc.

Mật mã

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

Điểm số

Xác định b = 9871 2 (xem ký hiệu mũi tên lên của Knuth ).

• .? thực hiện f: x ↦ x ↑ x .

• Khối bên trong thực hiện g: x ↦ f ^x (x) .

  Vì 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 và cứ thế, ta có
  g (x)> x ↑↑ (x + 1)> x ↑↑ x .

• Khối bên ngoài thực hiện h: x ↦ g ^b (x) .

  Vì 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 và cứ thế, ta có h (x)> x ↑↑↑ (b + 1) .

• Chúng ta bắt đầu với số nguyên 2 trên ngăn xếp, do đó mã tính h (2)> 2 (b + 1).

• Điểm số là số chữ số thập phân của h (2) , đó là log (h (2)) + 1> log (2 ↑↑↑ (b + 1))> 2 b .

Do đó, điểm số lớn hơn 2 (9871 2) .

2 ↑↑↑ n phát triển với một tốc độ vô lý khi n lớn hơn. 2 ↑↑↑ 4: = 2 2 ↑↑ 2 ↑↑ 2 = 2 2 ↑↑ 4 = 2 ↑↑ 65536 , là một tháp quyền lực liên kết phải gồm 65536 bản sao của 2 :

Tương tự, 2 ↑↑↑ 5: = 2 (2 ↑↑↑ 4) , là một tháp năng lượng gồm 2 4 bản sao của 2 .

Bây giờ, điểm số không phải là 2 ↑↑↑ 4 hoặc 2 5 , nó lớn hơn 2 ↑↑↑ b , trong đó b> 2 × 10 ^{39 428} . Đó là một con số lớn ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

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

Đầu ra:

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

lặp lại 18446744073709551615 * 10 ^ 987654320 lần.

$[theo mặc định 0, vì vậy ~$[tương đương với 18446744073709551615.

Như một lưu ý phụ, tôi hết bộ nhớ khi cố gắng tạo số 10^987654320.

Câu trả lời cũ (7703703696):

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

Đầu ra là:

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

lặp lại 98765432 lần.

Lưu ý: Chạy tất cả các mẫu với perl -Mbignum -E

Bash + coreutils, 151.888.888.888.888.905 (1.5 * 10 ^ 17)

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

Đầu ra số nguyên 1 đến 9x10 ¹⁵ , mỗi số một dòng. Mất một thời gian dài.

Tại sao 9E15? Hóa ra GNU seqdường như sử dụng phao 64 bit (gấp đôi) bên trong. Số nguyên lớn nhất chúng ta có thể biểu thị với loại này, trước khi tăng thêm một lần dừng do thiếu độ chính xác, là 2 ⁵³ hoặc 9007199254740992. Gần nhất chúng ta có thể nhận được với ký hiệu số mũ này là 9E15 hoặc 9000000000000000.

Để tính điểm, tôi đang sử dụng cộng tất cả các số với một số chữ số cho trước và thêm 9E15, bởi vì có một dòng mới giữa mỗi số:

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

Tôi có thể chuyển đầu ra này qua odmột mức độ lớn hơn hoặc hơn, nhưng điều đó làm cho việc tính toán điểm số khó hơn nhiều.

Câu trả lời thay đổi quy tắc:

Bash + coreutils, 18.926.221.380

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

Đầu ra 1 đến 1592346780. Trên macbook giữa năm 2012 của tôi (không quá xa so với điểm chuẩn được liên kết), quá trình này mất khoảng 9m45 giây.

_{Tôi không thể cưỡng lại việc tối ưu hóa nó thêm một chút nữa, mặc dù có lẽ nó vô nghĩa.}

Đầu ra:

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

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

GolfScript, ≈ 3 * 10 ^ (2 * 10 ^ 7) tức là ≈ 3x10 ^20000000

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

Làm thế nào nó hoạt động

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

Dưới đây Xlà số ký tự (độ dài) của biểu diễn chuỗi của mảng [0, 1, 2..,(87^9654321) - 1]sẽ giống như[0 1 2 3 4 ... (87^9654321) - 1]

Tôi đang cố gắng tính toán Xở đây để tìm điểm của tôi. (87^9654321) - 1là khoảng 10^(10^7.272415829713899)với các 18724742chữ số thập phân.

Xđại khái là như 3*10^(2*10^7)vậy X*Xcũng giống nhau thôi. Lưu ý rằng các giá trị này ở phía rất thấp do giới hạn tính toán của (thậm chí) wolframa , tôi không thể tính sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)được giá trị thực củaX

MATLAB, 95

Mã

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

Đầu ra

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

Đầu ra chứa tất cả các ký tự ASCII được chỉ định, mỗi ký tự chính xác một lần và theo thứ tự.

Ruby, 89

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

Đầu ra:

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

Chứa tất cả các ký tự ASCII trừ, p, , %, q, {, và }.

GolfScript, 93

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

Đầu ra:

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

Chứa tất cả các ký tự ASCII ngoại trừ "và '.

Bản đánh gôn - 27 * 2 ^{6543 9870}

Đây là bài nộp Golfscript đầu tiên của tôi! :)

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

Giải trình:

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

Đầu ra là một danh sách các số. Hãy xem xét các mã sau đây:

12,`{.+}1*

Với 12,nó tạo ra các mảng sau:

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

Backtick biến nó thành một chuỗi, chuyển nó vào khối {.+}. Điều này sao chép chuỗi và sau đó nối hai chuỗi, tạo ra:

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

Thông báo 1*cho trình thông dịch thực hiện khối trước đó một lần (2 ¹ = 2).

Vì vậy, dựa trên điều đó:

 12,`{.+}n*

Đầu ra đầu ra 12,`2 ⁿ lần.