เห็นได้ชัดว่าการเล่นโค้ดเป็นเรื่องเกี่ยวกับการใช้ประโยชน์จากโค้ดให้น้อยที่สุด ใครสนใจว่าผลผลิตจริงคืออะไร

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

กฎ:

1. เขียนตัวอย่างอิสระสามชุด (ไม่ใช่โปรแกรม / ฟังก์ชั่นเต็มรูปแบบ)

2. ตัวอย่างต้องเป็นภาษาเดียวกัน

3. คะแนนคือจำนวนเอาท์พุทไบต์ทั้งหมด

4. ผลลัพธ์อาจอยู่ในรูปแบบของผลลัพธ์ STDOUT เป็นต้น

5. ตัวอย่างอาจไม่ทำให้เกิดข้อผิดพลาดใด ๆ

6. ตัวอย่างอาจทำให้เกิดรูปแบบที่แตกต่างกันของการส่งออก

7. อักขระบรรทัดใหม่ที่ต่อท้ายจะไม่ถูกนับ

8. ตัวอย่างแรกจะต้องมี 1 ไบต์หรือความยาวขั้นต่ำที่สร้างอย่างน้อย 1 ไบต์ของเอาต์พุต

9. ตัวอย่างที่สองจะต้องยาวกว่าหนึ่งไบต์

10. ตัวอย่างที่สามจะต้องยาวกว่าสองไบต์แรก

gs2, 412 + 5.37 * 10 ⁹⁰² + 10 ^{10 903.1}ไบต์

1. fพุช1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzเป็น412สตริง -byte

2. fôพิมพ์พีชคณิตทั้งหมดของมันดังนั้น412! * 412ตัวละคร

3. fôôพิมพ์การเรียงสับเปลี่ยนทั้งหมดของ 412! -element list ซึ่งแต่ละองค์ประกอบมีความยาว 412 ตัวอักษรดังนั้น412 * (412!)!ไบต์

แก้ไข: เพื่อให้สิ่งต่าง ๆ ในมุมมองนี้เป็นอย่างน้อย

