หากคุณชอบสิ่งนี้ให้ลองเข้าร่วมใน:

• เกมDyalog APL 2016 ปีอย่างเป็นทางการ

• Dyalog APL 2017 Code Golf Challengeรายเดือน

สร้างตัวอย่างข้อมูล 12 นิพจน์ในภาษาเดียวกันซึ่งส่งผลให้ตัวเลข 0 ถึง 10 และ 42 ตามลำดับ แต่ไม่มีการเขียนข้อมูลตัวอักษรสตริงหรือข้อมูลตัวอักษรใด ๆ

ข้อมูลบิวด์อินเช่นPI()และALPHABET()ใช้ได้ดีเช่นของ U, X, Y, Z และค่าคงที่ของ CJam และค่าคงที่ของการประมวลผล BLORD, CHORD, CENTER, BREAK และ LINES ของการประมวลผล

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

ตัวอย่างทั้งหมดจะต้องถูกต้องในคอมพิวเตอร์ของผู้ส่งในเวลาที่ส่ง (ตามที่รายงานโดย SE) แต่อาจไม่พึ่งพาสภาพท้องถิ่นที่ผิดปกติเช่นจำนวนไฟล์ในไดเรกทอรีวันที่หรือเวลาที่แน่นอนหรือข้อมูลเฉพาะจากผู้ใช้ .

ตัวอย่างของตัวอย่างที่ถูกต้อง

3: INT(LOG10(YEAR(TODAY()))) เพราะมันยังคงเป็นจริงในอนาคตอันใกล้
4: CUBICROOT(LEN(CHARACTERSET())) เนื่องจากชุดอักขระ 256 ตัวอักษรเป็นเรื่องธรรมดามาก
8: SQRT(SYSTEMTYPE()) เนื่องจากระบบ 64 บิตเป็นเรื่องธรรมดามาก

ตัวอย่างของตัวอย่างที่ไม่ถูกต้อง

5: LEN(USERNAME()) เพราะคนส่วนใหญ่ไม่ใช้ "ผู้ดูแลระบบ" เป็นการเข้าสู่ระบบ :-)
9: LOG10(SYSTEMMEMORY()) เพราะมันใช้งานได้กับระบบที่มีหน่วยความจำ 1 GB
42 เท่านั้น: CODE("*") เพราะมันมีสตริง / ตัวอักษรตามตัวอักษร

ผลลัพธ์ของข้อมูลโค้ดแต่ละรายการจะต้องส่งผลให้มีจำนวนจริง (ค่า, int, float ฯลฯ ) ที่สามารถใช้สำหรับการคำนวณเพิ่มเติมโดยใช้ภาษาเดียวกับตัวอย่างเช่นไม่ใช่สตริงข้อความที่แสดงถึงตัวเลขนั้น

อนุญาตเฉพาะภาษาที่ใช้ตัวอักษร

คะแนนคือจำนวนไบต์ทั้งหมดของข้อมูลโค้ดทั้ง 12 รวมกัน บรรทัดใหม่ที่แยกข้อมูลโค้ดจะไม่ถูกนับ

โปรดทราบว่ากฎข้างต้นอาจป้องกันบางภาษาจากการเข้าร่วมแม้ว่าพวกเขาจะทัวริงเสร็จสมบูรณ์

คำถามที่พบบ่อย

Qโปรแกรมสามารถรับอินพุตได้หรือไม่?
ตอบใช่ แต่คุณอาจไม่เพียงแค่ขอให้ป้อนข้อมูลและป้อนหมายเลขที่เกี่ยวข้อง

Qอนุญาตให้ใช้ตัวเลขทางกายภาพ (ไม่ใช่ข้อมูล) หรือไม่ ใช่เช่น
LOG10()

Qสัญลักษณ์ในทับทิมนับเป็นตัวอักษรได้หรือไม่?
ตอบใช่

ถามคะแนนรวมบรรทัดใหม่ระหว่างข้อมูลโค้ดแต่ละอันหรือไม่ เลขที่

ถาม TI-BASIC "ใช้ตัวอักษร" มากพอที่จะใช้งานได้หรือไม่?
ตอบใช่

ถามการนับเป็นเท็จและจำนวนจริงเป็นตัวอักษรตัวเลขหรือไม่
ตอบไม่ได้

