Nếu bạn thích điều này, hãy xem xét tham gia:

• Các Official Dyalog APL 2016 Năm game

• Thử thách chơi gôn Dyalog APL 2017 hàng tháng

Tạo 12 đoạn / biểu thức , trong cùng một ngôn ngữ, dẫn đến các số từ 0 đến 10 và 42 tương ứng, nhưng không ghi bất kỳ dữ liệu số, chuỗi hoặc ký tự nào.

Dữ liệu tích hợp, như PI()và ALPHABET(), đều ổn, và ví dụ như các hằng số U, X, Y, Z và A của CJam, và BLEND, CHORD, TRUNG TÂM, BREAK và DÒNG xử lý.

Mỗi đoạn mã phải có khả năng tự đứng vững, tức là chúng có thể không phụ thuộc lẫn nhau. Tuy nhiên, bên trong một đoạn mã duy nhất, bạn có thể chỉ định một biến và sử dụng nó một cách tự do, miễn là bạn tham chiếu trực tiếp đến tên đó và không thông qua một chuỗi chứa tên của nó.

Tất cả các đoạn mã phải hợp lệ trên máy tính của người gửi tại thời điểm gửi (như báo cáo của SE), nhưng không được dựa vào các điều kiện địa phương bất thường như số lượng tệp trong một thư mục, ngày hoặc giờ chính xác hoặc đầu vào cụ thể từ người dùng .

Ví dụ về đoạn trích hợp lệ

3: INT(LOG10(YEAR(TODAY()))) bởi vì nó vẫn đúng trong tương lai
4: CUBICROOT(LEN(CHARACTERSET())) vì một bộ ký tự 256 chữ rất phổ biến
8: SQRT(SYSTEMTYPE()) vì các hệ thống 64 bit rất phổ biến

Ví dụ về đoạn trích không hợp lệ

5: LEN(USERNAME()) bởi vì hầu hết mọi người không sử dụng Đăng nhập của quản trị viên Đăng nhập :-)
9: LOG10(SYSTEMMEMORY()) vì nó chỉ hoạt động trên các hệ thống có chính xác 1 GB bộ nhớ
42: CODE("*") vì nó chứa một chuỗi / ký tự bằng chữ

Kết quả của mỗi đoạn mã phải dẫn đến một số thực tế (giá trị, int, float, v.v.) có thể được sử dụng để tính toán thêm bằng cách sử dụng cùng ngôn ngữ với đoạn mã, tức là không phải là một chuỗi văn bản đại diện cho số đó.

Chỉ cho phép các ngôn ngữ dựa trên ký tự.

Điểm là tổng số byte của tất cả 12 đoạn được kết hợp. Các dòng mới phân tách các đoạn không được tính vào.

Lưu ý rằng các quy tắc trên có thể ngăn một số ngôn ngữ tham gia, ngay cả khi chúng hoàn thành Turing.

Câu hỏi thường gặp

Q Các chương trình có thể chấp nhận bất kỳ đầu vào?
A Có, nhưng bạn không chỉ yêu cầu nhập và nhập số liên quan.

Q Các chữ số vật lý (không phải dữ liệu) có được phép không?
A Có, vd LOG10().

Q Do Symbols trong Ruby được tính là chữ?
Một Yes.

Q Điểm có bao gồm các dòng mới giữa mỗi đoạn không?
Một số

Q TI-BASIC "dựa trên ký tự" có đủ hợp lệ không?
Một Yes.

Q Làm sai và đúng là số chữ?
Một Không, họ được chấp nhận.

H Chúng ta có thể sử dụng một số bằng chữ để gọi một hàm nếu đó là cách duy nhất và số đó không ảnh hưởng đến đầu ra của hàm?
A Có, nếu đó là cách thông thường để viết mã bằng ngôn ngữ của bạn.

Q Ngôn ngữ của tôi giả sử có [một cái gì đó] ở đầu mỗi chương trình / biểu thức. Tôi phải bao gồm nó hay các đoạn trích của tôi chỉ hoạt động nếu được đặt ở giữa chương trình / biểu thức?
A Họ chỉ nên làm việc ở giữa một chương trình / biểu thức.

Q Điều gì về regex nghĩa đen?
Một Tử Cấm, ngoại trừ các ngôn ngữ chỉ làm regexes.