10^{1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

bytes, dwarfing คำตอบอื่น ๆ ทั้งหมดที่นี่จนถึงตอนนี้

Pyth, 26 + 1140850688 + (> 4.37 × 10 ^20201781 )

ฉันไม่รู้ว่าจะสามารถคำนวณความยาวที่แน่นอนของผลลัพธ์สำหรับโปรแกรมที่สามได้หรือไม่ ฉันสามารถให้ขอบเขตเท่านั้น มันจะพิมพ์อะไรบางอย่างระหว่าง4.37 × 10^20201781และ1.25 × 10^20201790ตัวละคร

G
yG
yyG

ภาพพิมพ์นี้:

abcdefghijklmnopqrstuvwxyz
['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']
[[], [''], ['a'], ['b'], ['c'], ..., ['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']]

2^(2^26) ~= 1.09 × 10^20201781คนแรกที่พิมพ์ตัวอักษรที่สองส่วนย่อยทั้งหมดของตัวอักษรและหนึ่งในสามส่วนย่อยของส่วนย่อยของตัวอักษรซึ่งเป็นรายการยาวที่

เห็นได้ชัดว่าไม่มีคอมพิวเตอร์เครื่องใดที่จะสามารถคำนวณรายการขนาดใหญ่และส่งออกได้

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 ไบต์ของเอาต์พุต

สำหรับการเปรียบเทียบง่ายขึ้นนี้จะอยู่ที่ประมาณ 7.3 * 10 19

P
PP
Ke!

พิมพ์:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

ทีนี้อันสุดท้ายประกอบด้วยการเรียงสับเปลี่ยนทั้งหมดของ[0 1 2 ... 19]ตัวเลขที่ถูกบีบเข้าด้วยกัน ฉันจะไม่แนะนำให้ลองใช้ ... (ลองเป็น4e!เพื่อให้ได้รสชาติ)

ทดสอบได้ที่นี่: 1 โครงการ , โครงการที่ 2 , รุ่น Sane ของโปรแกรม 3

เยลลี่ , เอาต์พุต1.2 × 10 ²⁵⁶⁸ไบต์

ȷ
ȷ*
ȷ*!

คำนวณ1000 , 1000 ¹⁰⁰⁰และ1000 ^1000! .

ลองใช้ออนไลน์: โปรแกรมแรก | โปรแกรมที่สอง | โปรแกรมที่สาม (แก้ไขแล้ว)

สำหรับจุดประสงค์ในการนับไบต์ȷสามารถเข้ารหัสเป็นไบต์ 0xa0 ในJelly เวอร์ชันปัจจุบันได้

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

ในเจลลี่ȷสามารถใช้ภายในตัวอักษรตัวเลขเป็น Python e(สัญลักษณ์ทางวิทยาศาสตร์) ตัวอย่างเช่น3ȷ4ผลตอบแทนที่30000 ในทางวิทยาศาสตร์วุ้นของค่าเริ่มต้นค่าสัมประสิทธิ์การ1และค่าเริ่มต้นยกกำลังไป3ดังนั้นȷ, 1ȷ3และ1000ทั้งหมดกลับจำนวนเดียวกัน

ȷ      Return 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
 *     Hook; compute 1000 ** 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
  !    Return 1000!.
 *     Fork; compute 1000 ** 1000!.

Hexagony , 1 + 3 + 6 = 10 ไบต์ของเอาต์พุต

ดี ... ไม่ใช่คะแนนที่น่าประทับใจ แต่อย่างน้อยฉันก็สามารถยืนยันได้ว่ามันเหมาะสมที่สุด ด้วยไบต์เดียวมันเป็นไปไม่ได้ที่จะพิมพ์บางอย่างและยกเลิกดังนั้นเราจึงเริ่มด้วยสองไบต์:

!@

รหัสที่กางออกคือ

 ! @
. . .
 . .

สิ่งนี้พิมพ์ไบต์และยกเลิก

สำหรับรหัสสามไบต์เราสามารถพิมพ์ผลลัพธ์สามไบต์ ตัวอย่างเช่น

o!@

หรือคลี่:

 o !
@ . .
 . .

111พิมพ์ อักษรตัวพิมพ์เล็กใด ๆ จากdเพื่อzทำงานและพิมพ์รหัสอักขระ วิธีเหล่านี้เป็นเพียง 23 วิธีในการพิมพ์ 3 ไบต์ด้วยรหัส 3 ไบต์

ในที่สุดสำหรับสี่ไบต์มี 169 วิธีในการพิมพ์ 6 ไบต์ เนื่องจากไม่มีพวกเขาทำอะไรที่น่าสนใจมากขึ้น (ยกเว้นการควบคุมการไหลคี่) กว่าการแก้ปัญหาตรงไปข้างหน้าฉันจะนำเสนอที่:

o!!@

กางออก:

 o !
! @ .
 . .

คุณเดามัน มันพิมพ์111111มันพิมพ์

ฉันจะรู้ได้อย่างไรว่าสิ่งเหล่านี้ดีที่สุด? ฉันปรับตัวฟรุ๊ตฟอร์เดอร์ที่ฉันเขียนสำหรับแคตตาล็อกเครื่องความจริงเพื่อหาผลลัพธ์ที่แน่นอนสูงสุดใน 7000 รอบ (ฉันไม่คิดว่าคุณสามารถเขียนบีเวอร์ยุ่งกับ 4 ไบต์ที่ทำงาน 7000 รอบ แต่ยังคงสิ้นสุดในภายหลัง)

อย่างจริงจัง 2025409 ไบต์

1 ไบต์:

N

(สร้างเอาต์พุต 11,756 ไบต์)

2 ไบต์:

Nñ

สร้างเอาต์พุต 153,717 ไบต์

3 ไบต์:

9!!

สร้างเอาต์พุต 1,859,936 ไบต์

อย่างจริงจังยังไม่ได้ทำสิ่งต่าง ๆ เช่น "ชุดย่อยทั้งหมด" หรือ "ชุดค่าผสมทั้งหมด" ดังนั้นคะแนนจึงค่อนข้างต่ำ

Python 3, 1 + 22 + 23 = 56

9
id
abs

เอาท์พุต

9
<built-in function id>
<built-in function abs>

พิมพ์ 9 แล้วคำนิยามสำหรับและidabs

เขาวงกต 1 + 2 + 4 = 7 ไบต์

อีกคะแนนต่ำซึ่งฉันส่วนใหญ่โพสต์เพราะฉันได้พิสูจน์แล้วว่ามันเป็นที่ดีที่สุดสำหรับภาษา

เช่นเดียวกับ Hexagony เขาวงกตไม่สามารถพิมพ์และยุติด้วยไบต์เดียวดังนั้นเราเริ่มต้นด้วยสองไบต์:

!@

พิมพ์ศูนย์และยุติ

สำหรับสามไบต์เราไม่สามารถเอาชนะโซลูชันที่ไร้เดียงสาได้:

!!@

พิมพ์สองไบต์ก่อนที่จะยกเลิก มีตัวเลือกอื่น ๆ ไม่กี่เช่นการพิมพ์-1ด้วย(!@หรือหรือ~!@ ,!@มีวิธีแก้ปัญหาสวย ๆ อย่างหนึ่งซึ่งใช้การหมุนซอร์สโค้ด:

!>@

@!>พิมพ์นี้เป็นศูนย์แล้วกะแหล่งที่จะกลายเป็น เมื่อถึงจุดนั้นมันจะถึงจุดจบตายหันกลับมาและดำเนินการ!อีกครั้งทางกลับก่อนที่จะยุติ

สำหรับสี่ไบต์มันสนุกกว่านี้อีกเล็กน้อยเพราะวิธีเดียวในการพิมพ์ 4 ตัวอักษรคือใช้เคล็ดลับด้านบน:

!!>@

พิมพ์สองศูนย์เปลี่ยนไป@!!>พิมพ์อีกสองศูนย์

ในทุกกรณีฉันไม่สนใจว่าคุณสามารถพิมพ์ไบต์ด้วย\หรือ.เพราะมันจะพิมพ์หนึ่งไบต์เสมอในขณะที่!จะพิมพ์อย่างน้อยหนึ่งและอาจหลาย

Bash, 1726 ไบต์

(ฉันได้รับการแก้ไขในขณะนี้โปรดพิจารณา upvoting)

1 ไบต์ :"

ขาออก:

>

307 ไบต์: id

ขาออก:

uid=501(geokavel) gid=20(staff) groups=20(staff),701(com.apple.sharepoint.group.1),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),33(_appstore),100(_lpoperator),204(_developer),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)

1418 ไบต์: zip (พิมพ์ไปยัง STDOUT)

