Rõ ràng, chơi golf mã là tất cả về việc tận dụng tối đa mã ít nhất. Ai thực sự quan tâm sản lượng thực tế là gì?

Mặc dù chúng tôi đã có một thách thức đối với tỷ lệ đầu vào / đầu ra cao nhất , đây là lời kêu gọi hầu hết đầu ra hữu hạn và xác định với độ dài mã đã cho. Trớ trêu thay, thử thách này sau đó không phải là môn đánh gôn .

Quy tắc:

1. Viết ba đoạn độc lập (không phải chương trình / chức năng đầy đủ).

2. Các đoạn phải ở cùng một ngôn ngữ.

3. Điểm là tổng số byte xuất ra.

4. Đầu ra có thể ở dạng kết quả, STDOUT, v.v.

5. Các đoạn có thể không gây ra bất kỳ lỗi.

6. Các đoạn có thể gây ra các hình thức đầu ra khác nhau.

7. Trailing ký tự dòng mới không được tính.

8. Đoạn mã đầu tiên phải là 1 byte hoặc độ dài tối thiểu tạo ra ít nhất 1 byte đầu ra.

9. Đoạn mã thứ hai phải dài hơn một byte.

10. Đoạn mã thứ ba phải dài hơn hai byte so với đoạn đầu tiên.

gs2, 412 + 5,37 * 10 ⁹⁰² + 10 ^{10 903.1} byte

1. fđẩy 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzznhư một 412chuỗi -byte.

2. fôin tất cả các hoán vị của nó, vì vậy các 412! * 412ký tự.

3. fôôin tất cả các hoán vị của danh sách 412! đó, trong đó mỗi phần tử dài 412 ký tự, do đó, 412 * (412!)!byte.

EDIT: Để đặt mọi thứ vào quan điểm, điều này ít nhất là

