Jika Anda suka ini, pertimbangkan untuk berpartisipasi dalam:

• The Official Dyalog APL 2016 Tahun Permainan

• Tantangan Golf Dyalog APL 2017 Code bulanan

Buat 12 cuplikan / ekspresi , dalam bahasa yang sama, yang menghasilkan angka 0 hingga 10, dan 42 masing-masing, tetapi tanpa menulis data numerik, string, atau karakter apa pun.

Data bawaan , suka PI()dan ALPHABET(), baik-baik saja, dan begitu juga misalnya konstanta CJam's U, X, Y, Z, dan A, dan Blend, CHORD, CENTER, BREAK, dan LINES Pemrosesan.

Setiap cuplikan harus dapat berdiri sendiri, artinya tidak saling bergantung. Namun, di dalam cuplikan tunggal, Anda dapat menetapkan variabel dan menggunakannya secara bebas, selama Anda merujuknya secara langsung berdasarkan nama, dan bukan melalui string yang berisi namanya.

Semua potongan harus valid pada komputer pengirim pada saat pengiriman (seperti yang dilaporkan oleh SE), tetapi tidak boleh bergantung pada kondisi lokal yang tidak biasa seperti jumlah file dalam direktori, tanggal atau waktu yang tepat, atau input spesifik dari pengguna .

Contoh cuplikan yang valid

3: INT(LOG10(YEAR(TODAY()))) karena tetap benar di masa mendatang
4: CUBICROOT(LEN(CHARACTERSET())) karena set karakter 256 huruf sangat umum
8: SQRT(SYSTEMTYPE()) karena sistem 64-bit sangat umum

Contoh cuplikan tidak valid

5: LEN(USERNAME()) karena kebanyakan orang tidak menggunakan "Admin" sebagai login :-)
9: LOG10(SYSTEMMEMORY()) karena hanya bekerja pada sistem dengan tepat 1 GB memori
42: CODE("*") karena mengandung string / karakter literal

Hasil dari setiap cuplikan harus menghasilkan angka aktual (nilai, int, float, dll.) Yang dapat digunakan untuk perhitungan lebih lanjut menggunakan bahasa yang sama dengan cuplikan, yaitu bukan string teks yang mewakili angka itu.

Hanya bahasa berbasis karakter yang diizinkan.

Skor adalah jumlah total byte dari semua 12 snippet yang digabungkan. Baris baru yang memisahkan snippet tidak dihitung.

Perhatikan bahwa aturan di atas dapat mencegah beberapa bahasa dari berpartisipasi, bahkan jika mereka Turing lengkap.

Faq

Q Dapatkah program menerima input apa pun?
J Ya, tetapi Anda mungkin tidak hanya meminta input dan memasukkan nomor yang relevan.

Q Apakah digit fisik (non-data) diizinkan?
A Ya, mis LOG10().

P Apakah Simbol dalam Ruby dihitung sebagai literal?
A Ya.

Q Apakah skor menyertakan baris baru di antara setiap cuplikan?
A No.

Q Apakah TI-BASIC "berbasis karakter" cukup valid?
A Ya.

Q Apakah false dan true dihitung sebagai angka literal?
A Tidak, mereka dapat diterima.

T Bisakah kita menggunakan angka literal untuk memanggil fungsi jika itu satu-satunya cara dan nomor tidak mempengaruhi output dari fungsi?
J Ya, jika itu adalah cara normal untuk menulis kode dalam bahasa Anda.

T Bahasa saya mengasumsikan ada [sesuatu] pada awal setiap program / ekspresi. Haruskah saya memasukkannya, atau haruskah cuplikan saya hanya berfungsi jika ditempatkan di tengah program / ekspresi?
A Mereka seharusnya bekerja di tengah-tengah program / ekspresi.

T Bagaimana dengan regex literal?
A Forbidden, kecuali untuk bahasa yang hanya melakukan regex.

