Penghitung Geiger adalah perangkat yang digunakan untuk mendeteksi radiasi.

Kami akan membuat program penghitung Geiger.

Seperti yang kita semua tahu, ketika radiasi mengenai program komputer, ia menghapus secara tepat 1 byte secara acak. Jadi program penghitung Geiger adalah program yang dengan sendirinya tidak melakukan apa-apa, tetapi ketika byte apa pun dihapus, program yang dimodifikasi akan dicetak beep, untuk menunjukkan adanya radiasi.

Jawaban akan dinilai dalam byte dengan lebih sedikit byte menjadi lebih baik. Jawaban harus minimal 1 byte.

Program Anda dapat mencetak beepdengan mengekor baris baru atau mencetak satu baris baru untuk output kosong, asalkan konsisten. Program Anda juga dapat menggunakan kasus yang berbeda untuk beepseperti BEEP, bEEPatau Beepselama ia melakukannya secara konsisten.

Hilang , 303 293 263 253 238 228 byte

v^"peeb"<\>"beepvv"((>@@>>%%>>(((((([[[[[[\
>>>>>>>>>//>>>>>>>>>>>>>>/>>/>>>>>>>>>>>>>\\
>>>>>>>>//>>>>\>>>>>>>>>>/>>>>>>>>>>>>>>>>>\\
>/>>>>>>>/>>>>>>>>>>>>\>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>\\>>>>\>>>>>>>>>>>>>>>>\

Cobalah online!

Skrip verifikasi (dipinjam dari jawaban pengguna 202729 ). Sayangnya ini hanya dapat menguji setengah dari kode sekaligus, tetapi yakinlah saya telah menguji seluruh program.

Aduh, ini yang sulit. Saya akan mengutip jawaban yang dihapus WW:

Lost mungkin adalah bahasa yang paling menarik untuk tantangan ini. Dalam Lost, lokasi awal dan arah pointer sepenuhnya acak, sehingga untuk membuat program deterministik Anda harus memperhitungkan setiap lokasi dan arah awal yang mungkin. Pada saat yang sama, dengan sifat tantangan ini Anda juga harus memperhitungkan setiap byte tunggal yang dihapus.

Sayangnya, jawabannya tidak memperhitungkan penghapusan baris baru, yang mengacaukan segalanya.

Penjelasan:

(perhatikan bahwa beberapa byte mungkin mati di sana-sini)

Pertama mari kita bicara tentang struktur umum kode:

v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\       Processing line
>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\      Beep line
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\     Back-up beep line
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\    Back-up return line
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\    Return line

Semuanya kecuali garis pemrosesan harus seluruhnya terdiri dari salah >satu atau salah satu dari itu \/. Mengapa? Sebagai contoh, mari kita hapus baris baru:

v^^"peeb"<<\/"beepvv"((>>>@@>>%%>>(((((([[[[[[[\>>>>>>>>>>>//>>>>>>>>>>>>>>>>>>>/>>>>>>>>>>>>>>\\
>>>>>>>>>//>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\\
>//>>>>>>>>>>>>>>>>>>>>\\>>>>>>>>>>>>>>>>>>>>>>>>\\
>>>>>>>>>>>>>>>>>>>>>>>>\\>>>>>>\>>>>>>>>>>>>>>>>>\

Baris pertama sekarang jauh lebih panjang daripada sisa blok. Jika sebuah pointer muncul pada >\/karakter non- dengan gerakan vertikal, maka itu akan terjebak dalam infinite loop.

Bagian detektor radiasi terbesar adalah bagian di ujung setiap baris.

 \
 \\
 >\\
 >>\\
 >>>\

Biasanya IP yang melewati ini dari baris pertama akan keluar dari baris terakhir. Namun, jika ada karakter pada baris yang dihapus, maka garis tersebut bergeser ke bawah, misalnya:

 \
 \\
 >\\
 >\\
 >>>\

Dan IP sebagai gantinya keluar dari baris yang tidak ada byte (dengan pengecualian dari baris terakhir, di mana ia keluar dari yang kedua ke terakhir).

Dari sana, masing-masing dari empat baris pertama akan dialihkan ke baris kedua:

v
>>>>>>>>>>
>>>>>>>>//
>/

Yang kemudian akan mengarah ke salah satu dari dua beepers.

v^"peeb"<<\/"beepvv"((>
>>>>>>>>>>//

Jika salah satu byte di beeper pertama telah dihapus, maka itu beralih ke yang kedua:

v^^"peb"<<\/"beepvv"((>
>>>>>>>>>>>//

Keduanya beepkemudian memimpin kembali ke baris pertama dan berakhir @.

Beberapa bagian lain-lain:

Yang (((((([[[[[[[digunakan untuk membersihkan tumpukan ketika pointer mulai dalam sepasang tanda kutip dan berakhir sampai mendorong seluruh baris pertama ke stack. Sayang sekali panjangnya karena baris pertama dapat dihapus untuk membuat garis pertama dua kali lipat. Bereksperimen dalam menghasilkan beeparitmatika bukannya tanda kutip berakhir lebih lama.

The \s dan /s tersebar di seluruh garis yang ada untuk golf byte di bagian atas kode dengan mengarahkan pointer ke garis yang benar. Karena sebagian besar garis bawah hanyalah pengisi, hanya garis atas yang dapat dip Golf. Jika ada yang punya ide untuk tumpukan bukti radiasi lebih pendek lebih jelas dari apa yang saya miliki sekarang, jangan ragu untuk berkomentar.

Hexagony , 38 byte

.....;p;<>b;e;/<b;e;;p...@@.......;@..

Cobalah online!

Program verifikasi.

Penjelasan

Kami menggunakan deteksi otomatis Hexagony untuk panjang sisi segi enam di sini.

Jika tidak ada byte yang dihapus, program memiliki panjang sisi 4 dan terlihat seperti ini:

Namun, jika byte dihapus. Ada 2 kasus.

1. Byte yang dihapus adalah setelah byte kedua <.

   Alur eksekusi adalah:

   

   Ada 2 berturut-turut @pada baris ke-5, jadi meskipun salah satu dari mereka dihapus, IP akan aman menekan a @.

2. Byte yang dihapus berada pada atau sebelum detik <.

   Kemudian bagian kedua akan tetap utuh, dan IP tidak lagi diarahkan ke atas oleh itu <. Gambar aliran eksekusi:

   

Hexagony , 34 29 byte

//..>;e;<b@;p;/|/;e;;\.b@;p<@

Cobalah online! Verifikasi!

Penjelasan:

Berikut adalah kode normal yang diformat ke dalam segi enam yang tepat menggunakan HexagonyColorer :

Ganda //di awal memastikan bahwa jalan ini selalu diambil. Jika ada karakter yang dihapus, @itu dihapus dari jalan, baik yang digeser kembali atau dihapus sendiri:

Dalam hal ini, kami telah menghapus karakter setelah |, yang membuatnya mengikuti jalur ini, mencetak beep:

Jika kita menghapus karakter dari sebelum |(atau karakter |itu sendiri), kita mengikuti printer bip yang lain:

Kami kemudian telah memperhitungkan semua kemungkinan dan kami hanya beepmenggunakan bagian-bagian program yang belum disinari.

Brainfuck yang memodifikasi sendiri , 73 63 byte

<<[[[[<<]]>[[.>>..>>.[,>]]]]   bbeepp+[<<<]>>[[>]>>>.>>..>>.,+]

Cobalah online! Verifikasi!

Spasi di tengah kode sebenarnya mewakili byte NUL.

Penjelasan:

Kode ini dibagi menjadi dua bagian dengan 3 NUL byte di tengah. Keduanya pada dasarnya mencetak beepjika bagian lain diiradiasi (dengan beberapa pengecualian).

Pertama, <<[[pada awalnya adalah untuk memastikan bahwa semua ]cocok setiap saat. [s tidak akan berusaha mencari kecocokan ]jika sel positif, sementara ]s lakukan . Jika ada yang ]melompat kembali ke salah satu kurung ini biasanya langsung melompat kembali karena sel 0.

Bagian selanjutnya, [[<<]]>lalu periksa apakah panjang bagian 2 genap. Jika demikian, ia mengeksekusi setengah bagian lain dari 1, yang mencetak beepmenggunakan bbeepppada awal bagian 2.

[[.>>..>>.[,>]]]]

Itu kemudian menghapus semua bagian 2 sehingga tidak mengeksekusi.

Di bagian 2, kami memeriksa apakah panjang bagian 1 dan byte NUL habis dibagi 3dengan +[<<<]>>.

[[>]>>>.>>..>>.,+]

Demikian pula, kami mencetak beep.

Z80Golf , 53 36 34 byte

-16 byte terima kasih kepada @Lynn -2 byte terima kasih kepada @Neil

Karena ini hanya kode mesin Z80, ada banyak xxd -runsintables dalam kode ini, jadi miliki hexdump yang dapat dikembalikan:

00000000: ddb6 2120 10dd b615 280c 003e 62ff 3e65  ..! ....(..>b.>e
00000010: ffff 3e70 ff76 003e 62ff 3e65 ffff 3e70  ..>p.v.>b.>e..>p
00000020: ff76                                     .v

Cobalah online! (penguji lengkap dengan Python)

Penjelasan

z80golf adalah mesin Z80 hipotetis Anarki Golf, di mana call $8000adalah putchar, call $8003adalah getchar, haltmembuat penerjemah keluar, program Anda ditempatkan $0000, dan semua memori lainnya diisi dengan nol. Membuat program yang tahan radiasi dalam perakitan cukup sulit, tetapi teknik yang secara umum bermanfaat adalah menggunakan instruksi idempoten satu byte. Sebagai contoh,

or c        ; b1    ; a = a | c

hanya satu byte, dan a | c | c == a | c, sehingga dapat dibuat tahan radiasi dengan hanya mengulangi instruksi. Pada Z80, beban langsung 8-bit adalah dua byte (di mana yang langsung berada di byte kedua), sehingga Anda dapat memuat beberapa nilai ke dalam register dengan andal juga. Inilah yang awalnya saya lakukan di awal program, sehingga Anda dapat menganalisis varian yang lebih panjang yang saya arsipkan di bagian bawah jawaban, tetapi kemudian saya menyadari bahwa ada cara yang lebih sederhana.

Program ini terdiri dari dua muatan independen, di mana salah satunya bisa rusak oleh radiasi. Saya memeriksa apakah byte telah dihapus, dan apakah byte yang dihapus itu sebelum salinan kedua payload, dengan memeriksa nilai beberapa alamat memori absolut.

Pertama, kita harus keluar jika tidak ada radiasi yang diamati:

    or a, (ix+endbyte) ; dd b6 21 ; a |= memory[ix+0x0021]
    jr nz, midbyte     ; 20 10    ; jump to a halt instruction if not zero

Jika ada byte yang dihapus, maka semua byte akan bergeser dan $0020akan berisi yang terakhir 76, jadi $0021akan menjadi nol. Kami mampu memancarkan awal program, meskipun hampir tidak ada redundansi:

• Jika lompatan offset $10dihilangkan, maka radiasi akan terdeteksi dengan benar, lompatan tidak akan diambil, dan offset tidak akan masalah. Byte pertama dari instruksi selanjutnya akan dikonsumsi, tetapi karena itu dirancang agar tahan terhadap penghapusan byte, ini tidak masalah.
• Jika opcode lompat $20dihilangkan, maka lompatan offset $10akan mendekodekan sebagai djnz $ffe4(menggunakan byte instruksi berikutnya sebagai offset - lihat di atas), yang merupakan instruksi loop - decrement B, dan lompat jika hasilnya bukan nol. Karena ffe4-ffffdiisi dengan angka nol nop, dan penghitung program membungkus, ini akan menjalankan awal program 256 kali, dan akhirnya melanjutkan. Saya kagum ini berhasil.
• Menghapus $ddakan membuat sisa dari decode snippet as or (hl) / ld ($1020), hl, dan kemudian geser ke bagian selanjutnya dari program. Tidak orakan mengubah register penting, dan karena HL adalah nol pada saat ini, penulisan juga akan dibatalkan.
• Menghapus $b6akan membuat decode sisanya seperti ld ($1020), ixdan melanjutkan seperti di atas.
• Menghapus $21akan membuat decoder memakannya $20, memicu djnzperilaku.

Perhatikan bahwa menggunakan or a, (ix+*)menyimpan dua byte lebih ld a, (**) / and a / and aberkat pemeriksaan terintegrasi untuk nol.

Kita sekarang perlu memutuskan mana dari dua salinan payload yang akan dieksekusi:

    or (ix+midbyte)  ; dd b6 15
    jr z, otherimpl  ; 28 0c
    nop              ; 00
    ; first payload
    ld a, 'b'        ; 3e 62
    rst $0038        ; ff
    ld a, 'e'        ; 3e 65
    rst $0038        ; ff
    rst $0038        ; ff
    ld a, 'p'        ; 3e 70
    rst $0038        ; ff
midbyte:
    halt             ; 76
otherimpl:
    nop              ; 00
    ld a, 'b'        ; 3e 62
    ; ...            ; ...
    rst $0038        ; ff
endbyte:
    halt             ; 76

Dua salinan dipisahkan oleh nop, karena lompatan relatif digunakan untuk memilih di antara mereka, dan radiasi bisa menggeser program dengan cara yang akan membuat lompatan melewati byte pertama setelah tujuan. Selain itu, nop dikodekan sebagai nol, yang membuatnya mudah untuk mendeteksi byte yang digeser. Perhatikan bahwa tidak masalah payload mana yang dipilih jika sakelar itu sendiri rusak, karena kedua salinan tersebut aman. Mari kita pastikan bahwa itu tidak akan melompat ke memori yang tidak diinisialisasi, meskipun:

• Menghapus $ddakan membuat dua byte selanjutnya decode sebagai or (hl) / dec d. Clobbers D. Bukan masalah besar.
• Menghapus $b6akan membuat pengkodean yang lebih lama tanpa dokumen dec d. Sama seperti di atas.
• Menghapus $15akan membaca $28alih - alih sebagai offset, dan eksekusi akan dilanjutkan pada $0c, seperti di bawah ini.
• Ketika $28menghilang, $0cditerjemahkan sebagai inc c. Muatan tidak peduli c.
• Menghapus $0c- untuk itulah gunanya. Jika tidak, byte pertama dari muatan akan dibaca sebagai lompatan offset, dan program akan melompat ke memori yang tidak diinisialisasi.

Payloadnya sendiri cukup sederhana. Saya pikir ukuran kecil dari string membuat pendekatan ini lebih kecil dari satu loop, dan lebih mudah untuk membuat posisi independen seperti ini. The edi beepmengulangi, jadi saya bisa mencukur habis satu ld a. Juga, karena semua memori antara $0038dan $8000adalah memusatkan perhatian, aku bisa jatuh melalui itu dan menggunakan lebih pendek rstvarian dari callinstruksi, yang hanya bekerja untuk $0, $8, $10dan seterusnya, hingga $38.

Pendekatan yang lebih tua

64 byte

00000000: 2e3f 3f2e 3f3f 7e7e a7a7 201f 1e2b 2b1e  .??.??~~.. ..++.
00000010: 2b2b 6b00 7ea7 2814 003e 62cd 0080 3e65  ++k.~.(..>b...>e
00000020: cd00 80cd 0080 3e70 cd00 8076 003e 62cd  ......>p...v.>b.
00000030: 0080 3e65 cd00 80cd 0080 3e70 cd00 8076  ..>e......>p...v

58 byte

00000000: 2e39 392e 3939 7e7e a7a7 2019 3a25 00a7  .99.99~~.. .:%..
00000010: 2814 003e 62cd 0080 3e65 cd00 80cd 0080  (..>b...>e......
00000020: 3e70 cd00 8076 003e 62cd 0080 3e65 cd00  >p...v.>b...>e..
00000030: 80cd 0080 3e70 cd00 8076                 ....>p...v

53 byte

Yang ini memiliki penjelasan dalam riwayat sunting, tetapi tidak terlalu berbeda.

00000000: 3a34 00a7 a720 193a 2000 a728 1400 3e62  :4... .: ..(..>b
00000010: cd00 803e 65cd 0080 cd00 803e 70cd 0080  ...>e......>p...
00000020: 7600 3e62 cd00 803e 65cd 0080 cd00 803e  v.>b...>e......>
00000030: 70cd 0080 76                             p...v

Bagaimana jika: output non-kosong baik-baik saja alih-alih berbunyi bip

1 byte

v

haltBiasanya program, tetapi jika radiasi menghapusnya, maka memori akan penuh dengan nol, membuat $8000eksekusi dalam jumlah tak terbatas, mencetak banyak byte nol.

> <> , 23 byte

<|o<"beep"/
>o<"beep"<\

Cobalah online! Verifikasi.

Sejujurnya sangat mengejutkan betapa singkatnya saya mendapatkan ini. Berakhir dengan kesalahan.

Versi yang tidak salah, 29 byte

<<;oooo"beep"/
 ;oooo"beep"<\

Cobalah online!

Klein , satu dari setiap topologi, berjumlah 291 byte

Setelah melihat jawaban WW menggunakan 001topologi, saya memutuskan untuk melihat betapa sulitnya melakukan Counter Geiger untuk setiap topologi. (Spoiler: sangat sulit. Sulit untuk mengetahui ke mana pointer akan pergi tanpa gerakan tangan yang membuat saya terlihat seperti sedang mencari tahu di mana tangan kiri saya)

Verifikasi!

(Saya juga berpikir untuk menulis sebuah program yang merupakan penghitung Geiger yang valid pada semua topologi, tetapi itu mungkin harus menunggu. Jika ada orang yang ingin mencoba, saya menawarkan hadiah 500 rep)

000 dan 010, 21 byte

<<@"peeb"/
.@"peeb"<\

Coba 000 online! dan Coba 010 online!

Ini porting dari ><>solusi saya . Ini jelas berfungsi 000, karena itulah topologi default untuk sebagian besar bahasa 2D, tetapi saya terkejut bahwa itu juga berfungsi 010.

001 dan 011, 26 byte

!.<<@"peeb"/
.@"peeb"..<..

Coba 001 online! dan Coba 011 online!

Yang ini disalin langsung dari jawaban WW . Terima kasih!

100, 21 byte

//@"peeb"\
@"peeb".</

Cobalah online!

101, 21 byte

//@"peeb"/
@"peeb".<!

Cobalah online!

110, 26 byte

<.<@"peeb"\\
.\@."peeb".\<

Cobalah online!

111, 24 byte

<<@"peeb"<\
...@"peeb"//

Cobalah online!

200, 21 byte

<<@"peeb"\
@"peeb".!/

Cobalah online!

201, 31 byte

\\.\.@"peeb"</./
./...@"peeb"<\

Cobalah online!

Sejauh ini yang paling menyebalkan.

210, 26 byte

/\\@"peeb"</\
/@.."peeb"<\

Cobalah online!

211, 27 byte

\\."peeb"((</
!/@@<"peeb"<\

Cobalah online!

Satu-satunya di mana saya harus menangani memasuki pager melalui sisi kanan.

Brainfuck yang memodifikasi sendiri , 144 102 byte

Unprintables ditampilkan sebagai escape sequence (misalnya \x01).

\xa8<<[[<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<[[[.<-]>[>-]\x01qffb\x00\x00beep\x00]]]<[>]<<[>[-<+>]+<<]>[[>]>>[.>]]\x01

Verifikasi!

Pesona Rise , 29 byte

>>yyLL@"peeb"/
     @"peeb"L\

Cobalah online!

Pada dasarnya sama dengan jawaban Klein 000 atau> <> (saya mulai dengan yang Klein). Satu-satunya perubahan yang benar-benar diperlukan adalah untuk mengubah <menjadi Ldan .menjadi  (terjemahan simbol perintah), memasukkan titik masuk IP (perlu 2, jika tidak, penghapusan akan menghasilkan program non-kompilasi) dan penyisipan yperintah dela untuk mendapatkan dua IP untuk digabung (dengan demikian hanya mencetak satu beep), sekali lagi, perlu dua. Juga diperlukan memasukkan NOP tambahan untuk menjaga panjang garis tetap sama. Klein juga nyaman digunakan @untuk "mencetak dan mengakhiri."

Tidak ada kemampuan untuk menggunakan spasi putih di kiri bawah, karena setiap reflektor untuk mengubah arah menghambat kemampuan untuk mendeteksi radiasi. misalnya (26 byte, disinari y):

/yLL@"peeb"/
\<<  @"peeb"L\

Mencetak tidak ada keluaran, karena segmen entri yang bengkok menyebabkan refleksi ulang ke terminator saluran bawah.

Befunge-93 , 55 byte

<< >       vv
>,,@#"beep"<"
v  |   _ #-<_
>"peeb",,,,@>

Cobalah online! Verifikasi!

Saya berharap untuk mendapatkannya sedikit lebih kecil dari ini, tetapi panjang beepprinter adalah hambatannya.

Wumpus , 37 34 32 31 byte

777*7..@ $o&4"beep"|"@peeb"4&o@

Cobalah online! Verifikasi!

Solusi ini menggunakan fakta yang .melompat ke posisi modulus panjang program.

Atau untuk jumlah byte yang sama

" @o&4"beep"}@
@o&4"beep"}$}  

Cobalah online! Verifikasi!

Yang ini menggunakan perbedaan dalam arah penunjuk untuk panjang garis ganjil dan genap. (Saya tidak benar-benar tahu cara kerja yang pertama "saat baris baru dihapus)

Klein (001), 26 byte

!.<<@"peeb"/
.@"peeb"..<..

Cobalah online!

Memeriksa!

Penjelasan

Program ini mengambil keuntungan dari topologi unik Klein khususnya topologi 001 , yang merupakan botol Klein.

Program yang belum diedit mengikuti jalur eksekusi:

Menghapus byte dari program dapat mempengaruhi program dalam 4 cara (masing-masing dengan warna yang berbeda):

Hal pertama yang perlu diperhatikan adalah bahwa <<akan selalu membelokkan ip ke kiri asal pada awalnya. Jika salah satu <dihapus, yang lain menggantikannya. Jadi jika ada byte yang dihapus dari bagian merah, jalur eksekusi berikut akan diikuti:

Jika byte biru dihapus, kami mendapatkan jalur yang sangat sederhana:

Jika baris baru dihapus, kami mendapatkan jalur:

Jalur kuning sedikit lebih kompleks. Karena garis bawah adalah satu lebih panjang dari garis atas, ketika program dikuadratkan pada awal pelaksanaan, karakter virtual ditambahkan ke akhir baris pertama untuk membuat mereka ukuran yang sama. Jika ada byte pada baris kedua yang dihapus, garis itu dipersingkat dan karakter virtual itu tidak ditambahkan. Ini penting karena !biasanya melompati karakter virtual, tetapi jika tidak ada, ia melompati /.

Backhand , 25 21 byte

vv""ppeeeebb""jjHH@

Cobalah online! Verifikasi!

Ini menggunakan kemampuan Backhand untuk mengubah nilai langkah penunjuk untuk melewati instruksi setiap langkah dan menyelesaikan masalah redunancy dengan rapi. Kemudian menggunakan jperintah untuk memeriksa apakah kode disinari dengan melompat ke karakter terakhir ( @, berhenti) jika tidak, dan melompat ke yang terakhir kedua ( H, berhenti dan tumpukan output) jika demikian.