Q Có phải một đoạn mã có thể in tất cả các số được chỉ định có thể chấp nhận không?
Một Không, họ phải được tách biệt và đôi bên cùng có độc lập.

H Tôi có thể giả sử một cái nồi hơi giống int main() {}...hoặc tương đương không?
Một Yes.

Q Kiểu dữ liệu đầu ra nào được phép?
A Bất kỳ kiểu dữ liệu số nào, như int, float, v.v.

H Tôi có cần in kết quả của từng đoạn không?
Một Không, làm cho kết quả có sẵn để sử dụng sau là đủ.

Q Các biến đặt trước có được phép không?
A Có và chúng sẽ được đặt lại (nếu thay đổi) cho mọi đoạn mã.

Q Có phải π và e được coi là số chữ?
Một Không, bạn có thể sử dụng chúng.

H Tôi có thể trả lại 4 và 2 trong các ô khác nhau cho 42 không?
Một Không, họ phải được kết nối như một số.

Q byte hay ký tự?
Một byte, nhưng bạn có thể chọn bất kỳ bảng mã mong muốn nào.

Q Có thể sử dụng các hàm hằng và các biến đặt trước như J 9:, Trên thực tế 9và Pretzel 9không?
A Có, nếu từ vựng là hữu hạn (19 cho J, 10 cho Thực tế và Pretzel).

Lục giác , 13 byte

1
2
3
4
5
6
7
số 8
9
10
42

Hãy thử trực tuyến!

Trong Hexagony, 0thông qua 9các hàm nhân bộ nhớ hiện tại với 10, sau đó thêm số được biểu thị bằng tên hàm. Do đó, đoạn đầu tiên trống rỗng khi ký ức bắt đầu 0.

Ví dụ, nếu bộ nhớ hiện tại là 65, thực thi chức năng 3sẽ tạo ra bộ nhớ hiện tại 653.

(Để downvoters: downvote tất cả những gì bạn muốn; tôi đã sẵn sàng.)

Funciton , 1222 byte

Ngoài các chữ số, có hai cách tôi có thể tạo ra một giá trị (bất kỳ giá trị nào) trong Funciton: biểu thức stdin và lambda. Stdin là một hộp duy nhất trong khi một biểu thức lambda đầy đủ đòi hỏi nhiều cú pháp hơn, vì vậy tôi sẽ sử dụng stdin. Tuy nhiên, trong khi stdin có thể là bất cứ điều gì, tất cả các công việc sau đây bất kể đầu vào được cung cấp là gì.

Tất cả các chức năng thư viện được sử dụng ở đây đã tồn tại trước khi thử thách được đăng.

0 (40 byte trong UTF-16)

╔╗┌┐
║╟┤└┼┬┐
╚╝└─┘└┘

Điều này sử dụng cú pháp thô cho ít hơn. Một giá trị không bao giờ nhỏ hơn chính nó, vì vậy kết quả của điều này là 0.

1 (52 byte trong UTF-16)

╔╗┌─╖┌─╖
║╟┤⌑╟┤ɕ╟
╚╝╘═╝╘═╝

⌑trả về một chuỗi lười biếng chứa một phần tử duy nhất và ɕđếm số phần tử. (Chuỗi lười biếng đủ lười biếng để đoạn trích này thực sự không đánh giá stdin chút nào!)

2 (70 byte trong UTF-16)

╔╗┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝

= 2¹. ʂtạo ra tất cả các chuỗi con của một chuỗi và do đó biến một chuỗi gồm n phần tử thành một với 2ⁿ.

