อัปเดต: นำการ จำกัด เวลาออก คุณต้องสามารถอธิบายผลลัพธ์ - ดูกฎใหม่

แกรมเป็นประโยคที่ใช้ตัวอักษรในตัวอักษรทุกอย่างน้อยหนึ่งครั้งเช่น:

สุนัขจิ้งจอกสีน้ำตาลอย่างรวดเร็วกระโดดข้ามสุนัขขี้เกียจ

สมบูรณ์แบบแกรมใช้ตัวอักษรทุกครั้งว่า

พิจารณาการเขียนโปรแกรมที่เป็น pangram ที่สมบูรณ์แบบโดยใช้อักขระ ASCII ที่พิมพ์ได้ 95 ตัว (รหัสฐานสิบหก 20 ถึง 7E) เป็นตัวอักษร:

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

โปรแกรมดังกล่าวจะต้องมีอักขระทั้งหมด 95 ตัวโดยที่อักขระ ASCII ที่พิมพ์ได้แต่ละตัวจะเกิดขึ้นหนึ่งครั้ง แต่ในลำดับใด ๆ (มี 95! = 1.03 × 10 ¹⁴⁸ความเป็นไปได้)

งานของคุณคือการเขียนโปรแกรมนี้เพื่อให้จำนวนตัวอักษร ASCII ที่พิมพ์ได้ไปยัง stdout นั้นสูงที่สุดเท่าที่จะเป็นไปได้

คะแนนของคุณคือจำนวนของตัวอักขระ ASCII ผลโปรแกรมของคุณ(คนรวมจำนวนเงินที่ไม่แตกต่างกันจำนวน: AABCคะแนน 4 ในขณะที่ABCคะแนน 3) คะแนนสูงสุดชนะ

รายละเอียด

• ผลลัพธ์อาจมีอักขระใด ๆ (รวมถึงซ้ำกัน) แต่อินสแตนซ์เดียวของอักขระ ASCII ที่พิมพ์ได้ 95 ตัวจะนับรวมอยู่ในคะแนนของคุณ
  • คุณสามารถใช้JSFiddle นี้เพื่อนับจำนวนอักขระ ASCII ที่พิมพ์ได้ในสตริงใด ๆ
• หากภาษาของคุณไม่มี stdout ให้ใช้ทางเลือกที่เหมาะสมที่สุด
• โปรแกรมของคุณ ...
  • ต้องมี runtime จำกัด(การ จำกัด เวลาถูกลบ)
  • ต้องมีเอาต์พุต จำกัด
  • อาจมีความคิดเห็น
  • ต้องรวบรวมและเรียกใช้โดยไม่มีข้อผิดพลาด (ไม่ได้ตรวจสอบ)
  • ต้องไม่แสดงพร้อมต์หรือต้องการอินพุต
  • จะต้องไม่เปลี่ยนแปลงเวลาและกำหนดขึ้น
  • ต้องไม่ใช้ไลบรารีภายนอก
  • ต้องไม่ต้องการการเชื่อมต่อเครือข่าย
  • ต้องไม่ใช้ประโยชน์จากไฟล์ภายนอก
    • (คุณสามารถใช้ไฟล์โปรแกรมเองได้ตราบใดที่การเปลี่ยนชื่อไฟล์ไม่ได้เปลี่ยนพฤติกรรมของโปรแกรม)
• หากงานนี้เป็นไปไม่ได้มีบางภาษาที่แย่เกินไป
• คุณจะต้องให้การส่งออกที่แน่นอนของคุณหรืออย่างแม่นยำอธิบายมันถ้ามันมีขนาดใหญ่เกินไปให้พอดีในโพสต์ คุณไม่จำเป็นต้องเรียกใช้โปรแกรมของคุณ ตราบใดที่มันจะทำงานในจำนวน จำกัด ของเวลาบนคอมพิวเตอร์ที่มีจำนวนมากมายของหน่วยความจำมันถูกต้อง

ตัวอย่าง