Qเราสามารถใช้ตัวอักษรตัวเลขเพื่อเรียกฟังก์ชั่นได้ไหมถ้าเป็นวิธีเดียวและหมายเลขนั้นไม่ส่งผลต่อการส่งออกของฟังก์ชั่น?
ตอบใช่ถ้าเป็นวิธีปกติในการเขียนรหัสในภาษาของคุณ

Qภาษาของฉันถือว่ามี [บางสิ่ง] ที่จุดเริ่มต้นของแต่ละโปรแกรม / การแสดงออก ฉันต้องรวมมันไว้หรือไม่หรือข้อมูลโค้ดของฉันควรทำงานถ้าวางไว้กลางโปรแกรม
ตอบพวกเขาควรทำงานระหว่างโปรแกรม / นิพจน์

คำถามเกี่ยวกับตัวอักษร regex คืออะไร
สิ่งต้องห้ามยกเว้นภาษาที่ทำ regexes เท่านั้น

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

ถามฉันขอสมมติว่าแผ่นสร้างสำเร็จรูปมีลักษณะคล้ายint main() {}...กันหรือไม่?
ตอบใช่

ถามประเภทข้อมูลออกที่ได้รับอนุญาตอะไร?
Aประเภทข้อมูลตัวเลขใด ๆ เช่น int, float, ฯลฯ

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

Qอนุญาตให้ตั้งค่าตัวแปรล่วงหน้าได้หรือไม่?
ตอบใช่และมันจะถูกรีเซ็ต (หากมีการเปลี่ยนแปลง) สำหรับทุกตัวอย่าง

ถาม considered และeถือเป็นตัวอักษรตัวเลขหรือไม่
ตอบไม่ได้คุณสามารถใช้มันได้

ถามฉันขอคืนค่า 4 และ 2 ในเซลล์ต่าง ๆ ได้ 42 หรือไม่?
ตอบไม่ได้พวกเขาจะต้องเชื่อมต่อเป็นหนึ่งหมายเลข

Qไบต์หรือตัวละคร? ไบต์ แต่คุณอาจเลือกเพจที่ต้องการใด ๆ

ถามอาจใช้ฟังก์ชั่นคงที่และตัวแปรที่ตั้งไว้ล่วงหน้าเช่น J's 9:, Actually 9และ Pretzel 9หรือไม่
ตอบใช่ถ้าคำศัพท์มี จำกัด (19 สำหรับ J, 10 สำหรับจริงและ Pretzel)

Hexagonyขนาด 13 ไบต์

1
2
3
4
5
6
7
8
9
10
42

ลองออนไลน์!

ใน Hexagony, 0ผ่าน9มีฟังก์ชั่นที่คูณหน่วยความจำในปัจจุบันโดย 10 แล้วเพิ่มจำนวนตัวแทนจากชื่อฟังก์ชัน 0ดังนั้นตัวอย่างแรกคือว่างเปล่าเป็นความทรงจำที่เริ่มต้นจากการเป็น

ตัวอย่างเช่นถ้าหน่วยความจำในปัจจุบัน65การดำเนินงานฟังก์ชั่นที่จะทำให้หน่วยความจำในปัจจุบัน3653

(สำหรับ downvoters: downvote สิ่งที่คุณต้องการ; ฉันพร้อมแล้ว)

Funciton , 1222 ไบต์

นอกเหนือจากตัวอักษรตัวเลขมีสองวิธีที่ฉันสามารถสร้างมูลค่า (ค่าใด ๆ เลย) ใน Funciton: การแสดงออกของ stdin และ lambda Stdin เป็นกล่องเดียวในขณะที่การแสดงออกแลมบ์ดาเต็มต้องใช้ไวยากรณ์มากขึ้นดังนั้นฉันจะไปกับ stdin อย่างไรก็ตามในขณะที่ stdin สามารถเป็นอะไรก็ได้งานต่อไปนี้ทั้งหมดไม่ว่าจะมีการป้อนข้อมูลใด

ฟังก์ชันไลบรารีทั้งหมดที่ใช้ที่นี่มีอยู่ก่อนที่จะมีการโพสต์ความท้าทาย

0 (40 ไบต์ใน UTF-16)

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

สิ่งนี้ใช้ไวยากรณ์ดิบสำหรับน้อยกว่า ค่าจะไม่ต่ำกว่าตัวเองดังนั้นผลลัพธ์ของสิ่งนี้คือ 0