3 (88 byte trong UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2 + 1. ♯tăng giá trị lên 1.

4 (88 byte trong UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟
╚╝╘═╝╘═╝╘═╝╘═╝

= 2².

5 (106 byte trong UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ʂ╟┤ɕ╟┤♯╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 4 + 1.

6 (106 byte trong UTF-16)

╔╗┌─╖┌─╖┌─╖┌─╖┌─╖
║╟┤⌑╟┤ʂ╟┤ɕ╟┤♯╟┤!╟
╚╝╘═╝╘═╝╘═╝╘═╝╘═╝

= 3 giai thừa.

7 (110 byte trong UTF-16)

┌───┐┌─╖┌─╖┌─╖╔╗
│┌─╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤A╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= A (2, 2) (Hàm Ackermann).

8 (118 byte trong UTF-16)

┌────┐┌─╖┌─╖┌─╖╔╗
│┌──╖├┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤<<╟┘╘═╝╘═╝╘═╝╚╝
 ╘╤═╝

= 2 << 2 (dịch chuyển sang trái).

9 (128 byte trong UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤×╟┘╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 3 × 3.

10 (146 byte trong UTF-16)

┌───┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖├┤♯╟┤ɕ╟┤ʂ╟┤ʂ╟┤⌑╟╢║
└┤+╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘╤╝

= 5 + 5.

42 (170 byte trong UTF-16)

┌──────┐┌─╖┌─╖┌─╖┌─╖┌─╖╔╗
│┌─╖┌─╖├┤!╟┤♯╟┤ɕ╟┤ʂ╟┤⌑╟╢║
└┤♯╟┤×╟┘╘═╝╘═╝╘═╝╘═╝╘═╝╚╝
 ╘═╝╘╤╝

= 6 × (6 + 1).

JavaScript, 144 141 140 138 132 125 123 byte

Với sự giúp đỡ từ @ edc65 , @Sjoerd Công việc Postmus , @DocMax , @usandfriends , @Charlie Wynn và @ Mwr247 !

result.textContent = [

+[]                          ,// 0  (3 bytes)
-~[]                         ,// 1  (4 bytes)
-~-~[]                       ,// 2  (6 bytes)
-~-~-~[]                     ,// 3  (8 bytes)
-~Math.PI                    ,// 4  (9 bytes)
-~-~Math.PI                  ,// 5  (11 bytes)
-~-~-~Math.PI                ,// 6  (13 bytes)
Date.length                  ,// 7  (11 bytes)
(a=-~-~[])<<a                ,// 8  (13 bytes) = (2 << 2)
(a=~Math.E)*a                ,// 9  (13 bytes) = (-3 * -3)
(a=-~-~[])<<a|a              ,// 10 (15 bytes) = ((2 << 2) | 2)
(a=Date.length)*--a           // 42 (19 bytes) = (7 * 6)

];

<pre id="result"></pre>

Chuột-2002 , 27 26 17 14 byte

Các đoạn đầu tiên đẩy 0-10, và ZR+đẩy 25sau đó 17và 25 17 + 42 =là 1.

A
B
C
D
E
F
G
H
I
J
K
ZR+

CJam, 27 24 byte

U    e# 0
X    e# 1
Y    e# 2
Z    e# 3
Z)   e# 3 + 1
YZ+  e# 2 + 3
ZZ+  e# 3 + 3
AZ-  e# 10 - 3
YZ#  e# 2³
A(   e# 10 - 1
A    e# 10
EZ*  e# 14 × 3

Cảm ơn @ MartinBüttner cho -1 byte!

Hãy thử trực tuyến!

Brainfuck, 70 byte

+
++
+++
++++
+++++
++++++
+++++++
++++++++
+++++++++
++++++++++
--[>+<++++++]>-

Mỗi dòng phải được chạy riêng.

10 đầu tiên là tự giải thích: chúng tôi tăng giá trị của ô thông qua mỗi cộng.

42 phức tạp hơn nhiều. Nó dựa vào thực tế là trình thông dịch Brainfuck sử dụng các ô 8 bit nhất, có nghĩa là tất cả các thao tác trên nó được thực hiện theo modulo 256. Các --ô đặt số 0 đến 254. Sau đó, chúng ta nhập một vòng lặp chạy cho đến khi ô # 0 là 0. Mỗi lần lặp thêm 1 vào ô số 1 và thêm 6 vào ô số 0. Vòng lặp này chạy 43 lần, vì vậy ô số 1 là 43. Cuối cùng, chúng tôi trừ đi 1 từ ô số 1 để làm cho nó 42.

Tôi đã nhận được 42 hiệu quả nhất từng được tìm thấy từ http://esolangs.org/wiki/Brainfuck_constants

Bóng tối , 339 303 byte

Đây là nơi Darkness thực sự tỏa sáng . Hiểu rồi? : ~)!

Không in (thay thế khoảng trắng bằng \sdòng đầu tiên vì nó sẽ không hiển thị khác):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

██████████████████████████████████████████ 

Với việc in ấn:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

██████████████████████████████████████████■ 

Mỗi dòng phải được chạy riêng trong trường hợp này vì chương trình kết thúc trong ánh sáng (một khoảng trắng). Tuy nhiên, có thể viết điều này trên một hoặc một vài dòng trong cùng một chương trình.

Bóng tối thông thường (█) tăng một thanh ghi lên 1 và lệnh ■ (một số loại bóng tối nhỏ) xuất ra nội dung của thanh ghi.

Perl 5, 86 75 71 66 byte

Tất cả ^Fđều là các ký tự điều khiển bằng chữ (0x06 trong ASCII) và do đó là một byte đơn.

$[          # array start index, defaults to 0                                  2
!$[         # !0 is 1                                                           3
$^F         # max sys file descriptor number, 2 on all sane systems             2
++$^F       # 2 + 1                                                             4
~-$]        # 5 - 1                                                             4
int$]       # $] is Perl version, int truncates                                 5
length$~    # 1 + 5                                                             8
~~exp$^F    # floor(e^2)                                                        7
$^F<<$^F    # 2 bitshift-right 2                                                6
-!$[+ord$/  # -1 + 10                                                          10
ord$/       # input record separator, newline by default, ord gets ASCII val    5
ord($"^$/)  # 32 + 10                                                          10

Cảm ơn msh210 vì đã lưu 11 byte và Dom Hastings cho 9 byte!

MATL, 30 byte

O
l
H
I
K
Kl+
HI*
KYq
HK*
IH^
K:s
IH^:sI-

H, Ivà Klà các hằng số được xác định trước cho 2, 3 và 4 (như pi). Ovà llà các hàm trả về một ma trận các số không ( O) hoặc các hàm ( l), kích thước mặc định là 1x1. :tạo một vectơ và tính stổng của nó, vì vậy K:stạo một vectơ từ 1 đến 4 và tính tổng của nó để có được 10. Yqlà hàm nguyên tố thứ n, cũng KYqlà số nguyên tố thứ 4, 7.

Prolog, 113 99 byte

Đoạn trích:

e-e              % 0.0
e/e              % 1.0
e/e+e/e          % 2.0
ceil(e)          % 3
ceil(pi)         % 4
ceil(e*e-e)      % 5
ceil(e+e)        % 6
floor(e*e)       % 7
ceil(e*e)        % 8
ceil(pi*e)       % 9
ceil(pi*pi)      % 10
ceil(e^e*e)      % 42

Kết hợp các hằng số toán học e và pi theo các cách khác nhau được chuyển đổi thành int.

Chỉnh sửa: Đã lưu 14 byte bằng cách sử dụng số float cho 0-2.

PHP, 157 145 91 byte

Lần đầu tiên đăng bài trên Code Golf, tôi nghĩ rằng tôi sẽ thử. Cuối cùng tôi sẽ khá hơn: P Nếu bạn thấy bất kỳ điểm rõ ràng nào (với bạn) nơi tôi có thể lưu các ký tự, hãy cho tôi biết.

EDIT: Nhận ra tôi không cần dấu chấm phẩy, vì đây chỉ là những đoạn trích.

EDIT2: Cảm ơn Blackhole vì nhiều gợi ý!

LC_ALL
DNS_A
~~M_E
~~M_PI
LOCK_NB 
LC_TIME
LOG_INFO
INI_ALL
IMG_WBMP
SQL_DATE
SQL_TIME
LOG_INFO*INI_ALL

Python 2, 191 159 158 157 156 149 146 byte

Trình đầu tiên của tôi bao giờ, tôi hy vọng tôi có mọi thứ đúng! Dựa trên thời gian tôi dành cho việc này, tôi đoán chắc chắn có một cái tốt hơn cho một vài trong số họ.

# 0 | Bytes : 5
int()

# 1 | Bytes : 5
+True

# 2 | Bytes : 6
-~True

# 3 | Bytes : 8
-~-~True

# 4 | Bytes : 10
-~-~-~True

# 5 | Bytes : 12
-~-~-~-~True

# 6 | Bytes : 14
-~-~-~-~-~True

# 7 | Bytes : 16
-~-~-~-~-~-~True

# 8 | Bytes : 15
a=True;a<<a+a+a

# 9 | Bytes : 19
a=True;(a<<a+a+a)+a

# 10 | Bytes : 20
int(`+True`+`int()`)

# 42 | Bytes : 16
~-len(`license`)
# Especially proud of this one !

Total byte count: 146

Rất cám ơn FryAmTheEggman!

C #, không sử dụng, 234 byte

new int()                       // 0
-~new int()                     // 1
-~-~new int()                   // 2
-~-~-~new int()                 // 3
-~-~-~-~new int()               // 4
-~-~-~-~-~new int()             // 5
-~-~-~-~-~-~new int()           // 6
-~-~-~-~-~-~-~new int()         // 7
-~-~-~-~-~-~-~-~new int()       // 8
(int)System.ConsoleKey.Tab      // 9
(int)System.TypeCode.UInt32     // 10
(int)System.ConsoleKey.Print    // 42

Điều này nhàm chán hơn nhiều so với ban đầu tôi nghĩ nó sẽ xảy ra. Tôi đã có ý tưởng khá đa dạng, chẳng hạn như new[]{true}.Lengthvà true.GetHashCode()và typeof(int).Name.Lengthvà uint.MinValuevv, nhưng new int()đánh bại họ cả.

PowerShell, 147 byte

Chúng sử dụng +để ngầm định mọi thứ cho số nguyên. Các số sau sử dụng Enums từ .Net Framework unerpinnings của PowerShell có giá trị đúng.

+$a                          #0, 3 bytes (unset vars are $null, +$null == 0)
+$?                          #1, 3 bytes (bool previous result, default $true, +$true == 1)
$?+$?                        #2, 5 bytes (same as #1, twice)
$?+$?+$?                     #3, 8 bytes (beats [Int][Math]::E)
$?+$?-shl$?                  #4, 11 bytes (-shl is shift-left)
$?+$?+$?+$?+$?               #5, 14 bytes
$?+$?+$?-shl$?               #6, 14 bytes (enum value, + casts to integer)
+[TypeCode]::Int16           #7, 18 bytes
$?+$?-shl$?+$?               #8, 14 bytes
+[consolekey]::tab           #9, 18 bytes
+[TypeCode]::UInt32          #10, 19 bytes
+[consolekey]::Print         #42, 20 bytes

#Total:                      147 bytes

• -~-~-~được sử dụng trong JavaScript, các câu trả lời C # và PHP sẽ có - -bnot - -bnot - -bnottrong PowerShell.

• x^ylũy thừa được sử dụng trong các câu trả lời Perl hoặc x**ytrong Python hoặc JavaScript ES7, sẽ là[Math]::Pow($x,$y)

• hằng số e và Pi là các ký tự nặng [Math]::Evà[Math]::PI

DC , 35 byte

K
KZ
IZ
Iv
EI-
FI-
IZd*
IIZ/
Ivd+
IIv-
IIZ-
IKZ-
I
EdE++

Để kiểm tra các đoạn trích nối thêm một fđể in ngăn xếp và chuyển chuỗi đó sang dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 byte

0 ~ 10:

X
cosh(X
int(e
int(π
-int(-π
int(√(π³
int(π+π
int(e²
int(eπ
int(π²
Xmax

42:

int(π²/ecosh(π

Trong TI-BASIC, tất cả các biến một chữ cái chưa được khởi tạo bắt đầu từ 0 và Xmax(ranh giới cửa sổ bên phải của màn hình đồ thị) bắt đầu từ 10.

Hằng số toán học πlà một byte , nhưng elà hai byte.

Python 2, 306 275 274 byte

Tôi đã sử dụng thực tế là với bất kỳ x (số nguyên nào chứ không phải 0) biểu thức x/xbằng 1 và chơi xung quanh với một số thao tác bitwise.

Tôi đã điều chỉnh các đoạn sao cho chúng vẫn đáp ứng các yêu cầu (cảm ơn @nimi, điều này đã tiết kiệm cho tôi 24 byte), nhưng bạn phải kiểm tra chúng theo cách thủ công. Đây là mã và số byte riêng lẻ:

zero.py Bytes: 7
len({})
--------------------------
one.py  Bytes: 12
r=id(id)
r/r
--------------------------
two.py  Bytes: 17
r=id(id)
-(~r/r)
--------------------------
three.py    Bytes: 20
r=id(id)
-(~r/r)|r/r
--------------------------
four.py Bytes: 20
r=~id(id)/id(id)
r*r
--------------------------
five.py Bytes: 26
r=~id(id)/id(id)
(r*r)|r/r
--------------------------
six.py  Bytes: 25
r=~id(id)/id(id)
(r*r)|-r
--------------------------
seven.py    Bytes: 27
r=~id(id)/id(id)
-~(r*r|-r)
--------------------------
eight.py    Bytes: 24
r=-(~id(id)/id(id))
r<<r
--------------------------
nine.py Bytes: 29
r=-(~id(id)/id(id))
r-~(r<<r)
--------------------------
ten.py  Bytes: 31
r=~id(id)/id(id)
-r*((r*r)|r/r)
--------------------------
answer.py   Bytes: 37
r=-(~id(id)/id(id))
(r<<r*r)|(r<<r)|r
--------------------------
Total byte count: 274

Toán ++, tổng cộng 92 byte

0 (1 byte): a

1 (2 byte):!a

2 (3 byte):_$e

3 (4 byte): _$pi

4 (7 byte): _$e+_$e

5 (8 byte): _($e+$e)

6 (9 byte): _$pi+_$pi

7 (8 byte): _($e*$e)

8 (9 byte): _($e*$pi)

9 (10 byte): _($pi*$pi)

10 (12 byte): _$e*_($e+$e)

42 (19 byte): _($pi+$pi)*_($e*$e)

Javascript (Trình duyệt Env), 155 136 130 byte

+[]
-~[]
-~-~[]
-~-~-~[]
-~-~-~-~[]
-~-~-~-~-~[]
-~-~-~[]<<-~[]
-~-~-~-~-~-~-~[]
-~[]<<-~-~-~[]
~(~[]+[]+-[])
-~[]+[]+-[]
-~(top+top.s).length // Requires browser environment

Cảm ơn:
@Ismael Miguel : 155 -> 136 -> 130 byte

Nghiêm túc, 39 33 byte

Những thứ trong ngoặc đơn là giải thích:

 (single space, pushes size of stack, which is 0 at program start)
 u (space pushes 0, u adds 1 (1))
 ⌐ (space pushes 0, ⌐ adds 2 (2))
 u⌐ (space pushes 0, u adds 1 (1), ⌐ adds 2 (3))
 ⌐⌐ (space pushes 0, ⌐⌐ adds 2 twice (4))
 ⌐P (space pushes 0, ⌐ adds 2 (2), P pushes the 2nd prime (5))
Hl▓ (H pushes "Hello, World!", l pushes length (13), ▓ pushes pi(13) (6))
QlP (Q pushes "QlP", l pushes length (3), P pushes the 3rd prime (7))
Ql╙ (Q pushes "QlP", l pushes length (3), ╙ pushes 2**3 (8))
úl▓ (ú pushes the lowercase English alphabet, l pushes length (26), ▓ pushes pi(26) (9))
 u╤ (space pushes 0, u adds 1 (1), ╤ pushes 10**1 (10))
HlPD (H pushes "Hello, World!", l pushes length (13), P pushes the 13th prime (43), D subtracts 1 (42))

Hexdumps chương trình:

20
2075
20a9
2075a9
20a9a9
20a950
486cb2
516c50
516cd3
a36cb2
2075d1
486c5044

Cảm ơn quintopia cho 6 byte!

dc, 42 byte

K
zz
OZ
zzz+
OZd*
OdZ/
zzzz*
Ozz+-
OdZ-
Oz-
O
Od+dz++

Các kết quả

0
1
2
3
4
5
6
7
8
9
10
42

Không có nhiều cách để tạo số mới với dc. Tôi sử dụng O: cơ sở đầu ra, ban đầu 10; K: độ chính xác, ban đầu 0; zđộ sâu chồng, ban đầu 0; Zchữ số có nghĩa của toán hạng. Chúng tôi kết hợp những điều này với các toán tử số học thông thường.

Chương trình kiểm tra

#!/bin/bash

progs=(                                         \
    "K"                                         \
    "zz"                                        \
    "OZ"                                        \
    "zzz+"                                      \
    "OZd*"                                      \
    "OdZ/"                                      \
    "zzzz*"                                     \
    "Ozz+-"                                     \
    "OdZ-"                                      \
    "Oz-"                                       \
    "O"                                         \
    "Od+dz++"                                   \
)

a=0
results=()
for i in "${progs[@]}"
do
    results+=($(dc -e "${i}p"))
    (( a+=${#i} ))
done

echo "#dc, $a bytes"
echo
printf '    %s\n' "${progs[@]}"
echo
echo '##Results'
echo
printf '    %s\n' "${results[@]}"

Toán học, 101 byte

a-a
a/a
⌊E⌋
⌈E⌉
⌈π⌉
⌊E+E⌋
⌈E+E⌉
⌊E*E⌋
⌈E*E⌉
⌈E*π⌉
⌈π*π⌉
⌊π*π^π/E⌋

Tôi khá chắc chắn một số trong số này là tối ưu. Những dấu ngoặc tròn thực sự đắt tiền.

Để thống nhất, hai cái đầu tiên cũng có thể E-Evà E/Edĩ nhiên, nhưng tôi nghĩ rằng nó khá tiện lợi để có được 0và 1từ một tính toán với các biến không xác định.

Japt , 34 33 30 byte

Lưu 1 byte nhờ @ThomasKwa

T
°T
C-A
D-A
E-A
F-A
G-A
°G-A
Iq
´A
A
H+A

Dưới đây là ý nghĩa của từng ký tự khác nhau:

T    0
A    10
B    11
C    12
D    13
E    14
F    15
G    16
H    32
I    64
q    sqrt on numbers
°    ++
´    --

Tuyệt vời , 98 byte

Không thú vị lắm, nó phụ thuộc vào các ?nthiết bị biến bất kỳ viên bi nào thành giá trị ngẫu nhiên trong phạm vi 0..n (bao gồm) một tác dụng phụ của việc này là ?0biến bất kỳ viên bi nào thành 0 bất kể đầu vào. Tôi nghĩ rằng việc sử dụng chữ được cho phép vì giá trị không ảnh hưởng đến kết quả và không có cách nào khác để gọi hàm một lần trong Marbelous.

0:

00  # A hexadicemal literal: value 0
?0  # Turn any marble into a random value from the range 0..0 (inclusive)

1:

00
?0
+1  # increment by one

...

9:

00
?0
+9

10:

00
?0
+A  # increment by 10

42:

00
?0
+L  # increment by 21
+L

> <> , 86 byte

• 0: ln;
• 1: lln;
• 2: llln;
• 3: lll+n;
• 4: lll:+n;
• 5: llll+n;
• 6: llll++n;hoặcllll:+n;
• 7: lllll+n;
• số 8: lllll:+n;
• 9: lllll++n;hoặcllllll+n;
• 10: llll+:+n;hoặclll:l+*n;
• 42: llll*ll+*n;

Dựa vào kích thước ngăn xếp để có được chữ của nó.

Công thức MS Excel, 163 151 150 143 byte

Không chính xác là một ngôn ngữ lập trình, nhưng ở đây nó đi ...

0:  -Z9                         (03 bytes)
1:  N(TRUE)                     (07 bytes)
2:  TYPE(T(Z9))                 (11 bytes)
3:  TRUNC(PI())                 (11 bytes)
4:  TYPE(TRUE)                  (10 bytes)
5:  ODD(PI())                   (09 bytes)
6:  FACT(PI())                  (10 bytes)
7:  ODD(PI()+PI())              (14 bytes)
8:  EVEN(PI()+PI())             (15 bytes)
9:  TRUNC(PI()*PI())            (16 bytes)
10: EVEN(PI()*PI())             (15 bytes)
42: EVEN(CODE(-PI())-PI())      (22 bytes)

PI()được sử dụng trong hầu hết các trường hợp vì đây là cách ngắn hơn (mà tôi biết) để giới thiệu một giá trị số mà không sử dụng một số hoặc chuỗi ký tự. Nchuyển đổi nhiều thứ khác nhau (bao gồm booleans) thành số và Tchuyển đổi nhiều thứ khác nhau thành văn bản. TYPEtrả về 2 cho một đối số văn bản và 4 cho một đối số boolean. TRUNCloại bỏ phần phân số (nghĩa là làm tròn số dương xuống), làm EVENtròn đến số chẵn tiếp theo và làm ODDtròn đến số lẻ tiếp theo. CODE(-PI())là mã ASCII của ký tự đầu tiên của chuyển đổi thành văn bản của -π, tức là 45 (cho "-").

EDIT: Đã xóa các dấu bằng nhau khỏi số byte (-12!) - như được chỉ ra bởi Nᴮᶻ trong các bình luận, chúng không được phép đưa vào.

EDIT 2: Giả sử phần còn lại của bảng tính trống, có thể sử dụng tham chiếu đến một ô trống là 0 (một lần nữa, được đề xuất bởi Nᴮᶻ) với điều kiện chúng tôi bao gồm dấu trừ (hoặc sử dụng nó trong biểu thức số khác) để giải quyết loại mơ hồ.

DUP , 68 byte

[
 [
  [
[)]!
[ )]!
[  )]!
[)~_]!
[ )~_]!
[  )~_]!
[   )~_]!
[)$+]!
[ )$+~_$+]!

Try it here.

Có rất nhiều cách để làm điều này, nhưng tôi đang lạm dụng stack return cho cái này.

Giải trình

Để tìm hiểu đầy đủ điều này, bạn cần hiểu hành vi của DUP liên quan đến lambdas. Thay vì tự đẩy lambda vào stack, nó thực sự đẩy IP hiện tại lên stack khi phát hiện lambda. Điều đó có thể giải thích 3 đoạn đầu tiên, liên quan đến lambdas.

Các đoạn tiếp theo sử dụng ngăn xếp trở lại. Khi !được thực thi, IP hiện tại được đẩy đến ngăn xếp trả về và đỉnh của ngăn xếp được đặt làm IP mới để bắt đầu thực hiện lambda. )bật một số từ ngăn xếp trở lại vào ngăn xếp dữ liệu.

Điều đó khá đủ để giải thích phần còn lại của các đoạn. Nếu bạn vẫn không nhận được nó, hãy nhớ rằng Stepnút này khá tiện dụng!

05AB1E, 40 38 24 byte

¾
X
Y
XÌ
Y·
T;
T;>
T;Ì
TÍ
T<
T
žwT+

• Đẩy ngược
• Đẩy 1
• Đẩy 2
• Đẩy 1 + 2
• Đẩy 2 * 2
• Đẩy 10/2
• Đẩy (10/2) +1
• Đẩy (10/2) +2
• Đẩy 10-2
• Đẩy 10-1
• Đẩy 10
• Đẩy 32, 10, thêm

D1ffe7e45e , 112

0
02
020
0202
02020
020202
0202020
02020202
020202020
0202020202
02020202020
202020202020202020202020202020202020202020

Mỗi dòng là một đoạn khác nhau.

Các số trong chương trình không được tính là số chữ vì chúng chỉ được sử dụng làm lệnh.

Người cuối cùng chắc chắn có thể được chơi golf nhiều hơn.

EDIT: Tôi đã làm cho trình thông dịch làm việc và tất cả các đoạn làm việc. Nếu bạn muốn tự kiểm tra, hãy thêm 0f0fvào cuối đoạn trích để chương trình kết thúc.

Pyth, 35 34 33 byte

-1 byte bởi @Mimarik

Có một số khả năng cho một số chương trình.

0, 1 byte

Z

1, 2 byte

hZ
!Z

2, 3 byte

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 byte

l`d

4, 3 byte

l`b
eCN

5, 4 byte

hl`b
telG

6, 3 byte

elG

7, 4 byte

tttT
helG

8, 3 byte

ttT

9, 2 byte

tT

10, 1 byte

T

42, 4 byte

yhyT

Tất cả những điều này liên quan đến các lệnh double ( y), +1 ( h) và -1 ( t) cơ bản hoặc l(độ dài của chuỗi). Biến Z được khởi tạo bằng không.

Đối với 5, bđược khởi tạo thành một ký tự dòng mới. Backtick đưa ra "\n"(bao gồm cả dấu ngoặc kép và độ dài của chuỗi đó là 4.

Hãy thử chúng ở đây !