T: Apakah satu bagian kode yang dapat mencetak semua angka yang ditentukan dapat diterima?
A Tidak, mereka harus terpisah dan saling independen.

T Bolehkah saya menganggap pelat baja mirip int main() {}...atau setara?
A Ya.

T Tipe data apa yang diizinkan?
A Semua data numerik, seperti int, float, dll.

T Apakah saya perlu mencetak hasil dari setiap potongan?
A Tidak, membuat hasilnya tersedia untuk penggunaan selanjutnya sudah cukup.

Q Apakah variabel pra-setel diizinkan?
A Ya, dan itu menjadi reset (jika diubah) untuk setiap cuplikan.

Q Apakah π dan e dianggap literal angka?
A Tidak, Anda dapat menggunakannya.

Q Bolehkah saya mengembalikan 4 dan 2 dalam sel yang berbeda untuk 42?
A Tidak, mereka harus terhubung sebagai satu nomor.

Q Bytes atau karakter?
A Bytes, tetapi Anda dapat memilih codepage yang diinginkan.

T Bolehkah fungsi konstan dan variabel preset seperti J 9:, Actually 9, dan Pretzel 9digunakan?
J Ya, jika kosakatanya terbatas (19 untuk J, 10 untuk Actually dan Pretzel).

Hexagony , 13 byte

1
2
3
4
5
6
7
8
9
10
42

Cobalah online!

Dalam Hexagony, 0through 9adalah fungsi yang mengalikan memori saat ini dengan 10, dan kemudian menambahkan angka yang diwakili oleh nama fungsi. Oleh karena itu, cuplikan pertama kosong karena ingatan dimulai sebagai 0.

Misalnya, jika memori saat ini 65, menjalankan fungsi 3akan membuat memori saat ini 653.

(Untuk downvoters: downvote semua yang Anda inginkan; Saya siap.)

Funciton , 1222 byte

Terlepas dari literal numerik, ada dua cara saya dapat menghasilkan nilai (nilai apa saja) di Funciton: ekspresi stdin dan lambda. Stdin adalah kotak tunggal sedangkan ekspresi lambda penuh membutuhkan lebih banyak sintaks, jadi saya akan menggunakan stdin. Namun, sementara stdin bisa berupa apa saja, semua pekerjaan berikut ini terlepas dari input apa yang disediakan.

Semua fungsi perpustakaan yang digunakan di sini ada sebelum tantangan diposting.

0 (40 byte dalam UTF-16)

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

Ini menggunakan sintaksis mentah untuk kurang dari. Nilai tidak pernah kurang dari itu sendiri, sehingga hasilnya adalah 0.

1 (52 byte dalam UTF-16)

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

⌑mengembalikan urutan malas yang mengandung elemen tunggal dan ɕmenghitung jumlah elemen. (Urutan malas cukup malas sehingga potongan ini tidak benar-benar mengevaluasi stdin sama sekali!)

2 (70 byte dalam UTF-16)

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

= 2¹. ʂmenghasilkan semua urutan dari suatu urutan, dan dengan demikian mengubah urutan elemen n menjadi satu dengan 2ⁿ.

3 (88 byte dalam UTF-16)

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

= 2 + 1. ♯menambah nilai dengan 1.

4 (88 byte dalam UTF-16)

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

= 2².

5 (106 byte dalam UTF-16)

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

= 4 +1.

6 (106 byte dalam UTF-16)

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

= 3 faktorial.

7 (110 byte dalam UTF-16)

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

= A (2, 2) (fungsi Ackermann).

8 (118 byte dalam UTF-16)

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

= 2 << 2 (bergeser ke kiri).

9 (128 byte dalam UTF-16)

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

= 3 × 3.

10 (146 byte dalam UTF-16)

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

= 5 + 5.

42 (170 byte dalam UTF-16)

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

= 6 × (6 +1).

JavaScript, 144 141 140 138 132 125 123 byte