1 (52 ไบต์ใน UTF-16)

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

⌑ส่งกลับลำดับขี้เกียจที่มีองค์ประกอบเดียวและɕนับจำนวนองค์ประกอบ (ลำดับขี้เกียจขี้เกียจพอที่ข้อมูลนี้ไม่ได้ประเมิน stdin เลย!)

2 (70 ไบต์ใน UTF-16)

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

= 2¹ ʂสร้างลำดับทั้งหมดของลำดับและเปลี่ยนลำดับขององค์ประกอบnเป็นหนึ่งเดียวกับ2ⁿ

3 (88 ไบต์ใน UTF-16)

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

= 2 + 1. ♯เพิ่มค่าด้วย 1

4 (88 ไบต์ใน UTF-16)

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

= 2²

5 (106 ไบต์ใน UTF-16)

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

= 4 + 1

6 (106 ไบต์ใน UTF-16)

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

= 3 แฟคทอเรียล

7 (110 ไบต์ใน UTF-16)

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

= A (2, 2) (ฟังก์ชัน Ackermann)

8 (118 ไบต์ใน UTF-16)

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

= 2 << 2 (เลื่อนซ้าย)

9 (128 ไบต์ใน UTF-16)

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

= 3 × 3

10 (146 ไบต์ใน UTF-16)

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

= 5 + 5

42 (170 ไบต์ใน UTF-16)

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

= 6 × (6 + 1)

JavaScript, 144 141 140 138 132 125 123 ไบต์

ด้วยความช่วยเหลือจาก@ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynnและ@ 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>

Mouse-2002 , 27 26 17 14 ไบต์

ข้อมูลโค้ดแรกผลักดัน 0-10 และZR+ผลักดันให้25แล้ว17และเป็น25 17 + 42 =1

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

CJam, 27 24 ไบต์

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

ขอบคุณ @ MartinBüttnerสำหรับ -1 ไบต์!

ลองออนไลน์!

Brainfuck, 70 ไบต์

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

แต่ละบรรทัดจะต้องทำงานแยกกัน

10 ข้อแรกคือการอธิบายตนเอง: เราเพิ่มมูลค่าของเซลล์ผ่านการบวกแต่ละครั้ง

42 นั้นซับซ้อนกว่าเยอะมาก มันขึ้นอยู่กับความจริงที่ล่าม brainfuck ส่วนใหญ่ใช้เซลล์ 8 บิตซึ่งหมายความว่าการดำเนินการทั้งหมดจะทำแบบโมดูโล 256 --ชุดเซลล์ # 0 ถึง 254 จากนั้นเราป้อนลูปที่ทำงานจนกว่าเซลล์ # 0 คือ 0 แต่ละการวนซ้ำ เพิ่ม 1 ไปยังเซลล์ # 1 และเพิ่ม 6 ไปยังเซลล์ # 0 ลูปนี้ทำงาน 43 ครั้งดังนั้นเซลล์ # 1 คือ 43 ในที่สุดเราก็ลบ 1 จากเซลล์ # 1 เพื่อให้เป็น 42

ฉันได้รับประสิทธิภาพสูงสุด 42 เท่าที่เคยพบจากhttp://esolangs.org/wiki/Brainfuck_constants

ความมืด , 339 303 ไบต์

ซึ่งเป็นที่ที่มืดจริงๆส่อง รับมัน : ~)!

โดยไม่ต้องพิมพ์ (แทนที่ช่องว่างด้วย\sในบรรทัดแรกเนื่องจากมันจะไม่แสดงเป็นอย่างอื่น):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

ด้วยการพิมพ์:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

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

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

ความมืดปกติ (█) เพิ่มการลงทะเบียน 1 และการเรียนการสอน■ (ความมืดเล็ก ๆ บางประเภท) จะส่งออกเนื้อหาของการลงทะเบียน

Perl 5, 86 75 71 66 ไบต์

^Fs ทั้งหมดเป็นอักขระควบคุมตามตัวอักษร (0x06 ใน ASCII) และด้วยเหตุนี้จึงเป็นไบต์เดียว

