Tantangan:
Tugas Anda adalah menulis sebanyak mungkin program / fungsi / snippet, di mana masing-masing menghasilkan / mencetak / mengembalikan bilangan bulat. Program pertama harus menampilkan integer 1
, yang kedua 2
dan seterusnya.
Anda tidak dapat menggunakan kembali karakter apa pun di antara program-program tersebut. Jadi, jika program pertama adalah:, x==x
maka Anda tidak boleh menggunakan karakter x
dan =
lagi di salah satu program lain. Catatan: Diijinkan untuk menggunakan karakter yang sama beberapa kali dalam satu program.
Mencetak:
Pemenang akan menjadi pengajuan yang dianggap paling tinggi. Jika ada seri, pemenangnya adalah pengiriman yang menggunakan jumlah byte paling sedikit.
Aturan:
- Anda hanya dapat menggunakan satu bahasa untuk semua bilangan bulat
- Cuplikan diizinkan!
- Agar tetap adil, semua karakter harus disandikan menggunakan satu byte dalam bahasa yang Anda pilih.
- Output harus dalam desimal. Anda tidak boleh menampilkannya dengan notasi ilmiah atau format alternatif lain. Output mengapung OK, asalkan semua angka yang ditampilkan di belakang titik desimal adalah
0
. Jadi,4.000
diterima. Ketidakakuratan karena FPA diterima, asalkan tidak ditampilkan dalam output. ans =
, ruang terkemuka dan trailing serta baris baru dll. diizinkan.- Anda dapat mengabaikan STDERR, selama output yang benar dikembalikan ke STDOUT
- Anda dapat memilih untuk mengeluarkan integer ke STDERR, tetapi hanya jika STDOUT kosong.
- Simbol bahasa independen (seperti Bahasa ) tidak diizinkan
- Huruf peka huruf besar-kecil
a != A
. - Program harus independen
- Spasi tidak dapat digunakan kembali
- Anda harus menggunakan digit ASCII dalam output
Penjelasan didorong!
number
code-challenge
restricted-source
Stewie Griffin
sumber
sumber
#include <iostream>
dan hal-hal boilerplate lainnya di C ++. Anda memang butuhfrom numpy import *
. Catatan: Saya bukan seorang programmer, jadi saya tidak tahu semua nuansa. Kita dapat berdiskusi dalam obrolan jika ada sesuatu yang tidak jelas :)Jawaban:
JavaScript (ES7), skor 17, 176 byte
Mereka mengatakan itu tidak bisa dilakukan, jadi saya melakukannya: D (terima kasih banyak bantuan dari @FullDecent)
Karakter yang tidak digunakan:
Saya tidak berpikir 18 mungkin, tapi saya mengatakan hal yang sama tentang 17 ...
Penjelasan
JavaScript adalah bahasa yang diketik dengan sangat lemah; jika Anda mencoba melakukan operasi matematika pada nilai non-angka, JS akan berusaha paling keras untuk mengubahnya menjadi angka terlebih dahulu. Ini memungkinkan banyak solusi menarik. Saya sudah mencoba untuk menghindari menggunakan digit sebanyak mungkin sehingga dapat digunakan nanti.
**
adalah operator eksponensial dalam ES7. String kosong saat dipaksa ke angka menjadi0
, jadi ini menghitung0 ** 0
, yang1
sesuai dengan JavaScript./~/
adalah regex literal, dan~/~/
mengembalikan-1
, jadi ini adalah~(-1 / -1) / -1
=~(1) / -1
=-2 / -1
=2
. (kredit ke @ GOTO0 untuk idenya)3
.4
.NaN
adalah falsy, demikian!NaN
jugatrue
, yang setara dengan1
. Ekspresi demikian menjadi1 - -1 - -1 - -1 - -1
=1 + 1 + 1 + 1 + 1
=5
.6
.7
.8
.9
.+[]
adalah0
, jadi[[]][+[]]
kembalikan elemen pertama[[]]
(yaitu,[]
), dan++
tambahkan ini ke1
. Kemudian+[+[]]
menambahkan array[0]
, yang dipaksa ke string dan membuat"10"
.11
. Saya awalnya telah menggunakan11&1111
untuk 3 dan33/3
11 sampai saya menyadari lagi betapa bodohnya saya ...12
dan gunakan.length
.2
dan>
untuk sementara waktu untuk mendapatkan yang ini. Saya beruntung lagi:222 >> 2
adalah55
, dan55 >> 2
sekarang13
.14
dalam hex (0xE
), tetapi kita membutuhkan digit0
tempat lain. Jadi alih-alih, kami menambahkan hasil``^``
ke stringxE
; string kosong yang dipaksakan ke angka adalah0
, jadi ini mengembalikan0 ^ 0
=0
. Kemudian hasilnya XOR dengan string kosong, yang mengubah kedua nilai menjadi angka;"0xE" ^ ""
adalah14
.0XF
adalah heksadesimal literal dengan nilai15
.C
keCSS == CSS
(yaitu,true
). Kemudian kami mengambil hasilnya dan melakukan<< C
empat kali, yang pada dasarnya dikalikan1
dengan2 ** 4
.555...555%55
untuk mengembalikan nomor yang bukan0
atau5
. Saya kebetulan sangat beruntung saat bermain-main di sini.Strategi yang dapat digunakan pada banyak angka:
-!NaN
akan bekerja pada nomor berapa pun (saat ini5
), meskipun mendapat besar sangat cepat~/~/
akan bekerja pada nomor berapa pun (saat ini2
), meskipun mendapat sangat besar sangat cepat.+[]
akan bekerja pada nomor berapa pun (saat ini10
), meskipun itu paling mudah di10
atau11
..length
akan bekerja pada nomor berapa pun.`${-``}xE`-``
akan bekerja pada hampir semua nomor jika Anda melakukannya dengan benar.C<<C
akan bekerja pada kekuatan dua (saat ini16
), atau int sama sekali jika Anda termasuk|
.sumber
window.
properti, sepertidefaultPixelWidth
, tetapi semuanya tampaknya mengandung salah satul
ataue
. Anda bisa mendapatkan 0 yang lain denganURL | URL
tetapi tidak banyak membantu.+ - * ~ < x X length
1 2 3 4 5 6 7 8 9 + - * ~ < x X length
. Jadi sebelum menyelesaikannya kita tidak bisa pergi 18Jelly , 47 bilangan bulat, 519 byte
Setiap baris adalah program yang terpisah dan lengkap.
Cobalah online!(termasuk test suite dan pemeriksa persimpangan)
Bagaimana itu bekerja
Setiap program lengkap tanpa argumen baris perintah mengeksekusi tautan utamanya (didefinisikan pada baris terakhir) secara niladis, yaitu tanpa input. Jika tautan pertama dalam rantai adalah nilad, ia dikonsumsi, dipanggil, dan kedua argumen tautan utama dan nilai pengembalian diatur ke hasilnya; jika tautan pertama dalam rantai adalah monad atau angka dua, itu tidak dikonsumsi dan argumen implisit dan nilai balik 0 digunakan sebagai gantinya. Dalam kedua kasus, sisa rantai dieksekusi secara monadik.
Jelly merusak outputnya dalam beberapa kasus. Khususnya, array tunggal dicetak tanpa tanda kurung di sekitarnya, sehingga 42 dan [42] dan tidak bisa dibedakan setelah dicetak. Kami akan menggunakan ini pada beberapa kesempatan.
1 - 10
The ada tes atom jika nilai kembali 0 milik argumen 0 . Ya, jadi
e
mengembalikan 1 .BI$
adalah quicklink, khususnya rantai monadik yang dibentuk oleh$
pengelompokan cepat atom binerB
dan atom kenaikanI
. Digabungkan, mereka mengonversi bilangan bulat ke dalam susunan digitnya di basis 2, kemudian menghitung perbedaan maju dari digit yang dihasilkan. Jika array hanya memiliki satu elemen, tidak ada perbedaan forward danI
mengembalikan array kosong (falsy); jika setidaknya ada dua digit,I
kembalikan array yang tidak kosong (benar).Quick
#
mengkonsumsi quicklink sebelumnya dan menerapkannya pada 0 , 1, 2, ... sampai cukup banyak kecocokan yang ditemukan dan mengembalikan susunan kecocokan. Jumlah yang diperlukan dihitung oleh⁼
, yang membandingkan nilai balik / argumen 0 dengan dirinya sendiri, menghasilkan 1 . Dengan demikian, seluruh program mengembalikan [2] , bilangan bulat non-negatif pertama dengan dua digit di basis 2.⁾⁾⁾
adalah string literal, khususnya string ⁾⁾ . The up grade atomỤ
macam indeks sebesar nilai yang sesuai mereka; karena kedua karakter sama, ini menghasilkan [1, 2] . Array yang dihasilkan dikurangi dengan bitor XOR^/
, sehingga seluruh program mengembalikan 3 .ı
menginisialisasi argumen dan mengembalikan nilai ke unit imajiner i .*
adalah angka dua eksponensial , yang argumen kanannya default ke argumen tautan utama. Jadi,***ı
menghitung ((i i ) i ) i ≈ 4,81 + 0i ,Ḟ
atom ( lantai untuk argumen nyata , bagian nyata untuk yang kompleks) menghitung bagian nyata ( 4,81 ), kemudianḞ
lantai, menghasilkan 4 .Ketiga program ini terdiri dari satu huruf tunggal dan melakukan apa yang Anda harapkan.
Literal
.
adalah singkatan untuk 0,5 dan menginisialisasi argumen dan mengembalikan nilai. The pembagian integer (angka dua ini:
) default argumen yang tepat untuk argumen link utama, sehingga::::
menghitung 0,5 / 0,5 / 0,5 / 0,5 / 0,5 , menghasilkan 8 .Literal lain.
The semua sama atom
E
mengembalikan 1 jika semua elemen dalam argumen yang sama, dan 0 jika tidak. Argumen integer z dipromosikan ke [z] , sehinggaE
akan mengembalikan 1 untuk argumen implisit 0 .Sekarang, atom output
Ȯ
mencetak 1 hingga STDOUT. Kami kemudian membandingkan 1 dengan argumen 0 implisit menggunakan kurang dari atom<
. Hasilnya adalah (1 <0) = 0 , dan dicetak secara implisit ketika program selesai.11 - 20
The Grid atom
G
mencoba untuk membuat tabel visual menyenangkan dari argumen. Untuk argumen integer biasa (di sini: 0 ), itu hanya membungkusnya dalam sebuah array. The datar tidak-sama atom⁻
membandingkan argumen implisit 0 dengan hasil di sebelah kanan ( [0] ), menghasilkan 1 karena argumen tidak sama. The representasi atomṘ
cetak 1 untuk stdout dan mengembalikan hasilnya. Pada akhir program, nilai pengembalian akhir dicetak secara implisit, jadi kami menghasilkan output 11 .The diri cepat
`
berubah menjadi angka dua menjadi monad dengan menyebutnya dengan argumen kiri dan kanan identik. Pertama,=`
bandingkan argumen 0 implisit dengan dirinya sendiri, menghasilkan 1 .The produk Cartesian atom
p
mengharapkan daftar sebagai argumen, sehingga mempromosikan bilangan bulat 1 ke kisaran [1, ..., 1] = [1] .p`
mengambil produk Cartesian dari [1] dan itu sendiri, menghasilkan [[1, 1]] .The eval atom
V
ternyata semua array datar (yang hanya berisi angka dan karakter) ke string, kemudian mengevaluasi string yang dihasilkan sebagai program Jelly niladic. [[1, 1]] pertama-tama berubah menjadi [“11”] , kemudianV
mengevaluasinya, menghasilkan [11] . Sekali lagi,V
ubah array ini menjadi "11" , lalu evals untuk menghasilkan 11 .Sekarang,
×`
gandakan 11 dengan dirinya sendiri, menghasilkan 121 . The desimal atom berubah 121 menjadi [1, 2, 1] , yang unik atomQ
membuang kedua 1 , danV
sekali lagi ternyata daftar digit ke integer yang dihasilkan dari concatenating mereka, kembali 12 .~
adalah atom bitwise BUKAN . Dengan aritmatika komplemen dua, memetakan argumen z ke ~ z = - (z + 1) .A
adalah atom nilai absolut , sehingga memetakan - (z + 1) = z + 1 . Dengan nilai pengembalian awal 0 , tiga belas salinan~A
pengembalian 13 .Konstanta
⁷
memegang karakter baris baru '\ n' dan menginisialisasi argumen dan mengembalikan nilai.The uneval atom
Ṿ
upaya untuk menciptakan representasi string dari argumen z sehingga program Jelly terdiri dari kode ini akan kembali z .Panggilan pertama dengan patuh mengembalikan string "" \ n " , yang merupakan karakter literal. Panggilan selanjutnya mengembalikan "" "," \ n " - sepasang literal karakter. Panggilan ketiga dan terakhir mengembalikan "" "," "," ,, "", "\ n" - rangkap lima literal karakter.
Akhirnya, atom indeks jendela
w
mempromosikan argumen yang tepat '\ n' ke string "\ n" dan menemukan indeks pertama dari substring dimulai dengan "\ n" . Ini mengembalikan 14 .⁴
adalah konstanta 16 . The Quicklink filterfalse masing-masing (ḟ€
) mempromosikan argumen kiri 16 untuk rentang [1, ..., 16] , kemudian iterates atas unsur-unsurnya.Untuk setiap elemen z ,
ḟ⁴
dijalankan, pertama-tama mempromosikan z ke [z] , lalu menghapus semua ( 16 ) kejadian 16 (jika ada) . Ini menghasilkan array [[1], [2],…, [14], [15], []] , di mana array terakhir kosong karena berisi 16 .Akhirnya, atom maksimum
Ṁ
memilih [15] .The modular atom
m
- yang disebut dengan argumen x (array) dan y (integer) biasanya membutuhkan waktu setiap | y | th unsur x , dimulai dengan yang pertama jika y> 0 , dengan jika terakhir y <0 . Namun, ketika y = 0 , ia mengembalikan x yang disatukan dengan kebalikannya.Argumen integer kiri 0 pertama kali dipromosikan ke [0] . Salinan pertama dari
m
gabungan [0] dengan dirinya sendiri, menghasilkan [0, 0] . Salinan yang tersisa mengubah hasil ini menjadi [0, 0, 0, 0] , lalu [0, 0, 0, 0, 0, 0, 0, 0] , dan akhirnya [0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] .Akhirnya, atom hitungan
ċ
menghitung berapa kali argumen implisit 0 muncul dalam array yang dihasilkan, menghasilkan 16 .ṭ
adalah atom paku dan menambahkan argumen kirinya ke yang benar. Karenaṭ
dan berikut iniḍ
adalah angka dua , semua panggilan untukṭ
memberikan argumen 0 implisit sebagai argumen yang tepatṭ
. Panggilan pertama mengembalikan [0, 0] , yang kedua [0, [0, 0] , dan yang kedelapan dan yang terakhir [0, [0, [0, [0, [0, [0, [0, [0, [0, 0]]]]]]]] .ḍ
adalah atom yang dapat dibagi ; untuk argumen x dan y , mengembalikan 1 adalah x habis dibagi oleh y , 0 jika tidak.Ḅ
adalah no-op untuk bilangan bulat, jadiḍḄ
menguji 0 untuk dapat dibagi oleh masing-masing bilangan bulat dalam array yang dibuat. 0 dapat dibagi dengan sendirinya, jadi kita mendapatkan [1, [1, [1, [1, [1, [1, [1, [1, 1]]]]]]]]] .Sekarang, unbinary atom
Ḅ
beroperasi pada array datar. Untuk pasangan [a, b] , itu hanya mengembalikan 2a + b . Seperti yang disebutkan sebelumnya,Ḅ
adalah no-op untuk bilangan bulat: argumen bilangan bulat c dipromosikan ke [c] , dan [c] dalam basis apa pun hanyalah c .Panggilan pertama untuk
Ḅ
mengurangi [1, 1] menjadi 3 , dengan demikian menghasilkan [1, [1, [1, [1, [1, [1, 3]]]]]]]]] . Panggilan berikutnya berkurang [1, 3] menjadi 5 , yang berikutnya [1, 5] menjadi 7 , dan seterusnya hingga yang kesembilanḄ
kembali 17 .Ṇ
adalah atom datar TIDAK logis dan memetakan argumen implisit 0 ke 1 .+
adalah atom tambahan, jadi masing-masing dari delapan belas salinan+Ṇ
kenaikan nilai pengembalian sebelumnya (awalnya 0 ). Seluruh program dengan demikian mengembalikan 18 .C
adalah atom pelengkap dan memetakan argumennya z ke 1-z .N
adalah negate atom dan memetakan argumennya z ke -z . Bersama-sama,CN
petakan z ke - (1-z) = z-1 , jadi delapan belas salinan mengubah argumen implisit 0 menjadi -18 . AplikasiC
hasil akhir1 - (-18) = 19
.The Menghitung atom
Ė
menyebutkan item dalam array, menciptakan pasangan indeks-nilai. Argumen implisit 0 dipromosikan ke [0] , laluĖ
menghasilkan [[1, 0]] . The undecimal atom mengkonversi array datar dari basis 10 ke integer, menghasilkan [10] dalam kasus ini.Panggilan kedua untuk
Ė
mengubah [10] menjadi [[1, 10]] , yangḌ
akhirnya berubah menjadi [20] .21 - 30
The ekor atom
ṫ
(angka dua) memilih postfix argumen kiri yang dimulai pada indeks (1-based dan modular) yang ditentukan dalam argumen yang tepat, mempromosikan argumen integer kiri x untuk [x] . Saat dipanggil dengan kedua argumen yang diset ke 0 ,ṫ
mengembalikan [0] .The setiap dan semua atom
Ȧ
mengembalikan 1 jika argumen adalah truthy dan tidak mengandung nol pada setiap kedalaman, 0 sebaliknya. Di sini, kita cukup menggunakannya sebagai fungsi identitas untuk mengembalikan argumen 0 implisit . The perpecahan di atomṣ
partisi argumen kiri [0] pada kejadian argumen kanan 0 , sehingga mengembalikan [[], []] di sini.The indeks atom
J
membuang unsur-unsur nilai kembali dan menggantikan mereka dengan indeks mereka, menghasilkan rentang [1, 2] dalam kasus khusus ini.Ȧ
danṫ
keduanya bekerja seperti sebelumnya, sehingga mereka mengurangi [1, 2] ke postfix yang dimulai pada indeks terakhir, menghasilkan [2] .Dalam tautan niladik, konstanta
⁸
berlaku [] . Ini adalah nilad yang tidak dapat dipecahkan, yaitu, tidak cocok dengan rantai dengan cara apa pun. Hasilnya, nilai pengembalian sebelumnya ( [2] ) dicetak ke STDOUT, kemudian diganti dengan nilai nilad ( [] ).Karena [] salah,
Ȧ
ubah menjadi 0 . TheJ
atom mempromosikan 0 ke [0] , kemudian mengembalikan daftar indeks nya ( [1] ), yang dicetak secara implisit ketika program selesai.Literal lain. Repdig tampaknya merupakan tempat terbaik untuk menggunakannya.
Ini menggunakan kompresi string bawaan Jelly. Indeks @ dan ṃ di halaman kode Jelly adalah 64 dan 220 dan string literal dapat berisi 250 karakter yang berbeda, jadi ini pertama menghitung bilangan bulat 250 × 65 + 220 = 16470 .
16470 dapat dibagi dengan 3, sehingga hasil bagi 16470/3 = 5490 mengkodekan karakter ASCII yang dapat dicetak atau umpan baris. Ada 96 di antaranya dan 5490 = 96 × 57 + 18 , yang berarti bahwa kami telah mendekodekan karakter ASCII yang dapat dicetak pada indeks berbasis 0 18 , yaitu '2' .
Kita dibiarkan dengan 57 , yang juga dapat dibagi dengan 3 , sehingga hasil bagi 57/3 = 19 = 96 × 0 + 19 mengkodekan karakter ASCII yang dapat dicetak pada indeks berbasis-0 18 , yaitu '3' .
Ini menyisakan 0 ; proses decoding berhenti. Karakter yang dihasilkan digabungkan untuk membentuk "23"
The faktorial atom
!
ternyata argumen implisit 0 ke 1 . Dua doa dari atom unhalveḤ
mengubah 1 menjadi 2 , kemudian 2 menjadi 4 . Akhirnya,!
hitung 4! = 24 .Dengan tidak adanya argumen baris perintah, konstanta
³
menampung 100 . Dua doa dari 100H
berubah menjadi 50 , kemudian 50 menjadi 25 .Konstanta
Øa
memegang huruf kecil. The maksimal atomM
menghasilkan semua indeks item maksimal, dan karena z adalah huruf kecil terbesar, hasilnya adalah [26] .Dua puluh enam salinan dari concatenate atom
;
menggabungkan awal nilai kembali 0 dan dua puluh enam contoh dari argumen default 0 , membangun sebuah array dari 27 nol.¬
adalah atom NOT logis , jadi;¬
tambahkan 1 ke array nol. Berikutnya¬
meniadakan semua elemen dalam array, meninggalkan kita dengan array 27 yang dan 1 nol.ḅ
adalah unbase atom dan mengkonversi array digit dari argumen kirinya dari basis yang ditentukan dalam argumen kanan menjadi integer.ḅ¬
mengkonversi dari unary ke integer, sehingga hanya melakukan penjumlahan. Untuk array 27 yang, ini mengembalikan 27 .The indeks atom
i
mempromosikan argumen kiri 0 untuk [0] , kemudian menemukan indeks argumen yang tepat 0 dalam array itu, menghasilkan 1 .The berbagai atom
r
membangun sebuah menaik atau menurun berkisar dari itu meninggalkan argumen untuk satu haknya. Argumen yang benar adalah argumen 0 implisit , jadi ini menghasilkan [1, 0] . Doa kedua darii
menemukan indeks 0 di [1, 0] , menghasilkan 2 .ð
memulai sebuah rantai diad yang baru. Karena rantai sebelumnya adalah niladik, argumen kiri dan kanan dari rantai ini akan sama dengan nilai pengembalian rantai pertama ( 2 ).c
dalam atom kombinasi . Dengan argumen kiri 8 dan argumen kanan 2 , ia menghitung semua kombinasi 2 elemen unik, tidak berurutan dari satu set 8 elemen, menghasilkan 8C2 = 8! / (6! 2!) = 28 .Konstanta
⁶
memegang karakter spasi dan menetapkan argumen dan mengembalikan nilai ke '' . Kata - kata atomḲ
mempromosikan karakter "" ke string tunggal "" dan membaginya menjadi spasi, menghasilkan [[], []] .The kelompok atom
Ġ
kelompok semua indeks dari elemen yang sama. Karena kedua elemen dari nilai pengembalian terakhir sama, ia mengembalikan [[1, 2]] di sini. The minimum atom ekstrak minimal (satu-satunya) elemen dari array ini, menghasilkan [1, 2] .The gelar atom
°
mengkonversi kedua bilangan bulat dari derajat sexagesimal ke radian, menghasilkan 1 ° × 2π / 360 ° = π / 180 dan 2 ° × 2π / 360 ° = π / 90 . The terbalik atom mengambil invers perkalian, menghasilkan 180 / π ≈ 57,3 dan 90 / π ≈ 28,6 .Kemudian,
Ṃ
sekali lagi mengambil minimum, menghasilkan 28,6 . Akhirnya, atom langitĊ
mengubah 28,6 menjadi 29 .The identitas atom
¹
mengembalikan 0 untuk argumen implisit 0 . The perpecahan di sekitar atomœṡ
mempromosikan kedua argumen (baik 0 ) ke [0] , kemudian membagi [0] sekitar subarrays berdekatan sama dengan [0] . Ini menghasilkan [[], []] .The jendela geser atom
Ẇ
membangun semua subarrays bersebelahan argumen. Instance pertama mengubah [[], []] menjadi [[[]], [[]], [[], []]] , instance kedua mengubah [[[]], [[]], [[]] , []]] ke dalam[[[[]]], [[[]]], [[[], []]], [[[]], [[]]], [[[]], [ [], []]], [[[]], [[]], [[], []]]] .
The Kebenaran atom
T
daftar semua indeks elemen truthy. Tidak ada array di level pertama yang kosong, jadi ini menghasilkan [1, 2, 3, 4, 5, 6] . The upend atomU
membalikkan array ini, menghasilkan [6, 5, 4, 3, 2, 1] .Empat salinan atom pop
Ṗ
menghapus empat elemen terakhir, meninggalkan kita dengan [6, 5] . Akhirnya, atom produkP
mengubah susunan ini menjadi 30 .31 - 40
ȷ
adalah singkatan untuk 1 × 10 3 = 1000 . The akar kuadrat atom½
menghasilkan 31,6 , dimana kisaran atomR
berubah menjadi [1, ..., 31] . Akhirnya, atom ekorṪ
mengekstraksi elemen terakhir, menghasilkan 31 .The panjang atom
L
mempromosikan argumen implisit 0 untuk [0] , kemudian mengambil panjang untuk menghasilkan 1 .µ
memulai rantai monadik yang baru, dan hasilnya 1 menjadi argumennya.Untuk argumen x dan y , atom divmod
d
menghasilkan [x / y, x% y] . Setiap panggilan akan memiliki y = 1 , sehingga hasilnya akan selalu [x, 0] .Panggilan pertama dimulai dengan x = 1 , menghasilkan [1, 0] .
d
hanya beroperasi pada bilangan bulat, sehingga vektor dalam panggilan berikutnya. Panggilan kedua menghasilkan [[1, 0], [0, 0]] , yang ketiga [[[1, 0], [0, 0]], [[0, 0], [0, 0]]]] , dan yang kelima dan terakhir adalah array dengan kedalaman 5 yang berisi satu dan 31 nol.µ
sekali lagi memulai rantai monadik baru, dan array dari sebelumnya menjadi argumennya. The datar atomF
unnests array ini, menghasilkan array datar dari satu dan 31 angka nol. Akhirnya,L
ambil panjang hasilnya, kembali 32 .Repdigit lain, literal lain.
Setiap instance dari bungkus atom mengubah argumen z ke [z] . Dengan nilai pengembalian awal 0 , semua 34 instance bersama-sama menghasilkan [[[[[[[[[[[[[[[0] []] []]] ]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] . Akhirnya, atom kedalaman
ŒḊ
menghitung kedalaman maksimal array yang dihasilkan, menghasilkan 34 .The window ada atom
ẇ
mempromosikan kedua argumen (baik default 0 ) ke [0] , maka tes jika ** [0] ** terjadi sebagai subarray bersebelahan [0] . Ya, jadiẇ
mengembalikan 1 .ɓ
memulai sebuah rantai diad yang baru. Karena rantai sebelumnya adalah niladik, argumen kiri dan kanan dari rantai ini akan sama dengan nilai pengembalian rantai pertama ( 1 ). Rantai menggunakan dua atom diad yang berbeda: bitshift left (æ«
) dan bitwise OR (|
).Rantai diad yang dimulai dengan tiga atau lebih diad awalnya memanggil angka dua pertama dengan argumen rantai. Di sini, ini memberi 1 << 1 = 2 . Enam diad selanjutnya dikelompokkan menjadi berpasangan (disebut garpu ), di mana angka dua paling kanan disebut pertama dengan argumen rantai, lalu yang paling kiri disebut dengan nilai pengembalian sebelumnya ke kedua sisi.
Karena
æ«æ«
, kita mendapatkan 2 << (1 << 1) = 2 << 2 = 8 . Kemudian,æ«æ«
hitung 8 << (1 << 1) = 8 << 2 = 32 . Sekarang,|æ«
dapatkan kami 32 | (1 << 1) = 32 | 2 = 34 .Akhirnya, trailing
|
bertindak seperti hook dan disebut dengan nilai return sebelumnya sebagai argumen kiri dan argumen kanan rantai sebagai yang benar. Ini mengembalikan 34 | 1 = 35 .Dengan tidak adanya argumen kedua, konstanta
⁹
menampung 256 . The terbalik atom mempromosikan 256 ke array [2, 5, 6] dan membalikkan itu untuk menghasilkan [6, 5, 2] . Kemudian, atom kepalaḢ
mengekstraksi elemen pertama, dan atom kuadrat²
kembali ** 6² = 36 *.The increment atom
‘
increment argumen dengan 1 , sehingga‘‘‘
mengubah awal nilai kembali 0 ke 3 . 0 berikut ini adalah nilad yang tidak dapat diparseabel, artinya tidak cocok dengan rantai dengan cara apa pun. Akibatnya, nilai pengembalian sebelumnya ( 3 ) dicetak ke STDOUT, kemudian diganti dengan nilai nilad ( 0 ).7 salinan berikut
‘
mengubah 0 ini menjadi 7 , yang dicetak secara implisit ketika program selesai.The penurunan atom
’
decrements argumen dengan 1 , sehingga tiga puluh delapan salinan mengubah nilai kembali awal 0 ke -38 . The perbedaan mutlak atomạ
menghitung perbedaan unsigned antara -38 dan argumen implisit 0 , kembali 38 .-
adalah singkatan untuk -1 dan menetapkan argumen tautan dan mengembalikan nilai ke -1 . Masing_
- masing adalah sebuah instance dari atom pengurangan diad , yang argumen kanannya akan default ke -1 jika hilang.Pertama,
-____-
menghitung (-1) - (-1) - (-1) - (-1) - (-1) = 3 . -1 berikut adalah nilad yang tidak dapat diparseable, sehingga nilai pengembalian sebelumnya ( 3 ) dicetak ke STDOUT, kemudian diganti dengan nilai nilad ( -1 ).Selanjutnya,
-_
menghitung (-1) - (-1) = 0 , di mana literal-
menetapkan argumen kiri_
dan menggunakan nilai kembali sebagai yang benar. Sembilan salinan berikut_
kurangi argumen default -1 dari nilai kembali, menghasilkan 9 , yang dicetak secara implisit ketika program selesai.”(
adalah karakter literal dan atom ordinalO
mencari titik kode Unicode-nya, menghasilkan 40 .41 - 47
Dengan tidak adanya argumen baris perintah ketiga, konstanta
⁵
berlaku 10 . The unlength atomḶ
menciptakan kisaran 0-based, khususnya [0, ..., 9] untuk argumen 10 , untuk kedua sisi berulang di tempat atomx
. Yang terakhir cocok dengan elemen dari argumen kirinya dengan pengulangan dari yang kanan, dan mengulangi masing-masing elemen dengan jumlah kali yang sesuai. Dengan [0,…, 9] sebagai argumen kiri dan kanan, kita mendapatkan nol nol, satu, dua, dan lain-lain.The indeks ke atom
ị
menjemput unsur argumen yang tepat pada indeks tertentu dalam satu kiri. Dengan argumen kiri 10 (⁵
ke kiri) dan argumen kanan [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] (hasil sebelumnya), ini menghasilkan 4 .Rantai hingga titik ini diikuti oleh nilad yang tidak dapat diurai
⁵
, sehingga nilai pengembalian sebelumnya ( 4 ) dicetak ke STDOUT, nilai pengembalian diatur ke 10 , dan sisa rantai diurai seperti biasa.Seperti sebelumnya,
⁵ḶxḶ
akan menghasilkan array [1, 2, 2, 3, 3, 3, 4, 4, 4, 4,…, 9] . Kali ini, kami menyebut atom yang diurutkanṢ
pada argumen 10 , yang mempromosikan 10 ke [1, 0] , lalu mengurutkannya untuk menghasilkan [0, 1] . The kepala diad atom sekarang mengambil prefiks dengan panjang 0 dan 1 dari hasil ke kiri, meninggalkan kami dengan [[], [1]] . Saat dicetak, hanya 1 yang akan tetap terlihat.⁽
dan dua karakter berikutnya membentuk literal numerik. Jika j dan k adalah titik kode mereka di halaman kode Jelly dan (j, k) <(124, 250) , kita mendapatkan integer 1001 + 250j + k . Poin kode '{' , '}' , dan 'ʂ' adalah 123 , 125 , dan 167 , sehingga literal kiri mengevaluasi hingga 1001 + 250 × 123 + 167 (= 31918) , sedangkan yang kanan mengevaluasi hingga 1001 + 250 × 123 + 125 (= 31876) .Karena bilangan bulat kiri kurang dari dua kali lebih besar dari yang benar, hasilnya adalah (... + 167)% (... + 125) = (... + 167) - (... + 125) = 167- 125 = 42 .
The mengocok atom
Ẋ
randomizes urutan elemen argumen ini; argumen numerik z dipromosikan ke kisaran [1,…, z] sebelumnya. Untuk argumen implisit 0 , rentang ini kosong danẊ
menghasilkan [] . The semua atomẠ
mengembalikan 1 jika semua elemen argumen ini adalah truthy, 0 jika tidak. Karena array kosong tidak mengandung elemen falsy,Ạ
mengembalikan 1 di sini.The zip dengan atom
ż
(angka dua) mengambil argumen x dan y dan transposes pasangan [x, y] . Untuk bilangan bulat x dan y , ini hanya menghasilkan [[x, y]] , jadi ini khususż
, disebut dengan argumen 1 dan 0 (argumen implisit), mengembalikan [[1, 0]] . The eval diad atomv
ternyata semua array datar (yang hanya berisi angka dan karakter) i argumen kiri ke string, kemudian mengevaluasi string yang dihasilkan sebagai program Jelly monadik dengan argumen yang tepat sebagai argumen program. Sejak ["10"]hanya terdiri dari literal, ini mengabaikan argumen yang benarv
dan hanya menghasilkan [10] .The copy cepat
©
atase kev
dan salinan hasilnya ke dalam register. Kemudian kejadian dari recall atom®
(nilad a) akan mengambil [10] dari register.Tiga salinan
żv
pekerjaan berikutnya seperti sebelumnya, memetakan [10] ke [[10, 0] hingga [100] menjadi ... hingga [10.000] . The rangka atomọ
tes berapa kali argumen kiri dibagi oleh salah satu haknya, jadi di sini, itu menghitung urutan 10 (diambil dengan®
) di 10000 = 10 4 , menghasilkan [4] .Berikut
®
ini adalah nilad yang tidak dapat diparseabel, sehingga nilai pengembalian sebelumnya ( [4] ) dicetak ke STDOUT, kemudian diganti dengan nilai nilad ( 10 ). Kami menerapkanẠ
selanjutnya, menghasilkan 1 . (Ini diperlukan karena nilad diikuti oleh angka dua akan dapat diuraikan pada saat ini.)Seperti sebelumnya,
żvżvżv
menambahkan tiga nol ke nilai pengembalian saat ini, mengubah 1 menjadi [1000] . Akhirnya,ọ®
hitung urutan 10 dalam 1000 = 10 3 , dan 3 dicetak ke STDOUT ketika program selesai.Namun repdigit lain, lagi literal.
Pertama dan terpenting, literal
111111
menetapkan argumen dan nilai pengembalian awal ke 111111 . Aliran lain1
juga literal.l
adalah atom logaritma , yang menghitung logaritma argumen kirinya ke pangkalan yang ditentukan di sebelah kanan. Ketika dipanggil pada 111111 dengan argumen 11 yang tepat , kita mendapatkan log 11 111111 ≈ 4.85 .Kata - kata atom
K
bergabung dengan argumen daftar di spasi, setelah mempromosikan numerik / karakter z ke [z] . Di sini, kita cukup menggunakannya untuk mengubah argumen tautan 111111 menjadi [111111] . (Kami tidak memerlukan array di sini, tetapi kami sudah kehabisan atom identitas.) Atom bitwise AND&
mengambil nilai kembali ke kedua sisi, melemparkannya ke integer jika diperlukan, dan menghitung bitwise AND. Dalam kasus khusus ini, ia mengembalikan [4,85 & 111111] = [4 & 111111] = [4] .Berikut
1111111
ini adalah nilad yang tidak dapat diparseabel, sehingga nilai pengembalian sebelumnya ( [4] ) dicetak ke STDOUT, kemudian diganti dengan nilai nilad ( 1111111 ).K
kemudian mengubah bilangan bulat ini menjadi [1111111] . (Sekali lagi ini tidak benar-benar diperlukan, tetapi nilad yang diikuti oleh angka dua akan dapat diuraikan pada saat ini.)Seperti sebelumnya,
l11
menghitung log 11 1111111 ≈ 5.81 , lalu&
mengembalikan [5.81 & 111111] = [5 & 111111] = [5] .Ini adalah satu-satunya program yang terdiri dari beberapa tautan yang ditentukan pengguna. Tautan terakhir adalah tautan utama dan dijalankan ketika program dimulai, yang tersisa adalah tautan pembantu. Quick
Ç
selalu merujuk ke tautan di atas yang sekarang dan mengeksekusinya secara monadik. Demikian juga, quickÑ
selalu merujuk ke tautan di bawah yang sekarang (membungkus) dan juga mengeksekusinya secara monadik.Tautan atas terdiri dari atom pasangan
,
- pasangan angka yang mengubah argumen x dan y menjadi [x, y] - dan jumlah atomS
- monad yang mempromosikan argumen bilangan bulat z ke [z] dan mengurangi argumen array dengan tambahan. Ketika tautan,SS
disebut dengan argumen integer n , itu menghitung Σ [n, Σn] = Σ [n, n] = 2n .Tautan tengah terdiri dari atom-atom di atas
Ç
, cepat yang disebutkan di atas , dan atom tidak pentingỊ
- sebuah monad yang menghasilkan 1 untuk argumen numerik z dengan -1 ≤ z ≤ 1 , tetapi 0 untuk semua lainnya. MenerapkanỊ
dua kali pada argumen integer dan pada dasarnya menggantinya dengan 1 , karena output dari yang pertamaỊ
( input dari yang kedua) selalu tidak signifikan. Hasil ini kemudian dipasangkan dengan nilai pengembalianÇ
(disebut dengan argumen n ), dan pasangan yang dihasilkan dikurangi dengan Σ [(| n | ≤ 1) ≤ 1, 2n] = Σ [1, 2n] = 2n + 1S
. Secara total, kami menghitung.Dengan dua tautan penolong ini, tautan utama sekarang dapat membuat bilangan bulat non-negatif dengan melihat angka binernya. Dengan nilai pengembalian awal 0 , rantai
ÇÑÇÇÇÑ
menghitung hasil akhir ((((((0 × 2 + 1) × 2) × 2 + 1) × 2 + 1) × 2 + 1) × 2 = ((5 × 2 + 1) × 2 + 1) × 2 = 46 .The prime berikutnya atom menemukan terkecil bilangan prima positif yang ketat lebih besar dari argumen. Dengan nilai pengembalian awal 0 , lima belas doa
Æn
menghitung bilangan prima kelima belas, yaitu 47 .sumber
brainfuck , skor 2,
25514410 byte... Ya, bukan ide terbaik karena saya hanya memiliki 8 karakter (tarpits akan tarpit) untuk bekerja dengan tetapi mari kita lihat berapa banyak yang mungkin.
Saya pikir ini semua yang mungkin. : PJawaban ini menunjukkan enam dari delapan karakter yang digunakan brainfuck, dua lainnya,
adalah input dan.
output.Visualisasikan secara online!
Penjelasan
Setiap angka dibuat dan disimpan pada sel awal pada pita. Sangat bergantung pada sel pembungkus, yang tidak diimplementasikan dalam beberapa penerjemah.
1 :
2 :
sumber
Neim , skor 38, 327 byte
Penjelasan:
0
.ℂ
untuk memeriksa 0 dan 0 untuk co-primality, yaitu mereka. Ini mendorong 1. Kemudian kita menggunakan bilangan prima pertama𝐋
, yang menghasilkan daftar tunggal berisi hanya 2. Kita kemudian mendapatkan elemen terbesar (𝐠
), yang mendorong 2 sebagai angka. Kemudian kami ulangi proses ini sampai kami mendapatkan daftarnya[2 3 5 7 11]
. Setelah itu, kita gunakan𝐝
untuk menghitung delta, menghasilkan daftar[1 2 2 4]
. Selanjutnya, kami menggunakan𝐬
untuk mendapatkan jumlah - yaitu 9 - lalu kami menghitung rentang eksklusif dari 0 hingga 9, menghasilkan[0 1 2 3 4 5 6 7 8]
. Akhirnya,𝐬
digunakan lagi untuk mendapatkan 37.α
adalah konstanta yang merepresentasikan negatif, dan kami berulang kali mendorongnya dan mengurangi (lagi-lagi mengeksploitasi fakta bahwa ketika kami mencoba muncul pada input kosong, 0 ditekan)Bisa dicoba di sini
sumber
all characters must be encoded using a single byte in the language you choose
. Apakah Neim mengkodekan karakter khusus hanya dalam 1 byte? Bagaimana?1
. Tentunya Anda bisa memanfaatkannya?Python 2, 15
Ini awal, mencari lebih banyak
Terima kasih kepada leo yang tipnya membantu saya mencapai angka 15
sumber
-~-~-~-~-~-~-~-~-~[[]==[]][[]<[]]
untuk 10 dan0xD
13 untuk jumlah byte total yang lebih rendah''is''
bernilai true untuk membuat nomor lain?((()<((),))|(()<((),))<<(()<((),))|(()<((),))<<(()<((),))<<(()<((),)))<<(()<((),))
string.printable
:c, j, k, l, s, v, w, y, z, A, B, C, D, E, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, !, #, $, &, ., :, ?, @, \\, `, {, }, \t, \r, \x0b, \x0c
Japt , 448 byte, skor 42
Kolaborasi besar antara Shaggy , ETHproductions , & Oliver .
Karakter (berguna) ini tersisa:
Penjelasan
Beberapa hal yang perlu diketahui tentang Japt sebelum kita mulai, yang sering saya manfaatkan. Pertama, Japt memiliki 6 variabel yang dicadangkan untuk input, yaitu huruf besar
U-Z
. Jika tidak ada input yang dilewatkan melalui variabel-variabel tersebut, semuanya default ke0
. Hal kedua dibahas dalam tip ini .Klik cuplikan apa saja untuk mencobanya di penerjemah online .
Ketika diterapkan pada angka,
v
metode ini mengambil bilangan bulat n sebagai argumen, dan mengembalikan 1 jika angka tersebut dapat dibagi dengan n , 0 jika tidak. Jika n tidak diberikan maka standarnya adalah 2 . 0 (nilai default untukU
) dapat dibagi 2 , jadi ini memberi kita 1 .Sangat mirip dengan yang pertama. Ketika diterapkan pada angka,
y
metode ini mengambil bilangan bulat n sebagai argumen, dan mengembalikan GCD dari dua angka tersebut. Jika n tidak diberikan maka standarnya adalah 2 . Karena 0 dapat dibagi 2 , GCD (0, 2) memberi kita 2 .Í
adalah jalan pintas untukn(2)
atau2
-this
. Karena kami tidak memiliki input, kami defaultthis
ke0
, yang menghasilkan2-0 = 2
.à
mengembalikan jumlah kombinasi[1...this]
, yang mengembalikan 3Q
default ke satu tanda kutip.i
pada string memasukkan string lain di awal; seperti yang dijelaskan dalam # 3 , masing-masingiiii)
- setara dengan.i("i".i("i"))
di JS, sehingga memasukkan dua salinani
di awal string. Lakukan ini dua kali dan Anda memiliki stringiiii"
.âQ
kemudian disimulasikan.search(Q)
, memberikan indeks pertama"
dalam string, yaitu 4 .H
adalah konstanta untuk 32 . Ketika diterapkan pada suatu bilangan,q
metode, yang menggunakan integer n sebagai argumen, mengembalikan akar ke- n dari bilangan itu. Jika n tidak diberikan, nilai defaultnya adalah 2, jadi beri kami akar kuadrat dari 32 yang kira-kira 5.6568 . adalah jalan pintas untuk , yang memberi lantai hasil, memberi kita 5 .Hq
Â
~~
L
diatur ke 100 , danÁ
merupakan jalan pintas untuk>>>
(zero-fill bitwise shift kanan)100>>>100
sama dengan100>>>4
(operan kanan membungkus mod 32), yaitu 6 .Seperti disebutkan sebelumnya,
V
standarnya adalah 0 .´
adalah jalan pintas untuk--
operator, sehingga kode ini setara dengan JS berikut:X.n(Y)
setara dengan Y - X , atau -X + Y ;--V
pengembalian pertama -1 , dan -2 kedua , jadi ini setara dengan - (- 1) + (- (- 2) + (- (- 2) + - (- 2))) . Menyederhanakan, kita mendapatkan 1 + 2 + 2 + 2 = 7 .Secara harfiah, 8 dan 9 .
Ini adalah konstanta untuk 10 - 16 , inklusif.
J
diatur ke -1 . Penerjemah Japt entah bagaimana berhasil mengurai ini dengan benar, sebagai(J--) - (--J) - (--J) - (--J) - (--J)
. Melakukan lebih banyak matematika, kami menemukan bahwa ini setara dengan (-1) - (-3) - (-4) - (-5) - (-6) , atau -1 + 3 + 4 + 5 + 5 + 6 = 17 .¾
adalah, seperti yang Anda duga, jalan pintas untuk.75
. Kami menempatkan 24 salinan 0,75 dalam sebuah array, lalu dijumlahkan denganx
, memberikan 0,75 * 24 = 18 .Saya pikir ini adalah favorit saya.
;
pada awal program mengubah nilai-nilai beberapa konstanta Japt; tanpa ituI
adalah 64 , tetapi dengan itu,I
adalah 91 .ìw
mengonversinya menjadi daftar angka dan berjalanw
pada daftar, membalikkan susunan, lalu mengonversi kembali ke angka untuk memberi kita 19 .½
adalah jalan pintas untuk.5
.e
pada angka x mengambil argumen y dan mengembalikan x * 10 y . Jadi rantai perhitungan yang terjadi adalah:Dan final
~~
berfungsi untuk meratakan ini menjadi bilangan bulat, menghasilkan hasil kami sebesar 20 .T
diatur ke 0 .++
adalah operator increment di JS dan juga di Japt;T+++T
diuraikan sebagai(T++) + T
, tetapi++T+++T
diurai sebagai(++T) + (++T)
, jadi ini setara dengan kode JSHasilnya adalah 1 + 2 + 3 + 4 + 5 + 6 , yang berjumlah 21 .
A literal 22 .
Ä
adalah jalan pintas untuk+1
, jadi ini hanya menjumlahkan 231
s.Ini menemukan jumlah permutasi
[1, 2, 3, 4]
, yaitu 4! = 24 .²
adalah jalan pintas untukp2
, yang meningkatkan angka dengan kekuatan dua. 5 ** 2 adalah 25 .°
adalah jalan pintas untuk++
operator, atau jika tidak dapat diuraikan seperti itu+ +
,. Seperti disebutkan sebelumnya, ketika tidak ada input,U
standarnya adalah 0 . Jadi kode ini setara dengan(++U), (U++) + + (++U) + + (++U) + + (++U) + + (++U) + + (++U)
, yang sangat mirip dengan # 17 :U
pertama kali ditambahkan1
, kemudian berulang kali ditambahkan dan ditambahkan sedemikian rupa sehingga hasil akhirnya adalah 1 + 3 + 4 + 5 + 5 + 6 + 7 = 26 .³
adalah jalan pintas untukp
metode dengan argumen 3 . Namun, jika huruf kecil muncul langsung setelah tanda kurung-kiri (»
adalah jalan pintas untuk((
), itu menjadi string. Ini memungkinkannya diteruskan ke metode dan disebut sebagai fungsi (yaitum³
akan pemetaan oleh.p(3)
). Dalam hal ini, bagaimanapun,("p",3)
mengembalikan kita3
, lalu kita menaikkannya ke kekuatan3
(p
adalah metode kekuatan ketika diterapkan ke angka), yang memberi kita 27 kita .¼
, seperti yang mungkin Anda ketahui sekarang, adalah jalan pintas untuk.25
, jadi ini menghitung 7 / 0,25 = 28 .Apa pun yang dibungkus dengan
$
simbol diperlakukan sebagai JavaScript murni, jadi kami memiliki string yang terdiri dari 29 garis bawah diikuti oleh ab
. (Tanpa$
,'
akan menjadi string karakter tunggal.)b
Metode ketika diterapkan ke string mengembalikan indeks pertama argumennya dalam string itu. Seperti yang dijelaskan di # 3 , yang terakhirb
dikonversi menjadi string, jadi kami mengambil indeks pertama darib
string kami, yaitu 29 .µ
adalah jalan pintas untuk-=
, danÉ
untuk-1
. Efeknya mengurangi 30 salinan -1 dari 0 , yang memberi 30 .Sangat mirip dengan # 29. The
a
metode, bila diterapkan pada string, mengembalikan indeks terakhir dari argumen dalam string itu. Menggunakan 0-indexing, indeks terakhira
dalam string 32a
detik adalah 31 .S
sudah ditentukan untuk satu ruang tunggal, danc
pada string char tunggal mengembalikan kode char-nya, memberikan 32 .Harfiah 33 .
MgN
mengembalikan nomor Fibonacci Nth.011
adalah 9 dalam oktal; angka Fibonacci 9 adalah 34 .#
mengembalikan kode karakter selanjutnya. Kode char#
itu sendiri terjadi 35 , membuat pekerjaan kita di sini sangat mudah.p
adalah eksponensial, dan tanpa argumen kedua defaultnya adalah 2 ; dengan demikian, ini dicetak 6 ** 2 = 36 .Yang ini agak rumit.
R
default ke satu karakter baris baru (bahwa itu baris baru menjadi penting nanti).í
pada string, tanpa argumen apa pun, mengambil setiap karakter dan menambahkan indeksnya: transformasi yang agak tidak berguna, tetapi hasilnya melalui 5 iterasi adalah ini: (menggunakanR
alih-alih baris baru literal)Menarik bagaimana setiap entri hanyalah awalan dari yang berikutnya ... Namun, bagian terakhir
è.
,, menghitung berapa banyak kecocokan/./g
yang ditemukan dalam hasil. Ada 38 karakter di string; namun, karena/./g
hanya cocok dengan karakter yang bukan baris baru, hasilnya adalah 37 .Tanda Punggung menandai string yang dikompresi, dan
¥
didekompresi menjadill
.l
pada string memberil
ength, jadi setelah dekompresi, ini memberi 38 .Oooh, yang ini doozy. Pertama, kami hasilkan
true
dengan¨N
(¨
kependekan dari>=
, danN
tanpa input adalah array kosong), kemudian mengonversikannya menjadi1
dengan|N
. Dari sana dan seterusnya menjadi sangat gila:(Itu
¹
S hanyalah pengganti untuk close-parens dan telah dihilangkan.) Finalo
kemudian muncul dan mengembalikan item terakhir dalam array, memberikan 39 .Sebagian besar trik yang sama dengan # 3 .
¤
adalah jalan pintas untuks
metode dengan argumen 2 . Namun dalam hal ini, kode yang ditranskripsikan adalah(("s", 2).s(2) * (("s", 2) * (("s", 2))))
, atau disederhanakan(2).s(2) * (2 * 2)
,..s(2)
mengembalikan nomor sebagai string basis-2, yang memberi"10"
;* (2 * 2)
secara implisit mengonversi ini menjadi angka dan mengalikannya dengan 4 , memberi 40 .Mirip dengan yang sebelumnya.
Å
adalah jalan pintas untuks
metode dengan argumen 1 . Namun dalam kasus ini, masing-masing(Å
transpile ke("s", 1)
, yang baru mengembalikan 1 .1<<1<<1<<1<<1<<1
adalah 32 , dan1<<1<<1<<1
adalah 8 ; ini XOR bersama dengan1
untuk mendapatkan 41 .±
adalah jalan pintas untuk+=
, dan¶
untuk===
. Ini berarti bahwa kodenya sebenarnyaY===Y
selalu benar, jadi kami dapat menyederhanakan ini beberapa:0 +1 = 1 ; 1 + 1 = 2 ; 2 + (2 + 1) = 5 ; 5 + 5 = 10 ; 10 + (10 + 1) = 21 ;21 + 21 = 42 .
sumber
Iq
untuk 8 untuk8
kembali, Anda harus menemukan sesuatu yang lain untuk 19.q
untuk5
mengizinkan saya menggunakanl
untuk menambahkan nomor tambahan. Mengusahakan alternatif2
agar saya bisa mendapatkannya=
kembali.(¤
untuk 2.L>>L
bisa membebaskan 6.#w s Å
bisa membebaskan;
danI
#
untuk 21.*
dan^
PHP, skor 17, 130 Bytes
karakter yang digunakan
ADEFGIKLMOPRSTVXYZ=_![]()<>'"#$,;/-+*|^&0123456789afhnprstwx
1 Konstanta Boolean Z (tidak disetel) sama dengan konstanta Z
2 FTP_MOREDATA adalah konstanta dalam PHP dengan nilai 2
3 bitwise dan karakter; dan W
4 bitwise. Geser ke kiri dan masuk akal, jangan masukkan array kosong ke boolean true dengan dilemparkan ke integer 1 melalui operator shift kiri
7 bitwise Atau karakter # dan $ dan 1
9 SIGKILL adalah konstanta dalam PHP dengan nilai 9
10 bitwise Shift kanan setiap langkah adalah pembagian integer dengan 8 sehingga kami memiliki langkah 333333, 41666, 5208, 651, 81, 10
13 hitung char X di string X ... dari awal
15 nilai heksadesimal f = 15
17 bitwise Xor dengan string ha dan YV
Semua cuplikan adalah item dalam array
Cobalah online!
PHP, skor 16, 94 Bytes
karakter yang digunakan
AEIMPRTUZeflnrstvwx^_&|()[]=!.*+/-<>$":0123456789
1 Konstanta Boolean Z (tidak disetel) sama dengan konstanta Z
2 bitwise dan karakter: dan w
3 Pi dicor ke nilai integer melalui array kosong dicor ke nol
7 bitwise xor karakter A dan v
10 variabel $ s tidak disetel! $ S = satu concat dengan panjang string dari variabel $ s
13 111/2 = 55/2 = 27/2 = 13 Divisi integer bitwise
15 nilai heksadesimal f = 15
Semua cuplikan adalah item dalam array
Cobalah online!
PHP, skor 14, 84 Bytes
karakter yang digunakan
$!_^[]()%/+~-=AEILMNPRUZ0123456789delnrstx
1 Konstanta Boolean Z (tidak disetel) sama dengan konstanta Z
3 Pi dicor ke nilai integer melalui array kosong dicor ke nol
7 ERA adalah konstanta dengan nilai 131116 mod 11 = 7
10 variabel $ s tidak disetel! $ S = satu concat dengan panjang string dari variabel $ s adalah nol
13 nilai heksadesimal d = 13 14 bitwise tidak dan tanda minus menaikkan NULL menjadi 14
Semua cuplikan adalah item dalam array
Cobalah online!
sumber
R, skor
1314Dapatkan satu ekstra berkat user2390246.
Karakter yang digunakan:
0123456789acemqrstuvxDFT^=";-/+()$
sumber
F^F
2"n"%in%"n"+"n"%in%"n"
:; 3-9: angka, 10:1e1
11:22/2
12:T--T--T--T...
13:0xD
14:sum(mtcars$vs)
%
dan berpikir untuk menggunakan dataset bawaan. Saya tidak mengerti mengapa itu tidak baik.dataset['A','B']
, asalkan tidak tumpang tindih dengan huruf yang sudah digunakan (dan terjadi mengandung nilai yang bermanfaat!). Sayangnya, sejauh yang saya tahu dari sekilas, semua dataset dengan baris bernama berisi huruf i, jadi tidak kompatibel dengan penggunaan%in%
.q=""=="";q+q
. Itu akan membebaskan penggunaan surat-surati
dann
. Tidak punya waktu untuk memeriksanya sekarang, tapi saya yakin ada satu tambahan di sana di suatu tempat ...MATL , skor
212223 angka (273 byte)Terima kasih kepada J Doe karena telah memperpanjang dari 22 hingga 23 angka!
Cobalah online! Setiap cuplikan di tautan diakhiri dengan
D
(tampilan) atau]D
(tutup lingkaran secara eksplisit dan tampilan) untuk menghapus tumpukan dan dengan demikian mengisolasi dari potongan berikutnya.Penjelasan
Dorong
0
. Meniadakan. Memberitrue
, yang ditampilkan sebagai1
.Dorong string
'bd'
. Perbedaan berurutan antara poin kode karakter.Dorong array sel yang berisi angka
pi
. Konversi ke array numerik (yaitu ke nomor tunggal). Membulatkan ke bawah.Dorong
2
dua kali. Kekuasaan.Numerik literal.
Numerik literal.
Numerik literal.
Numerik literal.
Numerik literal.
Dorong
3
. Dorong3.333333333333333
. Berkembang biak. Karena akurasi floating point ini memberikan10
.Numerik literal.
Dorong
3
. Lipat2
dua kali lipat.Tekan
[6]
(yang sama dengan6
). Hitung prima ke- n .Dorong
1
14 kali. Jumlah elemen dalam tumpukan. Bersihkan sisa tumpukan.Dorong
4
. Kotak. Lakukan yang sama. Any: give1
. Mengurangi.Dorong
4
.2
dibesarkan untuk itu.Push array
[false false ... false]
(17 kali). Jumlah elemen dalam array.Push array
[true true ... true]
(18 kali). Jumlah array.Tekan 19 angka acak yang diambil dari interval (0,1). Menggabungkan secara horizontal 18 kali. Jumlah elemen bukan nol dalam array.
Dorong
0
20 kali. Gabungan konten tumpukan secara vertikal (memberikan vektor kolom). Ukuran: memberikan array[20 1]
. Maksimum array.Tekan
1j
(unit imajiner) 21 kali. Tambahkan 20 kali. Dibagi dengan1j
.Numerik literal
Do ... while (
`
) dengan ujung implisit. Dalam iterasi pertama ia mendorong indeks iterasi (@
) dan menambahnya (Q
) 22 kali, yang menghasilkan23
. Kondisi loop (@@<
) salah, sehingga loop keluar.Beberapa ide untuk perbaikan lebih lanjut
(spasi) dalam snippet 10 dapat diganti dengan
|
X>
dalam snippet 20 dapat digantikan olehp
, sehingga membebaskan awalanX
.:
,A
sumber
Vim 8 pada Windows, skor 13, 104 byte
^{keystroke}
mewakili<C-{keystroke}>
, demikian^X
juga<C-x>
, kecuali^@
yang<C-j>
. Saya masih mencoba menambahkan lebih banyak angka ke daftar ini dan<CR>
mewakili umpan baris.Catatan: untuk menjalankan perintah ini, mulailah vim menggunakan
-u NONE -U NONE
. Ini untuk memastikan bahwa konfigurasi Anda tidak akan mengganggu kode.Cuplikan 1 hingga 10 memulai dalam mode sisipkan. Sementara cuplikan 12 dan 13 dimulai dalam mode normal.
Penjelasan
Cuplikan 8 adalah
:^R=&ts^@
. Saya harus berterima kasih kepada @ L3viathan untuk datang dengan ini dan @ nmjcman101 untuk menyarankan^@
sebagai pengganti untuk linefeed dan @ ØrjanJohansen untuk kependekan&tabstop
menjadi&ts
.&ts
kemudian mengevaluasi ke ukuran tab, yang secara default di 8, dan nilai ini dimasukkan ke dalam editor.Cuplikan 10 adalah
8^O^A^O^A
. Kami menyisipkan angka 8, dan kemudian menambahkannya dua kali untuk mendapatkan 10.Cuplikan 11 adalah
0^[^X^X^X^X^X^X^X^X^X^X^X0x
. Kami menuliskan 0 dan mengurangi 11 kali untuk mendapatkan -11. Lalu kami menghapus minus untuk mendapatkan 11.Cuplikan 12 adalah
:h<CR>wwwwwwwwwwwy$:q<CR>p
. Ini membuka menu bantuan Vim 8, yang berisi informasi berikut:Dan urutan
w
s pindah ke 12, di mana titiky$
menyalin nomor tersebut. Kemudian disisipkan ke dalam editor menggunakanp
.Cuplikan 13 adalah
grgKjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjYZZvPWWWllld|llD
terima kasih kepada @DJMcMayhem untuk membuatnya. Ini hanya berfungsi pada Windows. Cuplikan mencari menu bantuan untuk perintah yang dimulai dengang
. Kemudian bergerak turun menggunakanj
untuk sampai ke baris ini:setelah itu menyalin dan menempelkannya di buffer. Setelah itu, semuanya kecuali 13 dihapus dari buffer.
sumber
^R=&tabstop+&tabstop+&tabstop<CR>P
memberi Anda 12, atau<CR>
sudah digunakan karena^M
?<CR>
ketika saya berkata^M
, tapi terima kasih, saya akan melihat ke menghapus^M
dari potongan 8 sekarang :)0x01
sementara Ctrl + X memberi0x18
. Dan jelas, kedua byte ini terpisah. Apakah itu masuk akal?-u NONE -U NONE
,&tabstop
mengevaluasi ke 8. Jadi saya bertukar ini dengan potongan 8 dengan beberapa modifikasi, terima kasih :)Mathematica, skor 13
sumber
⌊⌋⌈⌉
hal - hal dalam satu byte setiap ...⌊⌋⌈⌉
dengan mengubah⌊E⌋
menjadiFloor@GoldenRatio
,⌈Pi⌉
menjadi4
,LucasL@4
menjadi7
, dan77/7
menjadi22/2
. Mungkin mungkin untuk melangkah setidaknya satu langkah lebih jauh dengan menerapkan fungsi dengan//
05AB1E , Skor 18, 67 byte
Cobalah online!
sumber
A'ok
:)„((Ç;¬
=20.0
(char dua-byte "(("; untuk nilai ordinal; membagi dua; ambil ekor);₁.²₁P₃/ï
=21
(log-2 dari 256; dikalikan dengan 256; dibagi dengan 95; dengan desimal dihapus);₂Ågttγć
=22
(Istilah Lucas ke-26; dua kali kuadrat-berakar; terbelah dalam chuck elemen yang sama; kepala diekstraksi)Pingpong , skor 127
Di PingPong, setiap karakter memiliki nilai numerik tersendiri yang berbeda, menjadikan penghitungan hingga semua tugas sepele. Bahasa berfungsi dengan membaca nilai setiap karakter dan mendorongnya ke atas tumpukan, tempat semua operasi dilakukan. PingPong secara teoritis dapat melewati 127 tetapi akan membutuhkan melewati blok karakter yang hanya muncul sebagai spasi dalam editor teks jadi saya meninggalkan mereka keluar dari solusi saya.
sumber
Oktaf, Skor 14, 74 byte
Cukup yakin saya dekat dengan batas sekarang.
Harus menghapus
strchr
karena saya sudah punyac
nomor 10. Saya masih memilikij
,^
,=
,!
, ruang dan tab horizontal (ASCII-9) kiri, sehingga mungkin untuk memeras satu lagi di.Tab horizontal dapat digunakan sebagai spasi, jadi triknya digunakan bersama
strchr
dannnz
dapat digunakan sekali lagi. Satu-satunya huruf kecil yang tersisa adalahabdfgjkmoquvwxy
. Tidak banyak fungsi yang dapat dibuat dari ini.mod
bisa bekerja, tetapi tidak dapat mengambil input string.Sangat mudah untuk menggunakan karakter yang tersisa untuk mendapatkan
1
, tetapi saya tidak tahu bagaimana saya bisa mendapatkan yang lain.Tes semua .
Mungkin bermanfaat:
fun a
sama denganfun('a')
,fun a b
sama denganfun('a','b')
dan seterusnya. Ini dapat digunakan beberapa tempat:Menggunakan ini akan membuat
0
tersedia, tetapi saya belum melihat bagaimana membuatnya berguna.e (2.71828...)
danj
masih belum digunakan. Harus menghapusceil
untuk digunakane
.Alternatif (inspirasi):
sumber
JavaScript (ES7), 16 bilangan bulat,
137130128 byteSaya mengambil jawaban @ ETHproductions dan berlari dengannya sebentar; itu sangat berubah sehingga saya mempostingnya secara terpisah. Gagasan dipersilakan. :)
Tersisa:
$_@#!^&|/?:, ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz
Atau, jika cuplikan untuk 1 diganti dengan
!!/!//!!/!/
:$_@#^&|*?:", ABDEGHIJKLNPQRUVWZcghjklmpqrsuvwyz
JavaScript (ES7), 16 bilangan bulat, 127 byte
Satu byte lebih pendek. : P
Tersisa:
$_@#!/^&|?:,ABDFGHIJKLNPQRVWYZcghjklmpqrsuvwyz
sumber
-~{}-~{}
: P Secara keseluruhan, ini cukup bagus. Jauh lebih pendek daripada punyaku ...!&/^|
tersisa untuk dikerjakan, cukup mengesankan. Jika perlu, Anda dapat menggunakan!!/!//!!/!/
untuk 1 untuk perdagangan!/
untuk"*
.-~-~{}
+!![]+[+[]]
, selama tidak ada penggunaan yang lebih baik untuk!
Dyalog APL, skor 15, 89 byte
Baris baru sebelumnya
l:l
adalah bagian dari 12.Spasi di 14 mewakili tab.
sumber
0 0 0
->0,0,0
;]fromhex f
> <> , skor 20,
93907465 byte(3 byte disimpan oleh Teal Pelican, banyak byte disimpan oleh Jo King!)
Cobalah mereka di taman bermain ikan! Anda dapat membuat potongan mencetak hasil mereka dengan menambahkan
n;
ke masing-masing. Perhatikan bahwa cuplikan ke-9 berisi tab, yang dimakan oleh pertukaran tumpukan.Penjelasan:
iii((
, masing-masingi
mencoba untuk mendapatkan input, tetapi karena tidak ada, mereka mendorong EOF =-1
sebagai gantinya. Kemudian(
adalah instruksi yang kurang dari itu, dan karena-1
tidak kurang dari-1
itu, ia mendorong kepalsuan0
; tetapi yang kedua(
bertanya apakah-1
kurang dari0
, yang mana, sehingga mendorong kebenaran1
.2
dan3
sudah jelas.ll{lll{[
, yang pertamal
mendorong panjang tumpukan, yaitu0
, kemudian yang kedua mendorong panjang baru, membawa tumpukan ke0, 1
. The{
berputar tumpukan kiri, swapping1
dan0
. Tiga lagil
membawa tumpukan1, 0, 2, 3, 4
. Kemudian{
putar1
ke depan, dan[
menyedot1
hal pertama pada tumpukan, yaitu4
.5
,6
,7
Dan8
yang jelas juga.!\t00=0g
(di mana\t
mewakili tab),!
lewati tab, lalu00=
dorong dua nol dan periksa apakah mereka sama - mereka ada, jadi kita mendapatkan kebenaran1
. Setelah mendorong yang lain0
, karakterg
mendapat di posisi1,0
kode, yang merupakan tab dengan kode karakter9
.a
melaluif
masing - masing dorongan10
untuk15
masing - masing (mungkin untuk membuat heksadesimal bagus).44*
mendorong dua4
s dan mengalikannya, untuk16
.'RA'
mendorong kode karakterR
danA
(masing-masing 82 dan 65) ke tumpukan, lalu%
menghitung82 mod 65 = 17
.999-9--
mengevaluasi ke9 - ((9 - 9) - 9) = 18
."&F#"
mendorong kode karakter&
,F
dan#
, yang38
,70
dan35
masing - masing. Kemudian,
divisi, jadi kita dapatkan38 / (70 / 35) = 19
.1::
dorong1
dan duplikat dua kali,+
tambahkan dua yang bersamaan untuk mendapatkan2
;:+
menduplikasi2
dan menambahkannya ke dirinya sendiri untuk mendapatkan4
;+
menambahkan sisa1
untuk mendapatkan5
; kemudian:+:+
duplikat dan tambahkan dua kali, menghasilkan20
.Ini adalah skor maksimum yang dimungkinkan dengan> <>. Setiap potongan harus menyertakan sebuah instruksi di suatu tempat yang ternyata stack kosong ke tumpukan tidak kosong, dan hanya ada 18> <> petunjuk yang bisa melakukan itu (yaitu
i
,l
, dan angka0–9
dana–f
), ditambah modus tali. (Setiap instruksi lain tidak melakukan apa pun pada tumpukan kosong><v^/\|_#x!{}r
,, atau mencoba untuk melontarkan sesuatu dan kesalahan?.+-*,%=():~$@[]on&gp
,.) Memasuki mode string menggunakan salah satu"
atau'
, sehingga ada18 + 2 = 20
kemungkinan potongan paling banyak .Jika Anda lebih nyaman dengan yang tidak patut daripada saya, ini dimungkinkan dalam 53 byte, terima kasih kepada Jo King:, di
00=, iii((i-, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, 2222***, !Xll$g, 11+::+:+:++, 'Y', "Z"
manaX
,Y
danZ
diganti dengan karakter dengan kode17
,19
dan20
masing - masing.sumber
iii((i-
16>2222***
17> berikutlll{lllll{{[{n
(mungkin samar, tetapi jika Anda ingin menampilkan sebagai satu angka, setidaknya ada satu yang kurangl
) 18>11+::+:+:++
! ll$g
mana ruang diganti oleh karakter kontrol dengan nilai 17 (Kontrol Perangkat 1)?MathGolf ,
485153 integer, 324 byteSkor +2 (dan -2 byte berbeda digunakan untuk
40
) berkat @maxb .Setiap baris adalah program yang terpisah.
Bytes yang digunakan (92 byte berbeda):
îª∞~c±b+φⁿ_¥-567○¢i♀/d²♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ♫¼8]Σ41╔½π░3§2#τ╥└♦⌡!⌠'0$ÿ@£9)►◄╠•╠"h ♣(
Penjelasan dan tautan TIO:
MathGolf adalah bahasa golf baru yang berspesialisasi dalam tantangan golf matematika. Ini memiliki banyak builtin byte tunggal untuk angka, menjadikannya tantangan yang sempurna untuk itu.
1)
î
: Dorong nilai loop terindeks 1, yaitu 1 secara default: Coba online.2)
ª∞~
: Push [1]; gandakan ([2]); daftar pop dan dorong isinya ke tumpukan: Coba online.3)
c±b±+
: Tekan -2; kemudian muncul dan dorong nilai absolutnya; tekan -1; kemudian muncul dan dorong nilai absolutnya; dan tambahkan bersama-sama Cobalah secara online.4)
φⁿ_¥-
: Dorong rasio emas (1.618033988749895); kubus (4.23606797749979); duplikat bagian atas tumpukan; ambil modulo 2 (0.23606797749979); kurangi satu sama lain: Cobalah secara online.5,6,7) Angka-angka itu sendiri: Cobalah online.
8) Cobalah online. 9) : Tekan -3; kuadrat: Coba online.
○¢i♀/
: Dorong 2048; dikonversi ke string heksadesimal (800); dilemparkan ke integer; tekan 100; membagi:d²
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) Push bawaan untuk angka itu sendiri (♂ABCDE☻FGHIJKLMNOPQRST♥UVWXYZ
): Cobalah online.39)
♫¼¼¼¼
: Dorong 10.000; integer-dibagi dengan 4 empat kali: Cobalah online.40)
88888]Σ
: Dorong 8 lima kali; bungkus menjadi daftar; jumlahkan daftar itu: Cobalah secara online.41) Angka itu sendiri: Cobalah online.
42)
╔½½½½½½½½½½½
: Dorong 86400; integer-dibagi dengan 2 sebelas kali: Cobalah online.43)
π░3§3
: Tekan PI (3.141592653589793
); dilemparkan ke string; pop dan tekan karakter ketiga yang diindeks 0 (4); tekan 3; Output seluruh tumpukan bergabung bersama secara implisit: 44)Cobalah online. 45) 48)22#22#
: Dorong 2 dua kali; ambil kekuatan keduanya (4); melakukannya lagi; Output seluruh tumpukan bergabung bersama secara implisit: Cobalah secara online. Cobalah online. 49) : Push string ; pop dan dorong panjangnya (4); tekan 9; Output seluruh tumpukan bergabung bersama secara implisit:τ╥└
: Dorong 2 * PI (6.283185307179586); pop dan dorong kekuatan 2 di bawahnya yang paling dekat (4); dorong bagian atas tumpukan + 1 tanpa muncul (5); Output seluruh tumpukan bergabung bersama secara implisit: Cobalah secara online.46)
♦⌡⌡⌡⌡⌡⌡⌡⌡⌡
: Push 64; pengurangan sebanyak 2 sembilan kali: Cobalah online.47)
!⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠
: Dorong gamma (n +1) (1 secara default); selisih 2 dua puluh tiga kali :: Dorong nilai ordinal karakter '0': Cobalah online. 51) : Dorong 1.000.000; Dorong 10.000.000; pop keduanya dan integer-bagi mereka satu sama lain (10); tekan 512; pop keduanya dan integer-bagi mereka satu sama lain:'0$
ÿ@@@@£9
"@@@@"
Cobalah online.50)
))))))))))))))))))))))))))))))))))))))))))))))))))
: Bertambah sebesar 1 lima puluh kali: Cobalah online. Cobalah online.►◄╠•╠
52)
"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"h
: Push string"hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh"
; dorong panjangnya (tanpa muncul tali); hapus semuanya dari tumpukan kecuali untuk item terakhir: Coba online.53)
♣(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
: Push 128; dikurangi 1 tujuh puluh lima kali: Cobalah online.Akan mencoba menambahkan lagi nanti. Saya masih memiliki beberapa hal berguna yang tersisa, termasuk modulo
%
dan gandakan*
.sumber
88888ΓΣαΣ
->88888]Σ
atau88888§§§§Σ
menghemat 2 perintah dengan biaya menggunakan satu. Anda juga bisa melakukan sesuatu seperti di"xxxxxx"h
mana karakter terakhir adalah ruang tanpa putus yang membersihkan semuanya kecuali TOS dan Anda bisa menggunakan panjang string untuk menghasilkan angka. Mungkin menggunakan sesuatu selain dari itux
, karena Anda punyaWx
yang memberi Anda selama Anda bisa mendapatkan 35 cara lain.char/ord
operator, yang bekerja seperti'A$
->67
, dan juga bekerja untuk string yang lebih panjang (jenis seperti basis-256 integer). Ini tidak didokumentasikan dengan sangat baik, tetapi jika Anda tertarik untuk meningkatkan jawaban ini, saya dapat membuat ulang ruang obrolan untuk MathGolf untuk setiap pertanyaan.88888]Σ
. Tidak tahu]
. Adapun"hhhhh"h
, sepertinya tidak berhasil . : S[
memulai konteks array dan]
mengakhirinya dan membungkus hasilnya dalam sebuah array. Agar level atas berperilaku seperti level yang lebih rendah,]
membungkus seluruh stack dalam sebuah array sepertinya ide yang bagus.Java 8,
111213, 39 byteJava hanya memiliki 10 simbol untuk angka (0-9) dan semua pemanggilan metode dan konstanta memerlukan titik, jadi saya tidak yakin saya bisa mendapatkan di atas 11 outputRupanya karakter dilemparkan ke bilangan bulat secara default ketika operasi diterapkan
+1 dengan bantuan @ OlivierGrégoire
Penjelasan:
integer lambda yang tidak mengambil input dan mengembalikan 1. Ketika parameter tidak mengambil input nilai default digunakan sesuai dengan meta post di atas, yang untuk integer adalah 0
bilangan bulat literal
XOR dua karakter untuk mengembalikan 10
integer literal
ekspresi lambda yang mengembalikan panjang string 12 karakter
Heksadesimal 13
TIO Link jika Anda ingin memverifikasi.
sumber
2
dapat ditulis sebagai2
dan10
sebagai'P'^'Z'
. Juga, ini membebaskan karakterX+*
dan penggunaanP
.i->i.ONE
tidak valid.Gaia , skor 25, 203 byte
Saya menganggap ini skor sempurna, karena tidak ada lagi nilad yang dapat digunakan mengingat keterbatasan karakter.
Penjelasan
1.
§‼
§
adalah karakter antariksa,‼
dipaksakan ke boolean, jadi hasilnya adalah 1.2.
..⌉+⌉
.
adalah jalan pintas untuk0.5
, jadi iniceil(0.5+ceil(0.5))
.3.
₵P~~
₵P
adalah pi,~
adalah negasi bitwise. Negasi bitwise ganda hanyalah pemotongan.4.
4
5.
5
6.
6
7.
∂Ql
∂Q
adalah daftar yang berisi nama-nama hari dalam seminggu,l
panjangnya.8.
8
9.
9
10.
¶c
Titik kode
c
linefeed¶
.11.
11
12.
'¡ċ⌋u⌋
13.
--⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻-⁻
-
adalah singkatan untuk-1
,⁻
adalah pengurangan. Jadi ini-1 - -1 - -1...
cukup untuk menghasilkan 13.14.
7:,Σ
Dorong
7
, duplikat:
, pasangkan,
kedua angka 7 ke dalam daftar, dan jumlahkanΣ
.15.
Ø!))))))))))))))
Ø
adalah string kosong, demikianØ!
juga 1. Penambahan)
1 14 kali.16.
øøw<øøw<«øøw<«øøw<«øøw<«
17.
⟩‘
Menutup string dengan
‘
membuatnya menjadi basis-250 angka literal.⟩
berada pada nilai byte 17 di halaman kode Gaia.18.
₸ḣ₸K$₸ḣ₸/S₸₸/=$
19.
]]]]]]]]]]]]]]]]]]]n
Setiap
]
membungkus tumpukan dalam daftar. Lakukan ini 19 kali dan dapatkan kedalamannyan
daftar.20.
⇑’e
Menutup string dengan
’
membuatnya menjadi daftar poin kode codepage.e
membuang daftar di tumpukan.⇑
memiliki titik kode 20 dalam codepage.21
0(((((((((((((((((((((_
Penurunan
(
0 21 kali, lalu negasikan_
.22.
22
23.
“B”“↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B”B
Konversikan string
“B”
dari basis-24, di mana angka 0-23 berada↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺↺B
. Hasilnya adalah23
.24.
3₈×
3 × 8.
25.
ℍḥḥ
100
ℍ
dibelah duaḥ
, dan dibelah dua lagi.sumber
C, skor 13
Ini hanya sekelompok konstanta bilangan bulat.
0==0
dievaluasi menjadi 1__LINE__
= 21+1+1...
=1*10
= 10'o'
adalah 111,'.'
mewakili ASCII 0x10 yang tidak dicetak. 111/10 = 11(2<<2)
= 8,8*2
= 16,16-2-2
= 12"strlenstrlens"
= 13sumber
Ohm , skor
2122, 160 total byteCobalah online!
Penjelasan
1.
╓S@Ri
Tekan detik dari tanggal / waktu saat ini (
╓S
). Dapatkan rentang inklusif dari 1 hingga detik (@
), balikkan (R
), dapatkan elemen terakhir (i
), yang selalu 1.2.
ΓΓ-Γ-Γ-
Γ
adalah -1, jadi ini adalah (-1) - (-1) - (-1) - (-1), yaitu 2.3.
αê⌠
αê
adalah nomor Euler (2.71828 ...),⌠
adalah plafon. 3 adalah hasilnya.4.
¡¡¡¡¼
¡
menambah penghitung,¼
mendorong penghitung.5.
5
Hanya literal.
6.
▀lll▀l
▀lll▀
adalah string literal terkompresi yang setara dengan"of >ic"
.l
butuh waktu lama, jadi hasilnya 6.7.
ÑÑÑÑÑÑÑÿWÿk
Pertama kita dorong 7 karakter baris baru (
Ñ
) dan kemudian string kosong (ÿ
). Tumpukan dibungkus dalam array (W
), dan kemudian indeks dari string kosong dalam array tersebut ditemukan.8.
ü`½½
ü
adalah karakter ruang.`
mendorong nilai ASCII (32), lalu terbagi dua dua kali (½½
).9.
9
Hanya literal.
10.
..≥°
..
adalah.
karakter literal . Itu bertambah (≥
), yang mem-parsing string sebagai angka, default ke 0 karena itu bukan angka yang valid, dan menambahkannya ke 1. Kemudian kita menghitung 10 1 (°
).11.
$$J
$
mendorong nilai register saat ini, awalnya 1. Jadi, tekan 1 dua kali, gabungkan tumpukan dan cetak.12.
3dd
Tekan 3 dan gandakan dua kali.
13.
7ƒ
Menekan angka Fibonacci 7.
14.
2≡≡≡Σ
Tekan 2, rangkap tiga tiga kali, meninggalkan 7 2 di tumpukan. Kemudian ambil jumlah tumpukan (
Σ
).15.
║F
║
adalah pembatas untuk base-220 number literals. Karena ini adalah di akhir baris, itu tidak perlu diakhiri.16.
4º
Hitung 2 4 .
17.
0ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~ò~
ò
bitate negate,~
adalah aratemetic negate. Menggabungkan operator-operator ini, kita dapat meningkatkan 0 17 kali.18.
6DD++
Tekan 6, duplikat dua kali, dan hitung 6 + 6 + 6.
19.
8π
Tekan bilangan prima 8.
20.
τ╛hτ*
Tekan 10 (
τ
), dapatkan elemen pertama (h
) dari faktor prima (╛
), kalikan dengan 10.21
"≤"≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤≤A
Demikian pula dengan cuplikan sebelumnya, string
"≤"
diurai menjadi 0. Kami menurunkannya 21 kali, lalu mengambil nilai absolut.22.
1111 11v11%L1111 11v11%L
Di sini kita menghitung 1111 div 11 mod 11, yaitu 2, lalu cetak 2. Kemudian lakukan lagi.
sumber
PowerShell, skor
12, 91 byte.14, 176 byteSunting:
(),""
Pondering 15 dengan sesuatu seperti"ZZZZZZZZZZZZZZZA".InDeXof("A")
tetapi tidak bisa menggunakan kembali titik atau 'e' ..PowerShell tidak dapat melakukan variabel tanpa $, tidak bisa melakukan eksponensial, bit shifting, Pi, ceil (), dll. Dengan simbol-simbol dasar, dan sebagian besar mengetik koercian ke / dari bool dan ke / dari angka-sebagai-string, jadi ada ruang yang relatif kecil untuk menghasilkan angka sintaksis rendah.
sumber
0
, jadi 13 bisa0xd
. Anda dapat meletakkannya5
di tempat normalnya, membebaskan+
untuk menggabungkan1
. Itu seharusnya membuat Anda mencapai 14. Jika Anda perlu menyimpan karakter, kunci hashtable bisa lebih dari satu huruf. Dan jika Anda memiliki cara luang untuk mendapatkan jumlah penjumlahan, Anda dapat melakukan10
=1e1
.""-(""-(""-lt(""-""))-(""-lt(""-"")))
. Itu membebaskan$?
untuk menjumlahkan, dan kemudian Anda dapat melakukan1e1
hal yang saya sarankan.t
bentrokan dengan kedua versi 1.(""-eq"")-(""-(""-eq""))
tampaknya lebih baik,q
di hashtable mudah diganti.TI-Basic (83 series), skor
2122232425 (1003 bytes)Lihat http://tibasicdev.wikidot.com/one-byte-tokens untuk daftar hal-hal yang menjadi tantangan dan tidak diizinkan di sini.
Semua ini dapat berupa program yang lengkap, karena baris terakhir suatu program akan dicetak secara otomatis. Tapi (kecuali 17, yang panjangnya beberapa baris), mereka juga bisa menjadi cuplikan di layar beranda.
Pada titik ini, saya tidak melihat cara lain untuk mendapatkan setiap nilai nol dari token yang tersisa tersedia. Jika ada perbaikan yang harus dilakukan, itu harus melibatkan terlebih dahulu membuat beberapa solusi di atas yang lebih konservatif.
Penjelasan
A=A
adalah boolean 1 karena variabelnyaA
sama dengan dirinya sendiri.B
adalah 0 secara default,tan(tan(cos(cos(cos(B
sekitar 2.21, dan kemudian kita mengambil lantai.C!°
adalah 1 derajat dalam radian, sekitar 0,017. Beberapa kekuatan positif dari ini adalah tanh (2), sekitar 0,964. Kami menyandikan kekuatan itu dalam biner menggunakan perkalian tersirat dan√(
, dan kemudian ambiltanh⁻¹(
.cosh(sinh⁻¹(X
disederhanakan menjadi₁₀^(
adalah built-in satu byte untuk kekuatan 10, dan 10 ^ 10 ^ 0 = 10 ^ 1 = 10.F nPr F
adalah 1.sin(tan⁻¹(X
disederhanakanG≤G
adalah 1, demikian[[G≤G]...[G≤G]]
juga vektor kolom 13x1. Mengambil produk dari transposnya dengan sendirinya memberikan matriks[[13]]
, yang determinannya adalah 13.not(H)
adalah 1.tanh(not(H))
hanya beberapa angka yang tidak sama dengan 0 atau 1, danln(XXX....X)ln(X)^⁻1
akan menyederhanakan ke jumlahX
's di log pertama asalkanX
bukan 0 (sehingga log ada) dan bukan 1 (sehingga kita tidak membagi oleh 0).e^(e^(e^(F
mengevaluasi menjadi sekitar 15,15, dan kemudian kita naik ke lantai.J≥J
adalah 1.identity(
membangun matriks identitas 1x1,dim(
menemukan dimensi baris dan kolomnya, dansum(
menambahkannya untuk mendapatkan 2. Kemudian kita melakukan ini lagi, menambahkan dimensi matriks 2x2 untuk mendapatkan 4, dan sekali lagi, menambahkan dimensi matriks 4x4 untuk mendapatkan 8, dan sekali lagi, menambahkan dimensi dari matriks 8x8 untuk mendapatkan 16.K nCr K
adalah koefisien binomial 0 pilih 0, atau 1. Menambahkan bersama 17 1 menghasilkan 17.i-i-...-i
menyederhanakan ⁻18i, dan menerimaabs(
memberi 18.rand→L
menyimpan bilangan real acak ke L, tetapi kami tidak peduli apa itu. Kami menghitunglog(L)⁻¹log(L^19)
, yang menyederhanakan menjadi 19.sinh(sinh(cos⁻¹(I
sedikit lebih dari 4, jadiseq(III,I,I,sinh(sinh(cos⁻¹(I
berikan daftar{0 1 8 27 64}
yang rata-rata aritmatika adalah 20.π
harus memberi 21; kami menyandikan kekuatan itu di ternary menggunakan multiplikasi tersirat dan³√(
.3×√(
sebagai root cube dan(
untuk perkalian.Fix 0
adalah pengaturan untuk menampilkan 0 digit setelah desimal, membulatkan semua nilai menjadi bilangan bulat.sin⁻¹(ᴇ0
mengevaluasi ke π / 2, dan π / 2 dikalikan dengan sendirinya 7 kali memberi sekitar 23,59, yang menjadi 24.5*5
adalah 25. (Akan lebih konservatif untuk menggunakan5
untuk mendapatkan 5, dan mengadaptasi solusi yang digunakan di sana untuk 25. Tetapi cara ini menghemat banyak ruang, dan*
bukan karakter yang sangat berguna karena ada multiplikasi tersirat.)sumber
SOGL , skor
161820, 109 byte, 47 karakter digunakansumber
Brachylog , 16 bilangan bulat, 86 byte
Cobalah online!(Input mengontrol program mana yang dijalankan, dari 1 hingga N)
Penjelasan
sumber
Jelly , skor 22, 177 byte
Coba sekaligus atau Coba satu per satu (argumen adalah output mana yang Anda inginkan).
Karakter yang tidak digunakan:
sumber
A
keduanya 2 dan 4 , bukan?22¹£€Y
tautan utama, Anda dapat menjalankan semua snippet sekaligus. tio.run/##y0rNyan8///hzjauOsc6Ry5jLt0jG3UPbTq0icuUy4zLnMuC6/…Reng, skor 40, 149 byte
Coba di sini!
Semua huruf besar adalah angka, jadi itu bagus. Semua kecuali dua di antaranya adalah cuplikan. Dua yang merupakan program:
Tautan yang disediakan memungkinkan seseorang untuk melihat tumpukan saat berjalan. Saya akan menulis penjelasan nanti.
sumber
CJam, skor 27, 168 byte
1-3:
X
,Y
,Z
Variabel
X
,,Y
danZ
diinisialisasi ke 1, 2, dan 3, masing-masing.4:
",,,,",
Dorong senar
,,,,
dan ambil panjangnya.5-9:
5
,6
,7
,8
,9
Numerik literal.
10-20 :
A
-K
Variabel yang diinisialisasi.
21:
U)))))))))))))))))))))
Variabel
U
diinisialisasi ke0
. DorongU
dan tambah 22 kali.22:
22
Numerik literal.
23:
';(((((((((';((((((((
Dorong karakter
;
dan kurangi 9 kali untuk mendapatkan2
, lalu dorong;
lagi dan kurangi 8 kali untuk mendapatkan3
.24:
4m!
Ambil faktorial 4.
25:
TT=TT=+TT=TT=TT=TT=TT=++++
TT=
mendorong1
. Kode ini setara dengan1 1+1 1 1 1 1++++
.26:
N:i~W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-
N
mendorong string yang berisi baris baru.:i
mengubahnya menjadi daftar kode karakter, menghasilkan[10]
.~
membukanya, memberi10
.W-
adalah setara dengan menambahkan satu. Bertambah 10 enam belas kali memberi 26.27:
LLLLLLLLLLLLLLLLLLLLLLLLLLL0]0#
Temukan indeks 0 dalam daftar di mana 0 berada di indeks ke-27.
Karakter masih tersedia:
$%&*./1<>?@MOPQRSV[\^_`abcdefghjklmnopqrstuvwxyz{|}
Beberapa catatan untuk ekspansi potensial:
Saya mungkin harus mengubah 10-20 untuk menggunakan variabel untuk sesuatu yang lain. Jika saya mendapatkan angka lebih tinggi dari 1, saya bisa menggunakan
*
(dan mungkin operator bitwise, tapi saya pikir mereka tidak akan banyak membantu).Saya masih punya
S
, apa pun kebaikan yang akan membantu saya.Jika saya mengubah 26 menjadi
N{}/iW-W-W-W-W-W-W-W-W-W-W-W-W-W-W-W-
, maka:
akan tersedia.Saya dapat mendorong beberapa daftar kosong dan mendapatkan lebih banyak nol dengan variabel yang ada. Saya juga bisa mendapatkan π, tapi itu sepertinya tidak terlalu berguna kecuali saya bisa melemparkannya ke integer, dan
m
(untukm[
) dani
sudah diambil.Dalam hal manipulasi array, saya dapat:
%
atauf
*
|
:M1|2|3|
sumber
U)))))))))))))))))))))
dan 22 menjadi22
yang akan gratis1
untuk potongan nanti.:i
pada daftar digit (misalnya[P]1b
memberi3
).''
bukannya';
dan kemudian cukup gunakan(
untuk membungkus sekitar untuk angka (jadi sekitar 65k(
untuk setiap digit). Itu akan membebaskan;
untuk hal lain, tetapi saya tidak yakin seberapa berguna itu.;
, tetapi saat ini saya tidak bisa.Haskell , skor 13, 86 byte
Cobalah online!
Terima kasih kepada Ørjan Johansen karena menemukan cara untuk memperbaiki surat saya tumpang tindih sambil menjaga skor tiga belas. (Juga untuk keluar dari jalan mereka untuk memberi tahu saya tentang ini sementara jawaban ini dihapus.)
pi/pi
adalah1.0
.sum[]
mengevaluasi ke0
,0^0
ke1
dansum[1,1]
ke2
.3
untuk9
hanya memecahkan kode diri mereka sendiri.length"eeeeeeeeee"
menghasilkan panjang string, yaitu10
.2+2+2+2+2+2
adalah12
.0xD
heksadesimal untuk13
.sumber