โปรแกรม Python 2 แบบง่าย ๆ นี้เป็นทางออกที่เป็นไปได้:

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

มันออก9876543210ซึ่งมี 10 ตัวอักษร ASCII ที่พิมพ์ได้ดังนั้นคะแนน 10

GolfScript มากกว่า 2 ↑↑↑ (9871 ↑↑ 2) ตัวอักษร

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

พิมพ์จำนวนเต็ม ใช้ประโยชน์จากขนาด CPU registerไม่ จำกัด(ซึ่งกำหนดความยาวสตริงสูงสุดใน Ruby) หน่วยความจำและเวลารัน linefeed มีไว้เพื่อการอ่านเท่านั้น

รหัส

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

คะแนน

กำหนดb = 9871 ↑↑ 2 (ดูเครื่องหมายลูกศรขึ้นของ Knuth )

• .? รันf: x ↦ x ↑ x

• ภายในบล็อกรันg: x ↦ฉ^x (x)

  ตั้งแต่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และอื่น ๆ เรามี
  กรัม (x)> x ↑↑ (x + 1)> x ↑↑ x

• ด้านนอกบล็อกรันH: x ↦กรัม^ข (x)

  ตั้งแต่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และอื่น ๆ เรามีh (x)> x ↑↑↑ (B + 1)

• เราเริ่มต้นด้วยจำนวนเต็ม2บนสแต็คดังนั้นโค้ดจะคำนวณh (2)> 2 ↑↑↑ (b + 1)

• คะแนนเป็นจำนวนของตัวเลขทศนิยมของเอช (2)ซึ่งเป็นบันทึก (h (2)) + 1> เข้าสู่ระบบ (2 ↑↑↑ (B + 1))> 2 ↑↑↑ข

ดังนั้นคะแนนมีขนาดใหญ่กว่า2 ↑↑↑ (9871 ↑↑ 2)

2 ↑↑↑ nเติบโตที่ก้าวไร้สาระเป็นnขนาดใหญ่ได้รับ 2 ↑↑↑ 4: = 2 ↑↑ 2 ↑↑ 2 ↑↑ 2 = 2 ↑↑ 2 ↑↑ 4 = 2 ↑↑ 65536ซึ่งเป็นหอพลังเชื่อมโยงทางขวาจำนวน65536สำเนา2 :

ในทำนองเดียวกัน2 ↑↑↑ 5 = 2 ↑↑ (2 ↑↑↑ 4)ซึ่งเป็นหออำนาจของ2 ↑↑↑ 4เล่ม2

ตอนนี้คะแนนไม่ได้เป็น2 ↑↑↑ 4หรือ2 ↑↑↑ 5มันมีขนาดใหญ่กว่า2 ↑↑↑ขที่b> 2 × 10 ³⁹ 428 นั่นเป็นจำนวนมาก ...

Perl, 70 * 18446744073709551615 * 10 ^ 987654320

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

เอาท์พุท:

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

ทำซ้ำ18446744073709551615 * 10 ^ 987654320ครั้ง