Dengan bantuan dari @ edc65 , @Sjoerd Job Postmus , @DocMax , @usandfriends , @Charlie Wynn dan @ 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 byte

Cuplikan pertama mendorong 0-10, dan ZR+mendorong 25lalu 17dan 25 17 + 42 =sekarang 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

Terima kasih kepada @ MartinBüttner untuk -1 byte!

Cobalah online!

Brainfuck, 70 byte

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

Setiap baris harus dijalankan secara individual.

10 yang pertama cukup jelas: kami menambah nilai sel melalui setiap plus.

42 jauh lebih kompleks. Itu bergantung pada fakta bahwa interpreter yang paling brainfuck menggunakan sel 8-bit, yang berarti bahwa semua operasi di atasnya dilakukan modulo 256. --Set cell # 0 hingga 254. Kemudian kita memasukkan sebuah loop yang berjalan hingga sel # 0 adalah 0. Setiap iterasi menambahkan 1 ke sel # 1 dan menambahkan 6 ke sel # 0. Loop ini berjalan 43 kali, jadi sel # 1 adalah 43. Akhirnya, kita kurangi 1 dari sel # 1 untuk membuatnya menjadi 42.

Saya mendapatkan 42 yang paling efisien yang pernah ditemukan dari http://esolangs.org/wiki/Brainfuck_constants

Darkness , 339 303 bytes

Di sinilah Darkness benar - benar bersinar . Mendapatkan? : ~)!

Tanpa cetak (ganti spasi dengan \sdi baris pertama karena tidak akan ditampilkan sebaliknya):

\s

█ 

██ 

███ 

████ 

█████ 

██████ 

███████ 

████████ 

█████████ 

██████████ 

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

Dengan pencetakan:

■ 

█■ 

██■ 

███■ 

████■ 

█████■ 

██████■ 

███████■ 

████████■ 

█████████■ 

██████████■ 

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

Setiap baris harus dijalankan secara terpisah dalam kasus ini karena program berakhir dalam cahaya (spasi). Namun, dimungkinkan untuk menulis ini pada satu atau beberapa baris dalam program yang sama.

Darkness reguler (█) menambah register dengan 1, dan ■ instruksi (semacam kegelapan mini) menampilkan isi register.

Perl 5, 86 75 71 66 byte

Semua ^Fs adalah karakter kontrol literal (0x06 dalam ASCII), dan karenanya satu byte.

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

Terima kasih kepada msh210 karena telah menghemat 11 byte dan Dom Hastings untuk 9 byte!

MATL, 30 byte

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

H,, Idan Kadalah konstanta yang ditentukan sebelumnya untuk 2, 3, dan 4 (seperti pi). Odan ladalah fungsi yang mengembalikan matriks nol ( O) atau yang ( l), ukuran default adalah 1x1. :membuat vektor, dan smenjumlahkannya, sehingga K:smembuat vektor dari 1 hingga 4 dan menjumlahkannya untuk mendapatkan 10. Yqadalah fungsi prima ke-n, demikian KYqjuga ke-4 prima, 7.

Prolog, 113 99 byte

Cuplikan:

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

Menggabungkan konstanta matematika e dan pi dengan cara yang berbeda dikonversi ke int.

Sunting: Disimpan 14 byte dengan memanfaatkan pelampung untuk 0-2.

PHP, 157 145 91 byte

Pertama kali memposting di Code Golf, saya pikir saya akan mencobanya. Saya akan menjadi lebih baik pada akhirnya: P Jika Anda melihat tempat yang jelas (untuk Anda) di mana saya dapat menyimpan karakter, beri tahu saya.

SUNTING: Sadar saya tidak butuh titik koma, karena ini hanya cuplikan.

EDIT2: Terima kasih kepada Blackhole untuk banyak saran!

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