$[          # 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

ขอบคุณmsh210สำหรับการบันทึก 11 ไบต์และDom Hastingsสำหรับ 9 ไบต์!

MATL 30 ไบต์

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

H, IและKเป็นค่าคงที่ที่กำหนดไว้ล่วงหน้าสำหรับ 2, 3 และ 4 (เช่นpi) Oและlเป็นฟังก์ชั่นที่คืนค่าเมทริกซ์ของศูนย์ ( O) หรือฟังก์ชั่น( l), ขนาดเริ่มต้นคือ 1x1 :ทำเวกเตอร์และsผลรวมมันK:sทำเวกเตอร์ตั้งแต่ 1 ถึง 4 และหาผลรวมเพื่อให้ได้ 10 Yqคือฟังก์ชันไพรม์ n-th ดังนั้นKYqไพรเวตที่ 4, 7

ภาษาอารัมภบท113 99 ไบต์

เกร็ดเล็กเกร็ดน้อย:

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

รวมค่าคงที่ทางคณิตศาสตร์eและpiด้วยวิธีต่างๆที่แปลงเป็น int

แก้ไข:บันทึก 14 ไบต์โดยใช้การลอยเป็น 0-2

PHP, 157 145 91 ไบต์

ครั้งแรกที่โพสต์บน Code Golf ฉันคิดว่าฉันจะให้มันยิง ในที่สุดฉันก็จะดีขึ้น: P หากคุณเห็นจุดที่ชัดเจน (กับคุณ) ที่ฉันสามารถบันทึกอักขระให้ฉันรู้

แก้ไข: รับรู้ฉันไม่ต้องการเครื่องหมายอัฒภาคเนื่องจากสิ่งเหล่านี้เป็นเพียงตัวอย่าง

EDIT2: ขอบคุณ Blackhole สำหรับคำแนะนำมากมาย!

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 bytes

การส่งครั้งแรกของฉันฉันหวังว่าฉันจะได้ทุกอย่างถูกต้อง! ขึ้นอยู่กับเวลาที่ฉันใช้ไปกับสิ่งนี้

# 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

ขอบคุณ FryAmTheEggman มาก!

C # ไม่มีการใช้งาน 234 ไบต์

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

มันน่าเบื่อมากกว่าที่ฉันคิดไว้ในตอนแรก ผมมีความคิดที่แตกต่างกันสวยเช่นnew[]{true}.Lengthและtrue.GetHashCode()และtypeof(int).Name.Lengthและuint.MinValueฯลฯ แต่new int()ชนะพวกเขาทั้งหมด

PowerShell, 147 ไบต์

สิ่งเหล่านี้ใช้+เพื่อแปลงสิ่งของเป็นจำนวนเต็มโดยปริยาย ตัวเลขในภายหลังใช้ Enums จาก. Net Framework unerpinnings ของ PowerShell ซึ่งมีค่าที่เหมาะสม

+$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

• -~-~-~ใช้ใน JavaScript คำตอบ C # และ PHP จะอยู่- -bnot - -bnot - -bnotใน PowerShell

• x^yการยกกำลังที่ใช้ในคำตอบ Perl หรือx**yใน Python หรือ JavaScript ES7 จะเป็น[Math]::Pow($x,$y)

• ค่าคงที่eและPiเป็นตัวละครที่หนัก[Math]::Eและ[Math]::PI

DC , 35 ไบต์

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

ในการทดสอบข้อมูลโค้ดผนวกfพิมพ์สแต็คและผ่านสตริงที่dc:

$ echo 'EdE++f' | dc
42

TI-BASIC, 41 ไบต์

0 ~ 10:

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

42:

int(π²/ecosh(π

ใน TI-BASIC ตัวแปรตัวอักษรตัวเดียวทั้งหมดเริ่มต้นที่ 0 และXmax(ขอบเขตหน้าต่างด้านขวาของหน้าจอกราฟ) เริ่มต้นที่ 10

ค่าคงที่ทางคณิตศาสตร์πคือหนึ่งไบต์แต่eเป็นสองไบต์

Python 2, 306 275 274 bytes

ฉันใช้ความจริงที่ว่าสำหรับxใด ๆ(จำนวนเต็มและไม่ใช่ 0) นิพจน์x/xเท่ากับ 1 และเล่นด้วยการดำเนินการระดับบิต

ฉันปรับตัวอย่างข้อมูลเพื่อให้พวกเขายังคงเป็นไปตามข้อกำหนด (ขอบคุณ @nimi สิ่งนี้ช่วยฉัน 24 ไบต์) แต่คุณต้องทดสอบด้วยตนเอง นี่คือโค้ดและจำนวนไบต์แต่ละตัว:

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

คณิตศาสตร์ ++ รวม 92 ไบต์

0 (1 ไบต์): a

1 (2 ไบต์):!a

2 (3 ไบต์):_$e

3 (4 ไบต์): _$pi

4 (7 ไบต์): _$e+_$e

5 (8 ไบต์): _($e+$e)

6 (9 ไบต์): _$pi+_$pi

7 (8 ไบต์): _($e*$e)

8 (9 ไบต์): _($e*$pi)

9 (10 ไบต์): _($pi*$pi)

10 (12 ไบต์): _$e*_($e+$e)

42 (19 ไบต์): _($pi+$pi)*_($e*$e)

Javascript (Browser Env), 155 136 130 ไบต์

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

ขอบคุณ:
@Ismael Miguel : 155 -> 136 -> 130 bytes

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

คำอธิบายในวงเล็บคือ:

 (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 ของโปรแกรม:

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

ขอบคุณ quintopia เป็นเวลา 6 ไบต์!

dc, 42 ไบต์

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

ผล

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

มีหลายวิธีในการสร้างหมายเลขใหม่ด้วย dc ฉันใช้O: ฐานผลผลิตตอนแรก 10; K: ความแม่นยำเริ่มแรก 0; zความลึกของสแต็กเริ่มต้น 0;Zเลขนัยสำคัญของตัวถูกดำเนินการ เรารวมสิ่งเหล่านี้กับตัวดำเนินการทางคณิตศาสตร์ตามปกติ

โปรแกรมทดสอบ

#!/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[@]}"

Mathematica, 101 ไบต์

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

ฉันค่อนข้างมั่นใจว่าสิ่งเหล่านี้บางอย่างไม่ดีพอ วงเล็บปัดเศษนั้นมีราคาแพงมาก

เพื่อความมั่นคงทั้งสองอาจเป็นได้E-EและE/Eแน่นอน แต่ฉันคิดว่ามันค่อนข้างดีที่จะได้รับ0และ1จากการคำนวณด้วยตัวแปรที่ไม่ได้กำหนด

Japt , 34 33 30 ไบต์

บันทึก 1 ไบต์ขอบคุณ @ThomasKwa

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

นี่คือความหมายของตัวอักษรแต่ละตัวที่แตกต่างกัน:

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

Marbelousขนาด 98 ไบต์

ไม่น่าตื่นเต้นอย่างมากมันขึ้นอยู่กับ?nอุปกรณ์ที่เปลี่ยนหินอ่อนเป็นค่าสุ่มในช่วง 0..n (รวม) ผลข้างเคียงของสิ่งนี้คือ?0เปลี่ยนหินอ่อนเป็น 0 โดยไม่คำนึงถึงอินพุต ฉันคิดว่าอนุญาตให้ใช้ตัวอักษรได้เนื่องจากค่าไม่ส่งผลต่อผลลัพธ์และไม่มีวิธีอื่นในการเรียกใช้ฟังก์ชันหนึ่งครั้งใน 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 ไบต์

• 0: ln;
• 1: lln;
• 2: llln;
• 3: lll+n;
• 4: lll:+n;
• 5: llll+n;
• 6: llll++n;หรือllll:+n;
• 7: lllll+n;
• 8: lllll:+n;
• 9: lllll++n;หรือllllll+n;
• 10: llll+:+n;หรือlll:l+*n;
• 42: llll*ll+*n;

อาศัยขนาดสแต็กเพื่อรับค่าตัวอักษร

สูตร MS Excel, 163 151 150 143 ไบต์

ไม่ใช่ภาษาการเขียนโปรแกรม แต่ที่นี่มันจะไป ...

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()ใช้ในกรณีส่วนใหญ่เนื่องจากเป็นวิธีที่สั้นกว่า (ที่ฉันทราบ) เพื่อแนะนำค่าตัวเลขโดยไม่ต้องใช้ตัวเลขหรือสตริงตามตัวอักษร Nแปลงสิ่งต่าง ๆ (รวมถึงบูลีน) เป็นตัวเลขและTแปลงสิ่งต่าง ๆ เป็นข้อความ TYPEส่งคืน 2 สำหรับอาร์กิวเมนต์ข้อความและ 4 สำหรับอาร์กิวเมนต์บูลีน TRUNCทิ้งส่วนที่เป็นเศษส่วน (เช่นปัดเศษจำนวนบวกลง) EVENปัดเศษขึ้นเป็นจำนวนคู่ถัดไปและODDปัดเศษขึ้นเป็นจำนวนคี่ถัดไปCODE(-PI())คือรหัส ASCII ของอักขระตัวแรกของการแปลงเป็นข้อความของ-πเช่น 45 (สำหรับ "-")

แก้ไข: ลบเครื่องหมายเท่ากับจากการนับไบต์ (-12!) - ตามที่ชี้โดย N pointed ในความคิดเห็นพวกเขาไม่ควรรวม

แก้ไข 2: สมมติว่าส่วนที่เหลือของแผ่นงานว่างเปล่ามันเป็นไปได้ที่จะใช้การอ้างอิงไปยังเซลล์ว่างเปล่าเป็นศูนย์ (อีกครั้งแนะนำโดยNᴮᶻ) โดยที่เรารวมถึงเครื่องหมายลบ (หรือใช้ในการแสดงออกตัวเลขอื่น ๆ ) เพื่อแก้ไข พิมพ์ความกำกวม

DUP , 68 ไบต์

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

Try it here.

มีหลายวิธีในการทำเช่นนี้ แต่ฉันใช้งานคืนที่ซ้อนกันสำหรับอันนี้

คำอธิบาย

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

ตัวอย่างต่อไปใช้กองส่งคืน เมื่อ!มีการดำเนินการ IP ปัจจุบันจะถูกผลักไปที่สแต็กกลับและด้านบนของสแต็คถูกตั้งค่าเป็น IP ใหม่เพื่อเริ่มต้นการดำเนินการแลมบ์ดา )ดึงตัวเลขจากสแต็กส่งคืนไปยังสแต็กข้อมูล

มันค่อนข้างมากพอที่จะอธิบายตัวอย่างที่เหลือได้ หากคุณยังไม่ได้รับโปรดทราบว่าStepปุ่มนั้นมีประโยชน์มาก!

05AB1E, 40 38 24 ไบต์

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

• กด counter_variable
• กด 1
• กด 2
• กด 1 + 2
• กด 2 * 2
• กด 10/2
• กด (10/2) +1
• กด (10/2) +2
• กด 10-2
• กด 10-1
• กด 10
• กด 32, 10 และเพิ่ม

D1ffe7e45e , 112

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

แต่ละบรรทัดเป็นตัวอย่างที่แตกต่างกัน

ตัวเลขในโปรแกรมไม่นับเป็นตัวอักษรตัวเลขเนื่องจากใช้เป็นคำสั่งเท่านั้น

คนสุดท้ายสามารถเล่นกอล์ฟได้มากขึ้นอย่างแน่นอน

แก้ไข: ฉันได้ล่ามทำงานและตัวอย่างทั้งหมดทำงาน หากคุณต้องการทดสอบว่าตัวเองเพิ่ม0f0fไปที่ส่วนท้ายเพื่อให้โปรแกรมยุติ

Pyth, 35 34 33 ไบต์

-1 ไบต์โดย @Mimarik

มีความเป็นไปได้หลายอย่างสำหรับบางโปรแกรม

0, 1 ไบต์

Z

1, 2 ไบต์

hZ
!Z

2, 3 ไบต์

hhZ
eCG
eCd
lyd
lyb
lyN

3, 3 ไบต์

l`d

4, 3 ไบต์

l`b
eCN

5, 4 ไบต์

hl`b
telG

6, 3 ไบต์

elG

7, 4 ไบต์

tttT
helG

8, 3 ไบต์

ttT

9, 2 ไบต์

tT

10, 1 ไบต์

T

42, 4 ไบต์

yhyT

สิ่งเหล่านี้เกี่ยวข้องกับคำสั่งdouble ( y), +1 ( h) และ -1 ( t) พื้นฐานหรือl(ความยาวของสตริง) ตัวแปร Z ถูกเตรียมใช้งานเป็นศูนย์

สำหรับ 5 bจะเริ่มต้นเป็นอักขระขึ้นบรรทัดใหม่ Backtick ให้"\n" (รวมถึงเครื่องหมายคำพูดและความยาวของสตริงนั้นคือ 4

ลองที่นี่ !