ลิขสิทธิ์ (c) 1990-2008 Info-ZIP - ประเภท 'zip "-L"' สำหรับลิขสิทธิ์ซอฟต์แวร์
Zip 3.0 (5 กรกฎาคม 2008) การใช้งาน:
zip [-options] [-b path] [-t mmddyyyy] [-n คำต่อท้าย] [รายการ zipfile] [รายการ -xi]
  การกระทำเริ่มต้นคือการเพิ่มหรือแทนที่รายการ zipfile จากซึ่ง
  สามารถรวมชื่อพิเศษ - เพื่อบีบอัดอินพุตมาตรฐาน
  หากไม่ระบุ zipfile และรายการ zip จะบีบอัด stdin เป็น stdout
  -f freshen: ไฟล์ที่เปลี่ยนแปลงเท่านั้น -u update: ไฟล์ที่เปลี่ยนแปลงเท่านั้นหรือไฟล์ใหม่
  -d ลบรายการใน zipfile -m ย้ายไปที่ zipfile (ลบไฟล์ OS)
  -r recurse เข้าสู่ไดเรกทอรี -j ชื่อไดเรกทอรีขยะ (ไม่บันทึก)
  -0 store เท่านั้น -l แปลง LF เป็น CR LF (-ll CR LF เป็น LF)
  บีบอัดได้เร็วขึ้น -1 บีบอัดได้ดีกว่า -9
  -q การทำงานที่เงียบ -V การดำเนินการ verbose / ข้อมูลรุ่นพิมพ์
  -c เพิ่มความคิดเห็นหนึ่งบรรทัด -z เพิ่มความคิดเห็น zipfile
  - @ อ่านชื่อจาก stdin -o สร้างไฟล์ zip เป็นรายการเก่าที่สุด
  -x ไม่รวมชื่อต่อไปนี้ -i รวมเฉพาะชื่อต่อไปนี้
  -F fix zipfile (-FF ลองให้หนักขึ้น) -D ไม่ต้องเพิ่มรายการไดเรกทอรี
  - ปรับคำนำหน้าการแตกไฟล์ด้วยตนเอง exe -J คำนำหน้าไฟล์ zip junk (unzipsfx)
  ความสมบูรณ์ของการทดสอบไฟล์ zip -X eXclude แอตทริบิวต์ไฟล์ eXtra
  - ลิงก์สัญลักษณ์ร้านค้าเป็นลิงค์แทนไฟล์อ้างอิง
  -e เข้ารหัส -n ไม่บีบอัดส่วนต่อท้ายเหล่านี้
  -h2 แสดงความช่วยเหลือเพิ่มเติม

MATL , 313

ใช้เวอร์ชันปัจจุบันของภาษา ( 3.1.0 ) ซึ่งเร็วกว่าความท้าทายนี้

1. รหัส (ตัวอักษรที่กำหนดไว้ล่วงหน้า: สร้างหมายเลข 2 ซึ่งพิมพ์โดยนัย):

   H
   

   เอาท์พุท (1 ไบต์):

   2
   

2. รหัส (สร้าง number pi ซึ่งพิมพ์โดยปริยายด้วย 15 ทศนิยม):

   YP
   

   เอาท์พุท (17 ไบต์):

   3.141592653589793
   

3. รหัส (ตัวเลขตั้งแต่ 1 ถึง 99 ซึ่งจะถูกพิมพ์ตามค่าเริ่มต้นโดยมีช่องว่างอยู่ระหว่าง):

    99:
   

   เอาท์พุท (295 ไบต์):

   1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
   

กำลังประมวลผล 39 ไบต์

กำหนด

1 ไบต์ :

print(X);

เอาท์พุท 0เอาท์พุท

9 ไบต์ :

print(PI);

เอาท์พุท 3.1415927

29 ไบต์ :

print(P3D);

เอาท์พุท processing.opengl.PGraphics3D

แบบไม่กำหนด>> 129 ไบต์

> = 32 ไบต์:

print(g);

เอาท์พุท processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 ไบต์:

print( g);

เอาท์พุท processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 ไบต์: (ขอขอบคุณ @anOKsquirrel สำหรับคำแนะนำนี้)

print(g,g);

เอาท์พุท

processing.awt.PGraphicsJava2D@ + [mem-address]
processing.awt.PGraphicsJava2D@ + [mem-address]

JavaScript, 1 + 3 + 18 = 18 22

ไม่ใช่คำตอบที่น่าสนใจ แต่อาจเป็น JavaScript ที่ดีที่สุด

alert(1)
alert(.1)
alert(1/9)

เพิ่ม 4 คะแนนขอบคุณ@Undefined ฟังก์ชั่น !

เอาท์พุทเป็นข้อความ:

1
0.1
0.1111111111111111

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

ตัวอย่างใด ๆ ที่สั้นกว่าความยาว 2 ไม่สามารถส่งออกหรือไม่สามารถยุติเอาต์พุตได้

ใน Befunge .แสดงผลลัพธ์ค่าสูงสุดของสแต็กเป็นจำนวนเต็มตามด้วยช่องว่าง ช่องว่างไม่ใช่การขึ้นบรรทัดใหม่ดังนั้นจึงรวมอยู่ในการนับ นอกจากนี้สแต็กนั้น "เต็มไปด้วย 0" ดังนั้นโปรแกรมจะแสดงผล (ตามลำดับ):

0 
0 0 
0 0 0 

SmileBASIC, 1 + 4 + 10 = 15 ไบต์