Kiriman pertama saya, semoga semuanya benar! Berdasarkan waktu yang saya habiskan untuk ini, saya kira pasti ada yang lebih baik untuk beberapa dari mereka.

# 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

Terima kasih banyak kepada FryAmTheEggman!

C #, tanpa penggunaan, 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

Ini jauh lebih membosankan daripada yang saya pikir awalnya. Saya punya ide yang cukup bervariasi, seperti new[]{true}.Lengthdan true.GetHashCode()dan typeof(int).Name.Lengthdan uint.MinValuesebagainya, tetapi new int()mengalahkan semuanya.

PowerShell, 147 byte

Ini digunakan +untuk secara implisit membuang sesuatu ke bilangan bulat. Angka-angka kemudian menggunakan Enums dari .Net Framework unerpinnings dari PowerShell yang kebetulan memiliki nilai yang benar.

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

• -~-~-~digunakan dalam JavaScript, C # dan jawaban PHP akan berada - -bnot - -bnot - -bnotdi PowerShell.

• x^yeksponensial yang digunakan dalam jawaban Perl, atau x**ydalam Python atau JavaScript ES7, akan menjadi[Math]::Pow($x,$y)

• konstanta e dan Pi adalah karakter-berat [Math]::Edan[Math]::PI

DC , 35 byte

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

