Tulis program atau fungsi terpendek yang menghasilkan 1000 angka atau urutan ini (0 atau 1-diindeks) yang dimulai dengan mereka.
[0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0,
1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1,
0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,
0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,
0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1,
0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1,
1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1,
1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1,
1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1,
1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1,
1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1,
1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1,
1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1,
1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1,
1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1,
1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1,
1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1,
1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1,
1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0,
0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1,
1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0]
code-golf
sequence
kolmogorov-complexity
John Mangual
sumber
sumber
Jawaban:
Jelly ,
1110 byteDisimpan 1 byte berkat @Dennis
Cobalah online!
Bagaimana?
Saya pertama kali memperhatikan bahwa pola berganti-ganti antara panjang 4 dan panjang 3, lewati langkah-4 setiap beberapa kali berjalan. Hal ini membuat saya mencari angka yang dapat dibagi ke dalam indeks saat ini, kemudian mengambil mod 2 dan lantai - yaitu mengambil bit paling tidak signifikan - untuk memberikan bit pada indeks itu dalam seri. Setelah banyak trial and error, saya menemukan yang
3.41845
melakukan hal itu, tetapi mengalikannya dengan perkiraan timbal baliknya (.29253
) lebih pendek satu byte.sumber
Ḃ
tetapi ternyata itu hanya mod 2 daripada bit terendah, jadi saya menambahkanḞ
untuk memperbaikinya. Ditukar sekarangȷḶ×⁽q£:ȷ5Ḃ
bekerja, selama 10 byte.Dyalog APL ,
998382 byteCobalah online!
Jelas bukan solusi yang dimaksudkan karena ini masih memiliki banyak data hardcode, tapi ini awal.
sumber
Ruby ,
34 29 2622 byteCobalah online!
Penjelasan cepat: ini bekerja karena angka ajaib 629. Saya perhatikan bahwa urutan mulai berulang setelah elemen ke-629, dan saya mencoba untuk "meningkatkan" beberapa jawaban yang ada, hanya menggunakan bilangan bulat matematika. Saya menemukan bahwa "angka ajaib" lainnya (0,29253) sebenarnya 184/629.
sumber
Jelly , 31 byte
Mengingat polanya mungkin ada cara yang lebih pendek ...
Cobalah online!
Bagaimana?
Mengeksploitasi struktur panjang run berulang yang terlihat hingga kedalaman tiga.
sumber
Java 8,
756462 byteMencetak seluruh urutan tanpa pembatas untuk menyimpan byte, karena mereka hanya akan
0
dan1
tetap.Ports jawaban Jelly @ ETHproductions , karena saya ragu saya menemukan sesuatu yang lebih pendek ..
Cobalah online.
Penjelasan:
Jawaban lama mengembalikan array yang dihasilkan ( 75 byte ):
Cobalah online.
Penjelasan:
sumber
JavaScript (Node.js) ,
4133 byte, portTerima kasih kepada Rick Hitchcock untuk 4+ byte
Cobalah online!
JavaScript (Node.js) , 121 byte, asli
Cobalah online!
sumber
f=(i=0)=>i<1e3?(i*.29253&1)+f(i+1):''
Stax ,
1311 byteJalankan dan debug di staxlang.xyz!
Port to Stax dari @ ETHproductions's Jelly answer (sebelum modifikasinya) dengan beberapa modifikasi oleh @recursive untuk menghemat dua byte.
sumber
Bahasa Wolfram (Mathematica) , 96 byte
Saya mencari otomat seluler yang melihat 4 tetangga di sebelah kiri dan menghasilkan pola berjalan kiri yang terlihat dalam data saat Anda Memisahkan data menjadi panjang 7 dan menjaga setiap baris ketiga.
Automaton seluler ini akan berjalan selama 29 generasi yang masing-masing rangkap tiga, mencocokkan urutan sempurna untuk karakter 1 hingga 629. Namun urutan mulai berulang pada karakter 630 daripada melanjutkan pola yang diamati, sehingga kode tambahan diperlukan untuk menangani pengulangan pola terpotong. Saya menghasilkan pola utama dua kali untuk mendapatkan 1258 karakter.
Tanpa kesalahan itu kita bisa melakukannya dalam 74 byte yang lebih pendek. Angka 47 adalah jumlah generasi yang diperlukan untuk mencapai 1000 karakter (ini sebenarnya berarti 1008 = 48 * 7 * 3)
Cobalah online!
sumber
Z80Golf , 27 byte
Cobalah online!
Diterjemahkan dari kode C ini:
Membongkar:
Ini pada dasarnya adalah pendekatan aritmatika titik tetap: (11149 + 65536) / 2 18 ≈ 0,29253, konstanta yang digunakan oleh jawaban lain.
sumber
J , 17 byte
Port AJ jawaban ETHproduction's Jelly.
Cobalah online!
sumber
Japt , 13 byte
Versi Japt dari jawaban Jelly ETHproduksi .
Bug diperbaiki berkat Oliver .
Coba di sini.
sumber
Arang , 13 byte
Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:
Berkat @ ASCII-only untuk memungkinkan pengindeksan untuk menerima float yang dilemparkan ke integer (dan kemudian secara otomatis mengurangi modulo 2 dalam kasus ini).
sumber
C,
555352 bytePort of Java Kevin Cruijssen menjawab . Cobalah online di sini .
Berkat vazt untuk bermain golf 2 byte dan untuk Jonathan Frech untuk bermain golf satu lagi.
Versi tidak disatukan:
sumber
i
diinisialisasi ke 0 karena bersifat global, sehingga Anda dapat menghapusi=0
dari penginisialisasi for-loop untuk menghemat 3 byte. Juga jika Anda memperkenalkan variabel kedua (sebagai parameterf()
) dan menetapkannyai++*.29253
, Anda dapat menghindari para pemain dan menyimpan 2 byte lainnya:i;f(j){for(;i<1e3;)printf("%d",(j=i++*.29253)%2);}
Cobalah secara online!i
diinisialisasi ke 0 di awal, tetapi jika kita ingin memanggil fungsi ini lebih dari sekali, itu tidak cukup baik. Menggunakanj
untuk menghindari para pemain adalah golf yang hebat, terima kasih./// , 63 byte
Cobalah online!
sumber