โปรแกรม 1:

วิธีที่สั้นที่สุดในการพิมพ์บางสิ่งด้วยหรือไม่ (PRINT) และอักขระเดี่ยว นี่อาจเป็นตัวเลขหรือชื่อตัวแปรและมันก็ไม่สำคัญเพราะมันมีความยาวเท่ากัน

?1
1

โปรแกรม 2:

ตอนนี้เราสามารถเข้าถึงบางสิ่งเพิ่มเติม นิพจน์ที่ยาวที่สุดซึ่งสามารถทำได้คือหนึ่งในค่าคงที่ #Y, #L หรือ #R ซึ่งมีค่า 128, 256 และ 512 ตามลำดับ อย่างไรก็ตามแทนที่จะเป็นเช่นนั้นฉันใช้เครื่องหมายจุลภาคเพื่อพิมพ์พื้นที่เพิ่มเติม 3 รายการ (ในกรณีนี้)

?1,
1   

โปรแกรม 3:

ด้วย 3 ตัวอักษรคุณสามารถเขียนหมายเลขสัญกรณ์ E:

?1E9
1000000000

HQ9 +, 71304

9

พิมพ์เนื้อเพลง 11,884 ตัวของ "เบียร์ 99 ขวด"

99

พิมพ์ "เบียร์ 99 ขวด" สองครั้ง

999

พิมพ์ "เบียร์ 99 ขวด" สามครั้ง

Japt -Q, ขา1.0123378918474279e+150ไบต์

จำนวนเต็มคือ

1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,568

ไบต์

# 1

M

เอาท์พุท

{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}

สำหรับ 67 ไบต์ (มอบเครดิตให้ปุย)

# 2

LÆ

เอาท์พุท

[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]

ซึ่งคือ 501 ไบต์

(เครดิตถึง @Shaggy)

# 3

;Eá

เอาต์พุตการเรียงสับเปลี่ยนทั้งหมดของอักขระ ASCII 95 ที่สามารถพิมพ์ได้ในรูปแบบ["...","...","..."...]ซึ่งคือ

$1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,001$ ไบต์ของผลผลิต

คุณสามารถรับเอาต์พุตจำนวนไม่ จำกัด ไบต์หากคุณใช้-Fแฟล็กใน Japt มันทำอะไรถ้านิพจน์สุดท้ายของโปรแกรมประเมินว่าเป็นเท็จมันจะส่งออกค่าที่ระบุในแฟล็กแทน ดังนั้นฉันเดาว่าคะแนนของ Japt -F"Insert Super Long String Here"จะไม่สิ้นสุด

Malbolge , 1 + 2 + 3 = 6 ไบต์