Untuk menguji potongan menambahkan funtuk mencetak tumpukan dan meneruskan string itu ke 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(π

Dalam TI-BASIC, semua variabel huruf tunggal yang tidak diinisialisasi mulai dari 0, dan Xmax (batas kanan jendela layar grafik) mulai dari 10.

Konstanta matematika πadalah satu byte , tetapi edua byte.

Python 2, 306 275 274 byte

Saya menggunakan fakta bahwa untuk setiap x (integer dan bukan 0) ekspresi x/xsama dengan 1 dan bermain-main dengan beberapa operasi bitwise.

Saya menyesuaikan cuplikan sehingga masih memenuhi persyaratan (terima kasih @nimi ini menyelamatkan saya 24 byte), tetapi Anda harus mengujinya secara manual. Berikut adalah kode dan jumlah byte individual:

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

Matematika ++, total 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 (Browser Env), 155 136 130 byte

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

Terima kasih kepada:
@Ismael Miguel : 155 -> 136 -> 130 byte

Serius, 39 33 byte

Stuff dalam tanda kurung adalah penjelasan:

 (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 program:

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

Berkat kuintopia selama 6 byte!

dc, 42 byte

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

Hasil

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

Tidak ada banyak cara untuk menghasilkan angka baru dengan dc. Saya menggunakan O: basis output, awalnya 10; K: presisi, awalnya 0; zkedalaman tumpukan, awalnya 0;Zdigit signifikan dari operan. Kami menggabungkan ini dengan operator aritmatika yang biasa.

Program uji

#!/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 byte

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

Saya cukup yakin beberapa di antaranya tidak optimal. Kurung bundar itu benar-benar mahal.

Untuk konsistensi, dua yang pertama juga bisa E-Edan E/Etentu saja, tapi saya pikir cukup bagus untuk mendapatkan 0dan 1dari perhitungan dengan variabel yang tidak ditentukan.

Japt , 34 33 30 byte

1 byte disimpan berkat @ThomasKwa

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

Inilah arti masing-masing karakter yang berbeda:

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 byte

Tidak terlalu menarik, itu bergantung pada ?nperangkat yang mengubah marmer menjadi nilai acak di kisaran 0..n (inklusif) efek samping dari ini adalah bahwa?0 mengubah marmer apa saja menjadi 0 tanpa memperhatikan input. Saya pikir penggunaan literal diizinkan karena nilainya tidak mempengaruhi hasil dan tidak ada cara lain untuk memanggil fungsi sekali di 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;ataullll:+n;
• 7: lllll+n;
• 8: lllll:+n;
• 9: lllll++n;ataullllll+n;
• 10: llll+:+n;ataulll:l+*n;
• 42: llll*ll+*n;

Bergantung pada ukuran tumpukan untuk mendapatkan literalnya.

Rumus MS Excel, 163 151 150 143 byte

Bukan bahasa pemrograman, tapi ini dia ...

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()digunakan dalam banyak kasus karena ini adalah cara yang lebih pendek (yang saya tahu) untuk memperkenalkan nilai numerik tanpa menggunakan angka atau string literal. Nmengubah berbagai hal (termasuk boolean) menjadi angka, dan Tmengubah berbagai hal menjadi teks. TYPEmengembalikan 2 untuk argumen teks dan 4 untuk argumen boolean. TRUNCmembuang bagian pecahan (yaitu angka bulat positif ke bawah), EVENdibulatkan ke angka genap berikutnya, dan ODDdibulatkan ke angka ganjil berikutnya. CODE(-PI())adalah kode ASCII dari karakter pertama konversi ke teks -π, yaitu 45 (untuk "-").

EDIT: Dihapus tanda sama dari jumlah byte (-12!) - seperti yang ditunjukkan oleh Nᴮᶻ dalam komentar, mereka tidak seharusnya dimasukkan.

EDIT 2: Dengan asumsi sisa lembar kerja kosong, dimungkinkan untuk menggunakan referensi ke sel kosong sebagai nol (lagi, disarankan oleh Nᴮᶻ) asalkan kami menyertakan tanda minus (atau menggunakannya dalam ekspresi numerik lainnya) untuk menyelesaikan ketik ambiguitas.

DUP , 68 byte

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

Try it here.

Ada BANYAK cara untuk melakukan ini, tapi saya menyalahgunakan tumpukan kembali untuk yang satu ini.

Penjelasan

Untuk mengetahui sepenuhnya hal ini, Anda perlu memahami perilaku DUP terkait lambda. Alih-alih mendorong lambda itu sendiri ke stack, itu malah mendorong IP saat ini ke stack ketika lambda terdeteksi. Itu bisa menjelaskan 3 cuplikan pertama, yang melibatkan lambdas.

Cuplikan berikutnya menggunakan tumpukan kembali. Kapan! dijalankan, IP saat ini didorong ke stack kembali, dan bagian atas stack ditetapkan sebagai IP baru untuk memulai eksekusi lambda. )muncul nomor dari tumpukan kembali ke tumpukan data.

Itu cukup banyak untuk menjelaskan sisa potongan. Jika Anda masih belum mengerti, ingatlah bahwa Steptombolnya cukup praktis!

05AB1E, 40 38 24 byte

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

• Dorong counter_variable
• Tekan 1
• Dorong 2
• Tekan 1 + 2
• Tekan 2 * 2
• Tekan 10/2
• Tekan (10/2) +1
• Tekan (10/2) +2
• Tekan 10-2
• Tekan 10-1
• Dorong 10
• Tekan 32, 10, tambahkan

D1ffe7e45e , 112

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

Setiap baris adalah cuplikan yang berbeda.

Angka-angka dalam program tidak dihitung sebagai angka literal karena mereka hanya digunakan sebagai perintah.

Yang terakhir pasti bisa lebih banyak golf.

EDIT: Saya membuat penerjemah bekerja dan semua cuplikan bekerja. Jika Anda ingin menguji apakah Anda sendiri, tambahkan 0f0fke ujung cuplikan sehingga program berakhir.

Pyth, 35 34 33 byte

-1 byte oleh @Mimarik

Ada sejumlah kemungkinan untuk beberapa program.

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

Semua ini melibatkan dasar ganda ( y), +1 (ht perintah ) dan -1 ( ), atau l(panjang string). Variabel Z diinisialisasi ke nol.

Untuk 5, b diinisialisasi ke karakter baris baru. Backtick memberi "\n"(termasuk tanda kutip, dan panjang string itu adalah 4).

Coba di sini !