10^{10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

byte, lùn tất cả các câu trả lời khác ở đây cho đến nay.

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

Tôi không biết liệu có thể tính được độ dài chính xác của đầu ra cho chương trình thứ ba không. Tôi chỉ có thể đưa ra ranh giới. Nó sẽ in một cái gì đó giữa 4.37 × 10^20201781và các 1.25 × 10^20201790ký tự.

G
yG
yyG

Bản in này:

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

Cái đầu tiên in bảng chữ cái, cái thứ hai tất cả các tập hợp con của bảng chữ cái và cái thứ ba là tập hợp con của các tập hợp con của bảng chữ cái, đó là một danh sách độ dài 2^(2^26) ~= 1.09 × 10^20201781.

Rõ ràng sẽ không có máy tính nào có thể tính toán danh sách lớn này và xuất ra nó.

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 byte đầu ra

Để so sánh dễ dàng hơn, đây là khoảng 7,3 * 10 ¹⁹ .

P
PP
Ke!

Bản in:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Chà, cái cuối cùng bao gồm tất cả các hoán vị [0 1 2 ... 19]với các số được ghép với nhau. Tôi không khuyên bạn nên dùng thử ... (Hãy thử như 4e!thể để có được hương vị.)

Kiểm tra tại đây: Chương trình 1 , Chương trình 2 , Phiên bản Sane của chương trình 3 .

Thạch , 1,2 × 10 ²⁵⁶⁸ byte đầu ra

ȷ
ȷ*
ȷ*!

Tính 1000 , 1000 ¹⁰⁰⁰ và 1000 ^1000! .

Dùng thử trực tuyến: chương trình đầu tiên | chương trình thứ hai | chương trình thứ ba (sửa đổi)

Đối với mục đích đếm byte, ȷcó thể được mã hóa thành byte 0xa0 trong phiên bản hiện tại của Jelly .

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

Trong Jelly, ȷcó thể được sử dụng bên trong chữ số dưới dạng Python e(ký hiệu khoa học). Ví dụ, 3ȷ4trả về 30000 . Trong ký hiệu khoa học Jelly của, giá trị mặc định hệ số để 1 và giá trị mặc định mũ để 3 , vì vậy ȷ, 1ȷ3và 1000tất cả trở lại cùng một số.

ȷ      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 byte đầu ra

Chà ... không phải là một điểm số rất ấn tượng, nhưng ít nhất tôi có thể khẳng định rằng nó là tối ưu. Với một byte đơn, không thể in một cái gì đó và chấm dứt, vì vậy chúng tôi bắt đầu với hai byte:

!@

Mã mở ra là

 ! @
. . .
 . .

Điều này in một byte và chấm dứt.

Đối với ba byte mã, chúng ta có thể in ba byte đầu ra. Ví dụ:

o!@

hoặc mở ra:

 o !
@ . .
 . .

in 111. Bất kỳ chữ thường viết thường từ dđể zlàm việc và in mã ký tự của nó. Đó là 23 cách duy nhất để in 3 byte với 3 byte mã.

Cuối cùng, đối với bốn byte, có 169 cách để in 6 byte. Vì không ai trong số họ làm bất cứ điều gì thú vị hơn (ngoại trừ luồng điều khiển kỳ lạ) so với giải pháp chuyển tiếp thẳng, tôi sẽ trình bày rằng:

o!!@

Mở ra:

 o !
! @ .
 . .

Bạn đoán nó Nó in 111111.

Làm thế nào để tôi biết những điều này là tối ưu? Tôi đã điều chỉnh trình giả mạo vũ phu mà tôi đã viết cho danh mục máy thật để tìm kiếm đầu ra hữu hạn tối đa trong 7000 chu kỳ (Tôi không nghĩ bạn có thể viết một hải ly bận rộn với 4 byte, chạy trong 7000 chu kỳ nhưng vẫn chấm dứt sau đó.)

Nghiêm túc, 2025409 byte

1 byte:

N

(tạo ra 11.756 byte đầu ra)

2 byte:

Nñ

Tạo ra 153.717 byte đầu ra

3 byte:

9!!

Tạo ra 1.859.936 byte đầu ra

Nghiêm túc là chưa có tính năng như "tất cả các tập hợp con" hoặc "tất cả các kết hợp", vì vậy điểm tương đối thấp về điều này.

Trăn 3, 1 + 22 + 23 = 56

9
id
abs

Đầu ra

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

In 9 và sau đó định nghĩa cho idvà abs.

Mê cung , 1 + 2 + 4 = 7 byte

Một số điểm thấp khác, mà tôi chủ yếu đăng bởi vì tôi đã chứng minh nó là tối ưu cho ngôn ngữ.

Giống như Hexagony, Labyrinth không thể in và kết thúc bằng một byte đơn, vì vậy chúng tôi bắt đầu với hai byte:

!@

In một số không và chấm dứt.

Đối với ba byte, chúng ta không thể đánh bại giải pháp ngây thơ:

!!@

Điều này in hai byte trước khi kết thúc. Có một vài lựa chọn khác, như in -1với (!@hoặc ~!@hoặc ,!@. Có một giải pháp khá hay mặc dù sử dụng xoay mã nguồn:

!>@

Điều này in một số không, sau đó chuyển nguồn để trở thành @!>. Tại thời điểm đó, nó đi vào ngõ cụt, quay lại và thực hiện !lại trên đường trở về, trước khi chấm dứt.

Đối với bốn byte, điều đó thú vị hơn một chút, vì cách duy nhất để in 4 ký tự là sử dụng thủ thuật trên:

!!>@

In hai số không, chuyển sang @!!>, in hai số không khác.

Trong tất cả các trường hợp này, tôi bỏ qua rằng bạn cũng có thể in một byte bằng \hoặc ., bởi vì chúng sẽ luôn in chính xác một byte, trong khi đó !sẽ in ít nhất một và có khả năng nhiều.

Bash, 1726 byte

(Tôi đã sửa nó ngay bây giờ. Vui lòng xem xét nâng cấp.)

1 byte :"

Đầu ra:

>

307 byte: id

Đầu ra:

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 byte: zip (In sang STDOUT)

Bản quyền (c) 1990-2008 Info-ZIP - Nhập 'zip "-L"' cho giấy phép phần mềm.
Zip 3.0 (ngày 5 tháng 7 năm 2008). Sử dụng:
zip [-options] [-b path] [-t mmddyyyy] [-n hậu tố] [danh sách zipfile] [danh sách -xi]
  Hành động mặc định là thêm hoặc thay thế các mục zipfile từ danh sách, trong đó
  có thể bao gồm tên đặc biệt - để nén đầu vào tiêu chuẩn.
  Nếu zipfile và danh sách bị bỏ qua, zip sẽ nén stdin thành thiết bị xuất chuẩn.
  -f làm mới: chỉ thay đổi tập tin -u cập nhật: chỉ thay đổi hoặc tập tin mới
  -d xóa các mục trong zipfile -m di chuyển vào zipfile (xóa các tệp hệ điều hành)
  -r recurse vào thư mục -j rác (không ghi) tên thư mục
  -0 chỉ lưu trữ -l chuyển đổi LF thành CR LF (-ll CR LF thành LF)
  -1 nén nhanh hơn -9 nén tốt hơn
  -q hoạt động yên tĩnh -v hoạt động dài dòng / thông tin phiên bản in
  -c thêm bình luận một dòng -z thêm bình luận zipfile
  - @ đọc tên từ stdin -o làm cho zipfile cũ như mục mới nhất
  -x loại trừ các tên sau -i chỉ bao gồm các tên sau
  -F sửa zipfile (-FF cố gắng hơn) -D không thêm các mục nhập thư mục
  -A điều chỉnh exe tự giải nén -J tiền tố zipfile rác (unzipsfx)
  -T kiểm tra tính toàn vẹn của tệp zip -X eXclude eXtra
  -y lưu các liên kết tượng trưng làm liên kết thay vì tệp được tham chiếu
  -e mã hóa -n không nén các hậu tố này
  -h2 hiển thị thêm trợ giúp

TOÁN , 313

Phiên bản hiện tại của ngôn ngữ ( 3.1.0 ) được sử dụng, sớm hơn thử thách này.

1. Mã (được xác định trước bằng chữ: tạo số 2, được in ngầm):

   H
   

   Đầu ra (1 byte):

   2
   

2. Mã (tạo số pi, được in ngầm với 15 số thập phân):

   YP
   

   Đầu ra (17 byte):

   3.141592653589793
   

3. Mã (các số từ 1 đến 99, được in theo mặc định với khoảng trắng ở giữa):

    99:
   

   Đầu ra (295 byte):

   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
   

Đang xử lý, 39 byte

Quyết đoán

1 byte :

print(X);

Đầu ra 0.

9 byte :

print(PI);

Đầu ra 3.1415927

29 byte :

print(P3D);

Đầu ra processing.opengl.PGraphics3D

Không xác định,> = 129 byte

> = 32 byte:

print(g);

Đầu ra processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 byte:

print( g);

Đầu ra processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 byte: (Cảm ơn bạn @anOKsquirrel vì đề xuất này.)

print(g,g);

Đầu ra

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

JavaScript, 1 + 3 + 18 = 18 22

Không phải là một câu trả lời rất thú vị nhưng có lẽ JavaScript tốt nhất có khả năng.

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

Đã thêm 4 điểm nhờ vào @Und xác định chức năng !

Đầu ra dưới dạng văn bản:

1
0.1
0.1111111111111111

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

Bất kỳ đoạn mã nào ngắn hơn độ dài 2 đều không thể xuất hoặc không thể chấm dứt đầu ra của nó.

Trong Befunge, .xuất giá trị trên cùng của ngăn xếp dưới dạng số nguyên, theo sau là khoảng trắng. Một không gian không phải là một dòng mới, vì vậy nó được bao gồm trong số đếm. Ngoài ra, ngăn xếp "vô hạn" được lấp đầy bằng 0, do đó, đầu ra chương trình (tương ứng):

0 
0 0 
0 0 0 

SmileBASIC, 1 + 4 + 10 = 15 byte

Chương trình 1:

Cách ngắn nhất để in một cái gì đó là với? (IN) và một nhân vật duy nhất. Đây có thể là một số hoặc một tên biến và không thành vấn đề vì tất cả chúng đều có cùng độ dài.

?1
1

Chương trình 2:

Bây giờ chúng tôi có quyền truy cập vào một vài điều nữa. Biểu thức dài nhất có thể được tạo sẽ là một trong các hằng số #Y, #L hoặc #R, có các giá trị tương ứng là 128, 256 và 512. Tuy nhiên, thay vì đó, tôi sử dụng dấu phẩy để (trong trường hợp này) có thêm 3 khoảng trắng.

?1,
1   

Chương trình 3:

Với 3 ký tự, bạn có thể viết các số ký hiệu E:

?1E9
1000000000

HQ9 +, 71304

9

In lời bài hát 11.884 ký tự của "99 chai bia"

99

In "99 chai bia" hai lần

999

In "99 chai bia" ba lần

Japt -Q, đầu ra 1.0123378918474279e+150byte

Số đầy đủ là

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

byte.

# 1

M

Đầu ra

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

Cho 67 byte. (Tín dụng cho Shaggy)

# 2

LÆ

Đầu ra

[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]

đó là 501 byte.

(Tín dụng cho @Shaggy)

# 3

;Eá

Xuất ra tất cả các hoán vị của 95 ký tự ASCII có thể in ở định dạng ["...","...","..."...], đó là

$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$ byte đầu ra.

Bạn có thể nhận được số lượng byte đầu ra vô hạn nếu bạn sử dụng -Fcờ trong Japt. Những gì nó làm là nếu biểu thức cuối cùng của chương trình ước tính thành false, nó sẽ đưa ra giá trị được chỉ định trong cờ thay thế. Vì vậy, tôi đoán điểm số cho Japt -F"Insert Super Long String Here"là vô cùng.

Malbolge , 1 + 2 + 3 = 6 byte

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

Dùng thử trực tuyến: thứ nhất , thứ hai , thứ ba

Đầu ra:

r
ll
xxx

Brute buộc. Giả sử \0không phải là một ký tự đầu ra hợp lệ

Với \0:

cP
cbO
cbaN

Đầu ra:

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

scg , 1 + 27 + 188 = 216

Đầu tiên:

1

Chỉ cần in 1, là ngăn xếp được xuất ra ở cuối chương trình.

Thứ hai:

.d

In thông tin gỡ lỗi, trông giống như thế này:

Stack: []
Array Markers: []

Ngày thứ ba:

99r

thêm 99 vào ngăn xếp, sau đó sử dụng chức năng phạm vi. Đầu ra 01234567891011 .... (đây là một trong những lần tôi muốn tôi thực hiện chức năng giai thừa. Tôi không)

Tuyệt vời 1 + 1 + 2 = 4 byte đầu ra

Marbelous bị cản trở ở đây bằng cách có các hướng dẫn hai byte. Nhận xét vô nghĩa hoặc khoảng trắng không cần thiết là cách duy nhất để có được số byte lẻ.

in "A" và chấm dứt:

`A

in "B" và chấm dứt, với một bình luận EOL trống

`B#

in "CD" và chấm dứt:

`C`D

Mathicala, 6 + 461 + 763 = 1230 1225 618 163 byte đầu ra

%  (* -> 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

*)

Hiện tại, hai cái cuối cùng sử dụng Informationđể lấy tài liệu về các ký hiệu, có thể xuất ra nhiều byte. Lưu ý rằng điều này đã được chạy trên dòng lệnh 10.1 MathKernel.

Javascript, 72 byte

Điều này hoạt động trong trình thông dịch dòng lệnh Mozilla JSShell .

1 byte: 1

Đầu ra 1

35 byte: gc

Đầu ra

function gc() {
    [native code]
}

36 byte: run

Đầu ra

function run() {
    [native code]
}

Octave, 2818417 byte

e

14 byte cho ans = 2.7183\n

pi

14 byte cho ans = 3.1416\n

doc

Hiển thị toàn bộ tài liệu. 2818389 byte, được tính bằng dd Dùng thử trực tuyến! bởi vì evalckhông làm việc

SmileBASIC 4, 1 + 13 + 15 = 29 byte

Điều này sẽ tương tự như câu trả lời SmileBASIC 3 của 12Me21, với một vài điều chỉnh.

1

Như trước đây, số lượng mã ngắn nhất để tạo ra một số đầu ra là 2 byte: ?( PRINT) và một số biểu thức byte đơn. Sự đồng thuận là PRINTkhông không tạo ra một dòng mới khi nó tiến đến dòng kế tiếp, do cách văn bản tác phẩm màn hình. Vì vậy, điều này dẫn đến một byte đầu ra.

?1
1

2

Với 3 byte, chúng ta có thể làm một cái gì đó khác nhau. SB4 giới thiệu INSPECT, có biệt danh là ??, in thông tin về một giá trị duy nhất. Ví dụ, nếu chúng ta cung cấp cho nó một chuỗi rỗng, điều này có thể tạo ra sản lượng nhiều hơn SB3 có thể. Điều này giúp chúng tôi có 13 byte.

??"
STRING: (0)""

3

Chúng tôi có 4 byte để làm việc, vì vậy chúng tôi phải quyết định những gì chúng tôi nên làm để tối đa hóa đầu ra của chúng tôi. Đi với ??là đặt cược an toàn; chúng tôi chỉ có 2 byte để sử dụng trên biểu thức của chúng tôi, nhưng đầu ra bổ sung INSPECTvề cơ bản là miễn phí. Vì vậy, tôi sử dụng nó để in một chuỗi nhãn. Đây là 15 byte.

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

Tổng cộng là 29 byte.

Kính hiển vi II, 23 + 47 + 71 = 141 byte

1: C

Việc xâu chuỗi các liên tục không được xác định nghiêm ngặt bởi các thông số kỹ thuật, nhưng trong việc thực hiện tham chiếu, việc này tự chạy, mang lại một chuỗi 23 byte.

<Continuation @t=\d\d\dus>( \dđại diện cho một chữ số, chữ số khác nhau).

Trên máy tính của tôi, ít nhất, trên thực tế, điều này luôn mất khoảng 180 đến khoảng 400 micro giây để chạy.

Việc sử dụng đầu tiên tôi thực sự đã có cho hướng dẫn này.

2: CP

47 byte đầu ra - đầu ra từ đầu tiên hai lần với một dòng mới ở giữa.

3: CPP

Khá đơn giản. 71 byte đầu ra - đầu ra từ lần đầu tiên ba lần với các dòng mới ở giữa.

PowerShell, ~ 4300 byte

Độ dài đầu ra gần đúng, dựa trên hệ thống mà nó chạy. Tất cả các đoạn dưới đây là xác định, trong đó nếu được đưa ra cùng một trạng thái ban đầu của máy tính sẽ xuất ra cùng một văn bản, chỉ là trong thực tế, đầu ra có thể thay đổi từ thực thi sang thực thi.

Độ dài 1, 107 byte

?

Đây là một bí danh cho Where-Object. Nó sẽ xuất ra một dấu nhắc người dùng yêu cầu thêm thông tin:

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

Độ dài 2, 113 byte

rp

Đây là một bí danh cho Remove-ItemProperty. Nó sẽ xuất ra một dấu nhắc người dùng yêu cầu thêm thông tin:

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

Chỉ dài hơn đoạn trích dài 1 đoạn.

Độ dài 3, ~ 4100 byte

gps

Đây là một bí danh Get-Processsẽ xuất ra một bảng được định dạng của tất cả các quy trình đang chạy trên hệ thống:

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 byte đầu ra

$
$$
$+$

Hai chức năng $và $$có sẵn trong tất cả các bảng điều khiển của trình duyệt chính, dưới dạng phím tắt cho document.querySelectorvàdocument.querySelectorAll tương ứng. Các trình duyệt khác nhau có mã riêng được ép buộc với các chuỗi hơi khác nhau và IE sử dụng JS đơn giản trong mỗi hàm dẫn đến biểu diễn dài hơn nhiều.

Đối với số byte, tôi lấy độ dài của biểu diễn chuỗi của từng thay vì hiển thị bảng điều khiển đôi khi được sửa đổi, do đó, tổng số byte là cho mỗi trình duyệt sau:

• Chrome: 56 + 57 + 112 = 225 byte
• IE: 312 + 318 + 624 = 1254
• Firefox: 33 + 33 + 66 = 132

(Tôi đang xem kết quả IE là số "chính thức" vì nó dài nhất.)

Đối với môi trường trình duyệt không có bàn điều khiển, các đầu ra lớn nhất đến từ các mục sau:

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

Độ dài kết quả theo trình duyệt:

• Chrome: 1 + 5 (hoặc 15 nếu {} có thể sử dụng) + 32 = 38 (hoặc 48) byte
• IE: 1 + 5 (hoặc 15 nếu {}có thể sử dụng) + 38 = 44 (hoặc 54)
• Firefox: 1 + 5 (hoặc 15 nếu {}có thể sử dụng) + 36 = 42 (hoặc 52)

Hai bộ đầu vào này tạo ra đầu ra lớn nhất có thể có trong tất cả các trình duyệt và bảng điều khiển này. Để chứng minh điều này, hãy kiểm tra tất cả các lựa chọn thay thế:

• Các biến hiện có: Chúng ta có thể tìm thấy tất cả các biến có sẵn nguyên gốc với tối đa ba ký tự Object.getOwnPropertyNames(window).filter(x=>x.length<=3)và sau đó mapchúng vào đầu ra chuỗi của chúng để xác định các biến lớn hơn. (Lưu ý rằng trong một số trình duyệt như Firefox, một số biến bảng điều khiển đặc biệt không thể được truy cập theo cách này vì chúng không phải là một thuộc tính của cửa sổ.)
• JS có số lượng hạn chế các loại chữ có thể được tạo với rất ít ký tự:
  • Theo thông số kỹ thuật, các số thập phân phải là một chữ số thập phân ( 1234567890) tùy ý theo sau .và nhiều chữ số thập phân hơn và / hoặc một phần số mũ, hoặc được .theo sau bởi một hoặc nhiều chữ số thập phân và tùy ý là một số mũ. Các loại số phải là 0o, 0xhoặc0b (hoặc chữ hoa mẫu đính kèm), tiếp theo là một hoặc nhiều chữ số. Đối với mục đích của chúng tôi, chúng tôi có thể suy luận như sau:
    • Chỉ có mười số có một ký tự, là các số nguyên từ 0 đến 9. Các số có hai ký tự duy nhất là các số nguyên 0-99 (0-9 bằng cách thêm một số thập phân sau) và các số 0,1 đến 0,9 bằng cách bỏ qua số 0 ban đầu . Các số có ba ký tự duy nhất là 0-999, bao gồm 0x0-0xf, 0o0-0o7, ​​0b0 và 0b1, số mũ từ 1e1 đến 9e9 (10 ký tự) và các số 0,1-9,9 và 0,01 đến 0,99. Mặc dù về mặt kỹ thuật không phải là một số theo nghĩa đen, NaN cũng có thể được tham chiếu trong ba ký tự.
  • Chuỗi, mảng và biểu thức chính, mỗi chuỗi có thể chỉ lấy tối đa một ký tự duy nhất của nội dung. Một mảng có thể được điền $, dấu phẩy hoặc số có một chữ số. Mảng chỉ có một phần tử được ép buộc thành chuỗi như chính phần tử đó. Mảng trống trở thành chuỗi rỗng.
  • Tùy thuộc vào môi trường, có thể hoặc không thể tạo các đối tượng đơn giản với ba ký tự. Thông thường, {}một mình khi bắt đầu một kịch bản sẽ được coi là một bao vây hơn là tạo ra một đối tượng. eval({})trả về không xác định, eval({$})trả về $hàm. Không có đủ ký tự để bao quanh {}trong ().
• Không có từ khóa nào đủ ngắn để sử dụng. Các từ khóa if, in, do, new, for, try, var, và letsẽ tất cả các yêu cầu tối thiểu của hai nhân vật khác để sử dụng, vượt quá giới hạn.
• Khai thác unary có sẵn bao gồm ~, +, -, !, ++, và --. Các toán tử hai ký tự chỉ có thể được sử dụng với một biến ký tự, trong đó chỉ có một ( $), mang lại NaN. Bốn toán tử khác có thể được sử dụng với bất kỳ giá trị một hoặc hai ký tự nào, trong đó có:
  • Một số biến. (Trên một số console $, $_, $0, $1, $2, $3, $4, $, $$, $x). Khi sử dụng với các nhà khai thác, kết quả được giới hạn -1, true, false, và NaN.
  • 109 số. Kết quả: Số nguyên -100 đến 99, -0,9 đến -0,1 true,, false.
  • Chuỗi rỗng. Kết quả : -1, 0( -0trở thành 0toString) , true.
  • Kết quả của bất kỳ giá trị một ký tự nào ở trên được liên kết với toán tử đơn nguyên một ký tự. Kết quả mới: Không có.
• Nhà khai thác có thể sử dụng hệ nhị phân (mà phải là một nhân vật duy nhất để có chỗ còn lại cho cả hai toán hạng) là +, -, *, /, %, <, >, &, |, ^. Chúng chỉ có thể được sử dụng với một giá trị ký tự ở mỗi bên. Tùy chọn cho các giá trị bao gồm $và số nguyên 0-9. Kết quả của tất cả các kết hợp này bao gồm Infinity, một số số và giá trị nhị phân được đề cập ở trên và nhiều phân số được ép buộc thành chuỗi 19 ký tự trở xuống ( 1/7là 19 ký tự, không giống như được 1/9đề xuất ở trên chỉ có 18) và biểu thị văn bản của $trước đó hoặc theo sau là một số nguyên đơn hoặc chính nó.
• Cuối cùng, tất cả các toán tử và biểu thức còn lại: Toán tử thành viên .yêu cầu một biến hiện có và một mã định danh tham chiếu đến một thuộc tính. Tất cả việc sử dụng này ở đây dẫn đến undefined. Xung quanh một giá trị ( )trả về giá trị, cũng như gán nó với =. Việc sử dụng ()hoặc `` để gọi một giá trị là một hàm dẫn đến không xác định hoặc lỗi với tất cả các giá trị có sẵn.

Thêm tất cả những điều này, có tổng cộng 1651 đầu ra có thể có khi sử dụng bảng điều khiển Chrome. Các đầu ra dài nhất cho một, hai và ba nhân vật là từ $, $$và $+$tương ứng.

dc , 2 + 5 + 18 = 25 byte

1: Ffsản lượng ( Hãy thử trực tuyến! ):

15

2: Fdfsản lượng ( Hãy thử trực tuyến! ):

15
15

3: Fd^fsản lượng ( Hãy thử trực tuyến! )

437893890380859375

Không có cái nào đặc biệt thú vị, nhưng dckhông thực sự tuyệt vời để nhổ ra hàng đống đầu ra. Tôi làm như thế mỗi câu trả lời được xây dựng trên trước đó. Dù sao, Fchỉ là số 15; fin toàn bộ ngăn xếp; dtrùng lặp top-of-stack; ^tăng giá trị chồng lên nhau thành sức mạnh của đỉnh cao (trong trường hợp này là 15 ^ 15). Tôi không tin rằng điều này có thể đứng đầu dc.

Ruby, 3 + 14 + 28 = 45 byte

Tại sao tôi làm điều này.

p

In nil.

$>

In #<IO:<STDOUT>>.

dup

In một cái gì đó dọc theo dòng #<Object:0x0000000003610988>.

irb

Ra mắt một phiên bản của Ruby tương tác. Khi thoát ra, đối tượng được trả về là #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>>121, nhưng vì nó yêu cầu bạn nhấn ^Dhoặc một cái gì đó để thực sự thoát khỏi cá thể irb, tôi không chắc liệu nó có thực sự được tính là một giải pháp trong "3 byte" hay không thực sự bao gồm nó trong điểm số trừ khi nó được chấp nhận.

Perl 6, 53 (17 + 18 + 18) byte

e
-e
e*e

1. e đầu ra $e$ đến 15 chữ số thập phân
2. -e đầu ra $-e$ đến 15 chữ số thập phân
3. e*e đầu ra $e^2$, nhưng thật kỳ lạ, nó cho thêm một chữ số thập phân

Runic Enchantments, 4,000,000 bytes of output

The first program is:

a@

Takes 2 bytes to: push a value to the stack, print a value from the stack, and terminate. In this case it prints 10 (though any integer value from 0 to 16 are also just as valid)

For 3 bytes:

aY@

Prints 10000, Again, a could be 1 through 16 inclusive (in order to generate more output than the original program, 0 is potentially valid under other operators) and there aren't a whole lot of operators that take a single input and produce any output, much less longer output. XCYZ:E are the only real options. aY@ is just the one that results in the most output.

P$!;

Theo đặc điểm ngôn ngữ, điều này chạy vô tận. Tuy nhiên, vì trình thông dịch có giới hạn thực thi tối đa "ok, đủ", đây là đầu ra có thể đạt được nhất trong 4 ký tự (và TIO cắt bỏ thực thi sau ~ 130.000 byte để vượt quá 128kib) và vì trình thông dịch xác định ngôn ngữ , điều này làm. Và mặc dù tôi đã tăng ngưỡng đó một lần trước đây (từ 10 nghìn bước lên 1 triệu), tôi không có kế hoạch gây rối với nó bất cứ lúc nào sớm.

To hơn?

Nếu tôi gọi ba giả định tôi đã thực hiện ở đây , thì chắc chắn.

`AA@

Điều này phù hợp với Ack(65,Ack(65,64)), không phải là giá trị quá lớn để chuyển sang chức năng Ackerman ban đầu - chắc chắn nhỏ hơn 255 trong bài cũ - nhưng không sao, chúng ta có thể gọi Ack hai lần trong 4 hướng dẫn.

And only god knows what it'll print.

_{Note: the A instruction has since then been made the Math meta-instruction, which consumes 3 objects on the stack: a char for what instruction to perform and then two inputs, x and y. As such this program doesn't actually do anything, both because neither A nor @ map to a math function and because two subsequent calls results in a stack underflow.}