$[เป็นค่าเริ่มต้น0เพื่อให้เทียบเท่ากับ~$[18446744073709551615

ในฐานะที่เป็นข้อความด้านข้างฉันมีหน่วยความจำ10^987654320ไม่เพียงพอที่พยายามสร้างหมายเลข

คำตอบเก่า (7703703696):

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

ผลลัพธ์คือ:

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

ทำซ้ำ 98765432 ครั้ง

หมายเหตุ: เรียกใช้ตัวอย่างทั้งหมดด้วย perl -Mbignum -E

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

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

เอาต์พุตจำนวนเต็ม 1 ถึง 9x10 ¹⁵หนึ่งรายการต่อบรรทัด ใช้เวลานาน

ทำไม9E15? ปรากฎว่า GNU seqดูเหมือนจะใช้ 64- บิตลอย (คู่) ภายใน จำนวนเต็มที่มากที่สุดที่เราสามารถเป็นตัวแทนของประเภทนี้ก่อนที่จะเพิ่มขึ้นหนึ่งหยุดทำงานเนื่องจากขาดความแม่นยำคือ 2 ⁵³หรือ 9007199254740992 ที่ใกล้ที่สุดเราจะได้รับสิ่งนี้ด้วยสัญกรณ์ชี้แจงคือ 9E15 หรือ 9000000000000000

ในการคำนวณคะแนนฉันใช้การเพิ่มตัวเลขทั้งหมดด้วยจำนวนหลักที่กำหนดและเพิ่ม 9E15 เนื่องจากมีการขึ้นบรรทัดใหม่ระหว่างแต่ละหมายเลข:

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

ฉันสามารถส่งออกท่อนี้ผ่านodเพื่อเพิ่มขนาดหรือดังนั้น แต่ทำให้การคำนวณคะแนนยากขึ้น

คำตอบการเปลี่ยนแปลงกฎล่วงหน้า:

Bash + coreutils, 18,926,221,380

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

ออก 1 ถึง 1592346780 สำหรับ macbook กลางปี ​​2012 ของฉัน (ซึ่งอยู่ไม่ไกลจากเกณฑ์มาตรฐานที่เชื่อมโยง) มันใช้เวลาประมาณ 9m45s

_{ฉันไม่สามารถต้านทานการเพิ่มประสิทธิภาพได้อีกสักนิดแม้ว่ามันอาจจะไร้ความหมายก็ตาม}

เอาท์พุท:

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

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

GolfScript ≈ 3 * 10 ^ (2 * 10 ^ 7) เช่น≈ 3x10 ^20000000

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

มันทำงานอย่างไร

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

นี่Xคือการนับตัวอักษร (ความยาว) ของการเป็นตัวแทนสตริงของอาร์เรย์[0, 1, 2..,(87^9654321) - 1]ซึ่งจะเป็นเช่น[0 1 2 3 4 ... (87^9654321) - 1]

ฉันพยายามคำนวณXที่นี่เพื่อหาคะแนนของฉัน (87^9654321) - 1ประมาณ10^(10^7.272415829713899)ด้วย18724742ตัวเลขทศนิยม

Xคร่าว3*10^(2*10^7)ดังนั้นX*Xก็เหมือนกันเท่านั้น โปรดทราบว่าค่าเหล่านี้อยู่ด้านล่างที่ต่ำมากเนื่องจากข้อ จำกัด ในการคำนวณของwolframa (แม้)ฉันไม่สามารถคำนวณได้sum (floor(log10(x)) + 1) for x = 1 to (87^9654321 - 1)ซึ่งเป็นค่าที่แท้จริงของX

MATLAB, 95

รหัส

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

เอาท์พุต

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

เอาท์พุทมีอักขระ ASCII ที่ระบุทั้งหมดซึ่งแต่ละครั้งและตามลำดับ

ทับทิม, 89

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

เอาท์พุท:

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

ประกอบด้วยอักขระ ASCII ยกเว้นp, , %, q, และ{}

GolfScript, 93

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

เอาท์พุท:

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

ประกอบด้วยอักขระ ASCII ยกเว้นและ"'

Golfscript - 27 * 2 ^{6543 9870}

นี่เป็นครั้งแรกที่ฉันส่ง Golfscript! :)

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

คำอธิบาย:

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

เอาท์พุทเป็นภาระของรายการของตัวเลข พิจารณารหัสต่อไปนี้:

12,`{.+}1*

ด้วย12,มันผลิตอาร์เรย์ดังต่อไปนี้:

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

backtick {.+}เปลี่ยนที่เป็นสตริงผ่านมันไปยังบล็อก สิ่งนี้จะทำซ้ำสตริงและต่อสองสตริงเข้าด้วยกัน:

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

The 1*บอกให้ล่ามเพื่อดำเนินการบล็อกก่อนหน้าหนึ่งครั้ง (2 ¹ = 2)

ดังนั้นตามที่:

 12,`{.+}n*

ส่งออกเอาต์พุต12,`2 ⁿครั้ง