(=aN
(&a`M
(=a`_L

ลองมันออนไลน์: ครั้งแรก , สอง ,สาม

ขาออก:

r
ll
xxx

เดรัจฉานถูกบังคับ ถือว่า\0ไม่ใช่อักขระเอาต์พุตที่ถูกต้อง

ด้วย\0:

cP
cbO
cbaN

ขาออก:

\0
\0\0
\0\0\0

scg , 1 + 27 + 188 = 216

คนแรก:

1

เพียงพิมพ์ 1 เนื่องจากสแต็กจะถูกเอาต์พุตเมื่อสิ้นสุดโปรแกรม

ประการที่สอง:

.d

พิมพ์ข้อมูลการดีบักซึ่งควรมีลักษณะเช่นนี้:

Stack: []
Array Markers: []

ที่สาม:

99r

เพิ่ม 99 ให้กับสแต็กจากนั้นใช้ฟังก์ชันช่วง เอาท์พุท 01234567891011 .... (นี่เป็นหนึ่งครั้งที่ฉันหวังว่าฉันจะใช้ฟังก์ชั่นแฟกทอเรียลฉันยังไม่ได้)

Marbelous 1 + 1 + 2 = 4 ไบต์ของเอาต์พุต

Marbelous อยู่ที่นี่ด้วยการแนะนำสองไบต์ ความคิดเห็นที่ไม่มีประโยชน์หรือช่องว่างที่ไม่จำเป็นเป็นวิธีเดียวที่จะได้รับจำนวนไบต์คี่

พิมพ์ "A" และยุติ:

`A

พิมพ์ "B" และยุติด้วยความคิดเห็น EOL ที่ว่างเปล่า

`B#

พิมพ์ "CD" และยกเลิก:

`C`D

Mathematica, 6 + 461 + 763 = 1230 1225 618 163ไบต์ของเอาต์พุต

%  (* -> Out[0] *)

?D  (* ->

D[f, x] gives the partial derivative ∂ f/∂ x. 
                                              n        n
D[f, {x, n}] gives the multiple derivative ∂  f/∂ x . 
D[f, x, y, …] differentiates f successively with respect to x, y, ….
D[f, {{x , x , …}}] for a scalar f
        1   2
     gives the vector derivative (∂ f/∂ x , ∂ f/∂ x , …). 
                                             1             2
D[f, {array}] gives a tensor derivative.

*)

?Do (* ->

Do[expr, {i   }] evaluates expr i    times. 
           max                   max
Do[expr, {i, i   }] evaluates expr with the variable i successively taking on the values 1 through i    (in steps of 1). 
              max                                                                                   max
Do[expr, {i, i   , i   }] starts with i = i   . 
              min   max                    min
Do[expr, {i, i   , i   , di}] uses steps di. 
              min   max
Do[expr, {i, {i , i , …}}] uses the successive values i , i , ….
               1   2                                     1   2
Do[expr, {i, i   , i   }, {j, j   , j   }, …] evaluates expr looping over different values of j, etc. for each i. 
              min   max        min   max

*)

ปัจจุบันทั้งสองใช้Informationเพื่อรับเอกสารเกี่ยวกับสัญลักษณ์ซึ่งสามารถส่งออกจำนวนมากไบต์ หมายเหตุที่ว่านี้ก็วิ่งบน 10.1 MathKernelบรรทัดคำสั่ง

Javascript, 72 ไบต์

สิ่งนี้ใช้ได้ในตัวแปลบรรทัดคำสั่ง Javascript ของMozilla JSShell

1 ไบต์: 1

เอาท์พุท 1

35 ไบต์: gc

เอาท์พุท

function gc() {
    [native code]
}

36 ไบต์: run

เอาท์พุท

function run() {
    [native code]
}

อ็อกเทฟ 2818417 ไบต์

e

14 ไบต์สำหรับ ans = 2.7183\n

pi

14 ไบต์สำหรับ ans = 3.1416\n

doc

แสดงเอกสารทั้งหมด 2818389 ไบต์นับด้วยdd ลองออนไลน์! เพราะevalcไม่ได้ทำงาน

SmileBASIC 4, 1 + 13 + 15 = 29 ไบต์

นี่จะคล้ายกับคำตอบ SmileBASIC 3 ของ 12Me21 โดยมีการปรับแต่งสองสามอย่าง

1

ก่อนหน้านี้จำนวนโค้ดที่สั้นที่สุดในการสร้างเอาต์พุตบางตัวคือ 2 ไบต์: ?( PRINT) และนิพจน์ไบต์เดียว ฉันทามติคือการที่PRINTไม่ได้ผลิตขึ้นบรรทัดใหม่เมื่อมันก้าวหน้าไปยังบรรทัดถัดเนื่องจากวิธีการทำงานของหน้าจอข้อความ ดังนั้นผลลัพธ์ในหนึ่งไบต์ของเอาท์พุท

?1
1

2

ด้วย 3 ไบต์เราสามารถทำสิ่งที่แตกต่าง SB4 แนะนำให้ใช้INSPECTนามแฝงว่า??จะพิมพ์ข้อมูลเกี่ยวกับค่าเดียว ตัวอย่างเช่นถ้าเราให้สตริงว่างเปล่าสิ่งนี้สามารถสร้างผลผลิตมากกว่า SB3 ได้ นี่ทำให้เรามี 13 ไบต์

??"
STRING: (0)""

3

เรามี 4 ไบต์เพื่อทำงานด้วยดังนั้นเราต้องตัดสินใจว่าเราควรทำอย่างไรเพื่อให้ได้ผลลัพธ์สูงสุด การไปด้วย??เป็นเดิมพันที่ปลอดภัย เรามี 2 ไบต์เท่านั้นที่จะใช้ในการแสดงออกของเรา แต่ผลลัพธ์เพิ่มเติมของINSPECTฟรีโดยทั่วไป ดังนั้นฉันจะใช้มันเพื่อพิมพ์สตริงฉลาก นี่คือ 15 ไบต์

??@A
STRING: (2)"@A"

รวมเป็น 29 ไบต์

Microscript II, 23 + 47 + 71 = 141 bytes

1: C

การทำให้เป็นสตริงของการต่อเนื่องไม่ได้ถูกกำหนดโดยสเป็คอย่างเคร่งครัด แต่ในการดำเนินการอ้างอิงนี้ให้รันด้วยตัวเองทำให้ได้สตริง 23 ไบต์

<Continuation @t=\d\d\dus>( \dแทนตัวเลขซึ่งตัวเลขแตกต่างกันไป)

อย่างน้อยในคอมพิวเตอร์ของฉันอันที่จริงแล้วใช้เวลาประมาณ 180 ถึง 400 ไมโครวินาทีในการทำงาน

การใช้งานครั้งแรกที่ฉันเคยมีจริงสำหรับคำแนะนำนี้

2: CP

47 ไบต์ของเอาท์พุท - เอาท์พุทจากคนแรกสองครั้งด้วยขึ้นบรรทัดใหม่ในระหว่าง

3: CPP

ค่อนข้างตรงไปตรงมา 71 ไบต์ของเอาต์พุต - เอาต์พุตจากหนึ่งแรกสามครั้งโดยมีบรรทัดใหม่ในระหว่าง

PowerShell ~ 4300 ไบต์

ความยาวเอาต์พุตโดยประมาณให้ระบบที่รันอยู่ ตัวอย่างด้านล่างทั้งหมดจะถูกกำหนดไว้ซึ่งหากได้รับสถานะเริ่มต้นที่เหมือนกันของคอมพิวเตอร์จะส่งออกข้อความเดียวกันเพียงว่าในทางปฏิบัติผลลัพธ์ที่สามารถเปลี่ยนจากการดำเนินการเพื่อการดำเนินการ

ความยาว 1, 107 ไบต์

?

Where-Objectนี่คือนามแฝงสำหรับ มันจะแสดงผลให้ผู้ใช้ถามเพื่อขอข้อมูลเพิ่มเติม:

cmdlet Where-Object at command pipeline position 1
Supply values for the following parameters:
Property: 

ความยาว 2, 113 ไบต์

rp

Remove-ItemPropertyนี่คือนามแฝงสำหรับ มันจะแสดงผลให้ผู้ใช้ถามเพื่อขอข้อมูลเพิ่มเติม:

cmdlet Remove-ItemProperty at command pipeline position 1
Supply values for the following parameters:
Path[0]: 

เพิ่งจะมีความยาวไม่เกิน 1 ตัวอย่าง

ความยาว 3, ~ 4100 ไบต์

gps

นี่คือนามแฝงGet-Processที่จะส่งออกตารางที่จัดรูปแบบของกระบวนการที่กำลังทำงานอยู่ทั้งหมดในระบบ:

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                                                          
-------  ------    -----      ----- -----   ------     -- -----------                                                                                
     85       8     1232       4452    46     0.14    544 armsvc                                                                                               
    151      10     6800       9888    39     0.58   5116 audiodg                                                                                              
    480      25     6060      17200   124     0.84   4536 AuthManSvr            
...

Javascript, 312 + 318 + 624 = 1254 ไบต์ของเอาต์พุต

$
$$
$+$

ทั้งสองฟังก์ชั่น$และ$$พร้อมใช้งานในคอนโซลหลักของเบราว์เซอร์ทั้งหมดเป็นทางลัดdocument.querySelectorและdocument.querySelectorAllตามลำดับ เบราว์เซอร์ที่แตกต่างกันมีรหัสเนทีฟที่บังคับใช้กับสตริงที่ค่อนข้างแตกต่างจากกันและ IE ใช้ JS ธรรมดาในแต่ละฟังก์ชั่น

สำหรับการนับจำนวนไบต์ฉันใช้ความยาวของการแทนค่าสตริงของแต่ละรายการแทนการแสดงผลคอนโซลที่ปรับเปลี่ยนบางครั้งดังนั้นจำนวนไบต์ทั้งหมดจึงเป็นของเบราว์เซอร์แต่ละตัวต่อไปนี้:

• Chrome: 56 + 57 + 112 = 225 ไบต์
• IE: 312 + 318 + 624 = 1254
• Firefox: 33 + 33 + 66 = 132

(ฉันกำลังพิจารณาผลลัพธ์ IE ให้นับว่า "เป็นทางการ" เพราะยาวที่สุด)

สำหรับสภาวะแวดล้อมที่ไม่ใช่คอนโซลของเบราว์เซอร์เอาต์พุตที่ใหญ่ที่สุดมาจากสิ่งต่อไปนี้

1
!1 // Or '{}' if being fed to a function instead of beginning a statement
Map

ความยาวผลลัพธ์โดยเบราว์เซอร์:

• Chrome: 1 + 5 (หรือ 15 ถ้า {}ใช้งานได้) + 32 = 38 (หรือ 48) ไบต์
• IE: 1 + 5 (หรือ 15 ถ้า{}ใช้งานได้) + 38 = 44 (หรือ 54)
• Firefox: 1 + 5 (หรือ 15 ถ้า{}ใช้งานได้) + 36 = 42 (หรือ 52)

ชุดอินพุตทั้งสองชุดนี้ให้ผลผลิตมากที่สุดเท่าที่จะเป็นไปได้ในเบราว์เซอร์และคอนโซลทั้งหมด เพื่อพิสูจน์สิ่งนี้ลองตรวจสอบทางเลือกทั้งหมด:

• ตัวแปรที่มีอยู่: เราสามารถค้นหาตัวแปรเนทีฟทั้งหมดที่มีสูงสุดสามตัวอักษรObject.getOwnPropertyNames(window).filter(x=>x.length<=3)และจากนั้นmapไปยังเอาต์พุตสตริงเพื่อกำหนดค่าที่ใหญ่กว่า (โปรดทราบว่าในบางเบราว์เซอร์เช่น Firefox ตัวแปรคอนโซลพิเศษบางอย่างไม่สามารถเข้าถึงได้ด้วยวิธีนี้เนื่องจากไม่ใช่คุณสมบัติของหน้าต่าง)
• JS มีจำนวนตัวอักษรที่ จำกัด ที่สามารถสร้างได้ด้วยตัวละครน้อย:
  • ตามข้อมูลจำเพาะตัวเลขทศนิยมจะต้องเป็นตัวเลขทศนิยม ( 1234567890) ตามด้วยตัวเลือก.และตัวเลขทศนิยมมากขึ้นและ / หรือส่วนที่เป็นเลขชี้กำลังหรือ.ตามด้วยตัวเลขทศนิยมหนึ่งหรือมากกว่าและเป็นส่วนหนึ่งที่เป็นทางเลือก ชนิดอื่น ๆ ของตัวเลขที่จะต้องเป็นอย่างใดอย่างหนึ่ง0o, 0xหรือ0b(หรือรูปแบบตัวพิมพ์ใหญ่) ตามด้วยหนึ่งหรือมากกว่าตัวเลข เพื่อจุดประสงค์ของเราเราสามารถสรุปได้ดังต่อไปนี้:
    • มีตัวเลขตัวเดียวเพียงสิบตัวเท่านั้นซึ่งเป็นจำนวนเต็ม 0 ถึง 9 ตัวเลขตัวอักษรสองตัวเท่านั้นคือจำนวนเต็ม 0-99 (0-9 โดยการเพิ่มทศนิยมหลังจาก) และตัวเลข 0.1 ถึง 0.9 โดยไม่ใส่ค่าเริ่มต้นของศูนย์ . ตัวเลขสามตัวเท่านั้นคือ 0-999 ซึ่งรวมถึง 0x0-0xf, 0o0-0o7, ​​0b0 และ 0b1, เลขชี้กำลัง 1e1 ถึง 9e9 (10 ตัวอักษร) และตัวเลข 0.1-9.9 และ. 01 ถึง. 99 แม้ว่าจะไม่ใช่ตัวเลขตามตัวอักษรในทางเทคนิค NaN ยังสามารถอ้างอิงได้เป็นอักขระสามตัว
  • สตริง, อาร์เรย์และ regexps ซึ่งแต่ละไฟล์สามารถมีอักขระได้สูงสุดตัวเดียวเท่านั้น อาเรย์อาจจะเต็มไปด้วย$จุลภาคหรือตัวเลขหลักเดียว อาร์เรย์ที่มีองค์ประกอบเดียวเท่านั้นที่จะถูกบังคับให้ใช้สตริงเป็นองค์ประกอบเอง อาร์เรย์ที่ว่างเปล่ากลายเป็นสตริงว่าง
  • ขึ้นอยู่กับสภาพแวดล้อมมันอาจเป็นไปได้หรือไม่อาจสร้างวัตถุง่าย ๆ ที่มีตัวอักษรสามตัว โดยปกติ{}คนเดียวที่จุดเริ่มต้นของสคริปต์จะถือว่าเป็นสิ่งที่แนบมามากกว่าการสร้างวัตถุ eval({})คืนค่าไม่ได้กำหนดeval({$})ส่งกลับ$ฟังก์ชัน มีตัวละครไม่เพียงพอที่จะล้อมรอบอยู่ใน{}()
• ไม่มีคำหลักที่สั้นพอที่จะใช้ คำหลักif, in, do, new, for, try, varและletทุกคนจะต้องมีอย่างน้อยสองตัวละครอื่น ๆ ในการใช้งานเกินขีด จำกัด
• ผู้ประกอบการที่มีจำหน่าย ได้แก่ เอก~, +, -, !, และ++ --ผู้ประกอบการทั้งสองตัวละครเท่านั้นที่สามารถใช้กับตัวแปรตัวเดียวซึ่งมีเพียงหนึ่ง ( $) NaNซึ่งอัตราผลตอบแทน ตัวดำเนินการอีกสี่ตัวสามารถใช้กับค่าหนึ่งหรือสองอักขระซึ่งมี:
  • ตัวแปรหลายตัว (ในบางคอนโซล$, $_, $0, $1, $2, $3, $4, $, $$, $x) เมื่อนำมาใช้กับผู้ประกอบการเหล่านี้ผลที่ได้จะถูก จำกัด ให้-1, true, และfalseNaN
  • หมายเลข 109 ผล: นัมเบอร์ -100 ผ่าน 99, -0.9 -0.1 trueผ่าน, false,
  • สตริงว่าง ผล: -1, 0( -0กลายเป็น0บน truetoString)
  • ผลลัพธ์ของค่าหนึ่งอักขระใด ๆ ข้างต้นที่เกี่ยวข้องกับตัวดำเนินการ unary หนึ่งตัว ผลลัพธ์ใหม่: ไม่มี
• ผู้ประกอบการไบนารีใช้สอย (ซึ่งจะต้องเป็นตัวเดียวที่จะมีห้องที่เหลือสำหรับทั้งตัวถูกดำเนินการ) เป็น+, -, *, /, %, <, >, &, ,| ^สามารถใช้กับค่าอักขระเดี่ยวในแต่ละด้านเท่านั้น ตัวเลือกสำหรับค่า ได้แก่$และจำนวนเต็ม 0-9 ผลของการรวมกันทั้งหมดของเหล่านี้รวมถึงInfinityตัวเลขบางอย่างและค่าไบนารีกล่าวข้างต้นและเศษส่วนจำนวนมากที่มีการบังคับให้สาย 19 ตัวอักษรหรือน้อยกว่า ( 1/719 ตัวอักษรที่แตกต่างจาก1/9ที่แนะนำข้างต้นซึ่งเป็นเพียง 18) และการแสดงข้อความ$นำหน้าหรือ ตามด้วยจำนวนเต็มหลักเดียวหรือตัวมันเอง
• สุดท้ายตัวดำเนินการและนิพจน์ที่เหลือทั้งหมด: ตัวดำเนินการสมาชิก.ต้องการตัวแปรที่มีอยู่และตัวระบุที่อ้างอิงถึงคุณสมบัติ undefinedการใช้งานทั้งหมดนี้ส่งผลให้ที่นี่ รอบค่าในผลตอบแทนที่คุ้มค่าในขณะที่ไม่กำหนดด้วย( ) =การใช้()หรือ `` เพื่อเรียกค่าเป็นฟังก์ชั่นส่งผลให้ไม่ได้กำหนดหรือข้อผิดพลาดกับค่าที่มีอยู่ทั้งหมด

เมื่อรวมทั้งหมดนี้แล้วจะมีเอาต์พุตทั้งหมด 1651 รายการที่เป็นไปได้เมื่อใช้คอนโซล Chrome ผลที่ยาวที่สุดสำหรับหนึ่งสองและสามตัวละครจาก$, $$และ$+$ตามลำดับ

dc , 2 + 5 + 18 = 25 ไบต์

1: Ffผลตอบแทน ( ลองออนไลน์! ):

15

2: Fdfผลตอบแทน ( ลองออนไลน์! ):

15
15

3: Fd^fผลตอบแทน ( ลองออนไลน์! )

437893890380859375

ไม่มีสิ่งใดที่น่าสนใจเป็นพิเศษ แต่dcก็ไม่ได้ยอดเยี่ยมสำหรับการกระจายกอง ฉันชอบที่แต่ละคำตอบสร้างขึ้นก่อนหน้านี้ อย่างไรก็ตามFเป็นเพียงหมายเลข 15 fพิมพ์สแต็กทั้งหมด dแสดงซ้ำด้านบนสุดของสแต็ก ^ยกถัดจากด้านบนของสแต็คเป็นพลังของด้านบนของสแต็ค (ในกรณีนี้คือ 15 ^ 15) ฉันไม่เชื่อว่าสิ่งนี้สามารถเติมdcเงินได้

Ruby, 3 + 14 + 28 = 45 ไบต์

ทำไมฉันถึงทำอย่างนี้

p

nilพิมพ์

$>

#<IO:<STDOUT>>พิมพ์

dup

#<Object:0x0000000003610988>พิมพ์สิ่งที่ตามสายของ

irb

เรียกใช้อินสแตนซ์ของ Interactive Ruby เมื่อออกจากวัตถุที่ส่งคืนคือ#<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>>121 แต่เนื่องจากคุณต้องการให้กด^Dหรือบางสิ่งบางอย่างเพื่อออกจากอินสแตนซ์ irb ฉันไม่แน่ใจว่ามันจะนับเป็นทางออกใน "3 ไบต์" หรือไม่ จริงๆแล้วรวมไว้ในคะแนนเว้นแต่จะได้รับตกลง

Perl 6, 53 (17 + 18 + 18) ไบต์

e
-e
e*e

1. e เอาท์พุท $e$ ถึง 15 ตำแหน่งทศนิยม
2. -e เอาท์พุท $-e$ ถึง 15 ตำแหน่งทศนิยม
3. e*e เอาท์พุท $e^2$แต่แปลก ๆ มันให้ทศนิยมมากกว่าหนึ่งอัน

Runic Enchantments เอาต์พุต 4,000,000 ไบต์

โปรแกรมแรกคือ:

a@

ใช้ 2 ไบต์ถึง: ดันค่าไปที่สแต็กพิมพ์ค่าจากสแต็กและสิ้นสุด ในกรณีนี้มันจะพิมพ์10(แม้ว่าค่าจำนวนเต็มใด ๆ จาก 0 ถึง 16 ก็ใช้ได้เช่นกัน)

สำหรับ 3 ไบต์:

aY@

พิมพ์10000อีกครั้งaอาจรวม 1 ถึง 16 (เพื่อสร้างเอาต์พุตมากกว่าโปรแกรมดั้งเดิม 0 อาจใช้ได้ภายใต้ตัวดำเนินการอื่น) และไม่มีตัวดำเนินการจำนวนมากที่รับอินพุตเดี่ยวและสร้างเอาต์พุตใด ๆ การส่งออกอีกต่อไปน้อยมาก XCYZ:Eเป็นตัวเลือกที่แท้จริงเท่านั้น aY@เป็นเพียงหนึ่งที่ผลในที่สุดเอาท์พุท

P$!;

ตามข้อกำหนดของภาษาสิ่งนี้จะทำงานอย่างไม่มีที่สิ้นสุด อย่างไรก็ตามเนื่องจากล่ามมีขีด จำกัด สูงสุดในการดำเนินการ "ตกลงเพียงพอ" นี่เป็นเอาต์พุตที่ทำได้มากที่สุดใน 4 อักขระ (และ TIO ตัดการดำเนินการหลังจาก ~ 130,000 ไบต์เกิน 128kib) และเป็นล่ามกำหนดภาษานี้ โรงงาน และในขณะที่ฉันได้ยกระดับเกณฑ์นั้นก่อนหน้านี้ (จาก 10k ก้าวเป็น 1 ล้าน) ฉันไม่ได้วางแผนที่จะยุ่งกับมันเร็ว ๆ นี้

ใหญ่?

หากฉันเรียกสมมติฐานสามข้อที่ฉันทำที่นี่มาแน่นอน

`AA@

ซึ่งใช้งานได้Ack(65,Ack(65,64))ดีซึ่งไม่ได้มีค่ามากนักสำหรับการเข้าไปในฟังก์ชัน Ackerman ในตอนแรก - เล็กกว่า 255 ในโพสต์เก่า แต่แน่นอนว่าเราสามารถโทร Ack สองครั้งใน 4 คำแนะนำ

และพระเจ้าองค์เดียวเท่านั้นที่รู้สิ่งที่จะพิมพ์

_{หมายเหตุ: Aคำสั่งนั้นถูกสร้างขึ้นมาจากMathคำสั่งเมตาซึ่งใช้ 3 วัตถุบนสแต็ก: ตัวอักษรสำหรับคำสั่งที่จะทำและจากนั้นสองอินพุต, x และ y ในฐานะที่เป็นโปรแกรมดังกล่าวนี้ไม่ได้จริงทำอะไรทั้งสองเพราะค่าAมิได้@แมปกับฟังก์ชั่นทางคณิตศาสตร์และเนื่องจากสองสายผลที่ตามมาใน underflow สแต็ค}