Berpotensi sangat sulit, tetapi saya telah melihat beberapa hal luar biasa keluar dari situs ini.

Tujuannya adalah untuk menulis program, dalam bahasa apa pun, yang melakukan apa pun yang Anda inginkan. Tangkapannya adalah bahwa program tersebut harus valid setelah setiap pergantian karakter.

Pergeseran karakter melingkar sangat mirip dengan Pergeseran Sirkular . Beberapa contoh hal-hal saya jelas.

Untuk program int main() { return 0; }

bergeser ke kiri dengan 6 karakter menghasilkan: in() { return 0; }int ma

bergeser ke kiri dengan hasil 1 karakter: nt main() { return 0; }i

bergeser ke kanan dengan hasil 10 karakter: eturn 0; }int main() { r

Namun, program ini jelas tidak mematuhi aturan.

Aturan

• Bahasa apapun
• Pemenang ditentukan oleh jumlah suara
• Solusi yang melakukan hal yang sama, atau hal yang sama sekali berbeda untuk setiap rotasi, akan menerima 100 virtual up-vote untuk skor mereka.

PEMBARUAN Saya pikir ini sudah berlangsung cukup lama. Pemenang, dengan suara terbanyak (termasuk suara virtual) adalah Mark Byers. Sudah selesai dilakukan dengan baik!

Gunakan bahasa yang tepat untuk tugas itu. Dalam hal ini, itu Befunge .

Bahasa ini secara alami memungkinkan rotasi karena:

• Semua perintah adalah satu karakter.
• Kontrol membungkus ketika mencapai akhir program, mulai lagi dari awal.

Program Befunge ini mencetak output yang sama persis ("Halo") terlepas dari berapa banyak "pergeseran karakter melingkar" yang Anda gunakan:

86*01p75*1-02p447**1-03p439**04p439**05p455**1+06p662**07p75*1-08p645**2-09p69*4+019+p57*029+p59*1-039+p555**1-049+p88*059+p86*01p75*1-02p447**1-03p439**04p439**05p455**1+06p662**07p75*1-08p645**2-09p69*4+019+p57*029+p59*1-039+p555**1-049+p88*059+p645**2-00p645**2-00p

Ini berjalan pada Befungee . Ini mengharuskan papan ditingkatkan (bukan 80 karakter default) Ini bisa dijalankan seperti ini:

python befungee.py -w400 hello.bef

Ini bekerja dengan terlebih dahulu secara dinamis menghasilkan dan menyimpan program yang mencetak "Halo" dan kemudian menimpa byte pertama untuk mengarahkan kontrol ke program yang baru ditulis. Program ini ditulis dua kali sehingga jika byte tidak ditulis dengan benar pertama kali, itu akan diperbaiki kedua kalinya.

Idenya dapat diperluas untuk menghasilkan program kompleksitas sewenang-wenang apa pun.

Brainf * ck

Pilih alat yang tepat untuk pekerjaan itu - sebuah pepatah yang tidak pernah lebih relevan daripada pekerjaan ini di sini!

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++.+.>++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++.++++++++++++++.>++++++++++.+

Program unshifted yang Anda lihat di sini hanya mencetak SHIFT(plus baris baru). Pergeseran melingkar akan menghasilkan berbagai output lainnya, meskipun selalu akan menghasilkan enam karakter ASCII.

Commodore 64 BASIC

?kependekan dari PRINT, dan :merupakan pemisah pernyataan, jadi:

?1:?2:?3:          // prints 1, 2, and 3
:?1:?2:?3          // prints 1, 2, and 3
3:?1:?2:?          // adds a program line 3 :PRINT1:PRINT2:PRINT
?3:?1:?2:          // prints 3, 1, and 2
:?3:?1:?2          // prints 3, 1, and 2
2:?3:?1:?          // adds a program line 2 :PRINT3:PRINT1:PRINT
?2:?3:?1:          // prints 2, 3, and 1
:?2:?3:?1          // prints 2, 3, and 1
1:?2:?3:?          // adds a program line 1 :PRINT2:PRINT3:PRINT

Variasi yang lebih panjang tentu saja mungkin:

?1:?2:?3:?4:?5:?6:?7:?8:?9:?10:?11:

dll ...

Naskah Golf

Program ini mencetak beberapa angka yang selalu berjumlah 2, terlepas dari bagaimana program digeser:

10 2 base
0 2 base1
 2 base10
2 base10 
 base10 2
base10 2 
ase10 2 b
se10 2 ba
e10 2 bas

Garis cetakan pertama 1010(10 dalam biner), garis cetakan kedua 02dan semua jalur lainnya dicetak 2.

Memperbarui:

Program ini dapat diuji di sini . Harap dicatat bahwa saya telah menambahkan ns di akhir setiap baris hanya untuk memformat output; ini dapat dihapus dan program masih berfungsi.

Ruby, mungkin salah satu solusi terpendek yang mungkin:

p

Dan satu lagi yang sedikit lebih panjang dan lebih menarik:

;;p";p;";p

biner x86 16 bit

Dibuat secara manual dengan bantuan ( 1 2 ) tabel, nasm, dan ndisasm ini. Ini akan selalu kembali tanpa crash atau infinite loop, karena tidak ada byte yang melompat atau mengubah stack dan itu diisi dengan NOP untuk mengakhiri dengan retinstruksi byte tunggal dalam hal apa pun.

Dalam sebagian besar kasus, ini akan menghasilkan FOOatau menguranginya. Jika AXrusak, ini akan memanggil int 10 acak (ini mengubah kecepatan kursor berkedip di salah satu tes saya), tetapi biasanya tidak menghasilkan crash.

Untuk mencoba, letakkan hexdump di file dan gunakan xxd -r foo.hex > foo.com, kemudian jalankan di lingkungan dos (saya menggunakan dosbox).

Berikut ini adalah hex dump dari file ini:

0000000: b846 0d90 90fe c490 9090 bb05 0090 9043  .F.............C
0000010: 43cd 1090 b84f 0d90 90fe c490 9090 bb05  C....O..........
0000020: 0090 9043 43cd 1090 b84f 0d90 90fe c490  ...CC....O......
0000030: 9090 bb05 0090 9043 43cd 1090 9090 c3    .......CC......

Dan beberapa offset menarik yang bisa dibongkar:

+0

00000000  B8420D            mov ax,0xd42
00000003  90                nop
00000004  90                nop
00000005  FEC4              inc ah
00000007  90                nop
00000008  90                nop
00000009  90                nop
0000000A  BB0500            mov bx,0x5
0000000D  90                nop
0000000E  90                nop
0000000F  43                inc bx
00000010  43                inc bx
00000011  CD10              int 0x10
00000013  90                nop
00000014  B84F0D            mov ax,0xd4f
00000017  90                nop
00000018  90                nop
00000019  FEC4              inc ah
0000001B  90                nop
0000001C  90                nop
0000001D  90                nop
0000001E  BB0500            mov bx,0x5
00000021  90                nop
00000022  90                nop
00000023  43                inc bx
00000024  43                inc bx
00000025  CD10              int 0x10
00000027  90                nop
00000028  B84F0D            mov ax,0xd4f
0000002B  90                nop
0000002C  90                nop
0000002D  FEC4              inc ah
0000002F  90                nop
00000030  90                nop 
00000031  90                nop
00000032  BB0500            mov bx,0x5
00000035  90                nop
00000036  90                nop
00000037  43                inc bx
00000038  43                inc bx
00000039  CD10              int 0x10
0000003B  90                nop
0000003C  90                nop
0000003D  90                nop
0000003E  C3                ret

(untuk contoh di bawah ini, sisa biner masih valid)

+1

00000000  42                inc dx
00000001  0D9090            or ax,0x9090
00000004  FEC4              inc ah
00000006  90                nop

+2

00000001  0D9090            or ax,0x9090
00000004  FEC4              inc ah
00000006  90                nop

+6

00000000  C4909090          les dx,[bx+si-0x6f70]
00000004  BB0500            mov bx,0x5
00000007  90                nop
00000008  90                nop
00000009  43                inc bx
0000000A  43                inc bx
0000000B  CD10              int 0x10

+11

00000000  050090            add ax,0x9000
00000003  90                nop
00000004  43                inc bx
00000005  43                inc bx
00000006  CD10              int 0x10

+12

00000000  00909043          add [bx+si+0x4390],dl
00000004  43                inc bx
00000005  CD10              int 0x10

+18

00000000  1090B84F          adc [bx+si+0x4fb8],dl
00000004  0D9090            or ax,0x9090
00000007  FEC4              inc ah
00000009  90                nop

(offset lain hanyalah pengulangan di atas)

+58

00000000  10909090          adc [bx+si-0x6f70],dl
00000004  C3                ret

Jawaban Unary:

000000 ... 00000

^ 44391 Nol

Program kucing. Tidak masalah bagaimana Anda memutar, ini adalah program yang sama.

PHP

Ini dia, program PHP yang valid:

Is this still funny?

Scala

Kutipan bersarang:

""""""""""""""""""""""""""""""""

C ++ / Java / C # / Scala

Komentar:

///////////////////////////////////

Perintah kosong:

;;;;;;;;;;;;;;;

Pesta

Kombinasi komentar, Whitespace dan Shell:

#

:

Sed

Perintah mandiri yang valid:

p P n N g G d D h H

Kombinasi di atas:

p;P;n;N;g;G;d;D;h;H;

AWK

Untuk mencetak setiap baris file:

1

atau

//

Jangan cetak apa pun:

0

Perl

abcd

J

Pertama, skrip untuk memeriksa rotasi program yang valid s:

check =: 3 :'((<;(". :: (''Err''"_)))@:(y |.~]))"0 i.#y'

Misalnya, program +/1 5(jumlah 1 dan 5) memberi:

 check '+/1 5'
┌───────┬───┐
│┌─────┐│6  │
││+/1 5││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│Err│
││/1 5+││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│Err│
││1 5+/││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│6  │
││ 5+/1││   │
│└─────┘│   │
├───────┼───┤
│┌─────┐│6  │
││5+/1 ││   │
│└─────┘│   │
└───────┴───┘

Kemudian, program yang membosankan dan valid:

check '1x1'
┌─────┬───────┐
│┌───┐│2.71828│ NB. e^1
││1x1││       │
│└───┘│       │
├─────┼───────┤
│┌───┐│       │ NB. Value of variable x11
││x11││       │ 
│└───┘│       │
├─────┼───────┤
│┌───┐│11     │ NB. Arbitrary precision integer
││11x││       │
│└───┘│       │
└─────┴───────┘

dc

program dc mudah valid dalam rotasi apa pun. Sebagai contoh:

4 8 * 2 + p  # 34
8 * 2 + p 4  # stack empty / 10
...

Kode Mesin

Bagaimana dengan kode mesin Z80 / Intel 8051 untuk NOP .

Tentu itu Tidak Ada Operasi, tetapi TIDAK butuh satu atau dua siklus ... Anda dapat memiliki sebanyak atau sedikit dari yang Anda inginkan.

Dan saya tidak setuju dengan jawaban Ruby di atas - Saya pikir satu byte 00h lebih pendek dari Ruby p.

k

.""

Mengevaluasi string kosong

"."

Mengembalikan karakter titik

"".

Mengembalikan aplikasi parsial '.' (formulir sianik) ke daftar karakter kosong.

sh, bash

cc
cc: no input files

cc diputar adalah cc lagi, tetapi sangat tidak ramah jika disebut telanjang.

dh 
dh: cannot read debian/control: No such file or directory
hd 

dh debhelper juga tidak terlalu kooperatif, sementara hexdump hanya menunggu input.

gs
sg 

Ghostscript memulai mode interaktif, sementara kelompok beralih menampilkan pesan penggunaan - solusi yang valid di sini, juga.

Dan di sini adalah skrip untuk menemukan kandidat untuk program semacam itu:

#!/bin/bash
for name in /sbin/* /usr/sbin/* /bin/* /usr/bin/*
do 
    len=${#name}
    # len=3 => 1:2 0:1, 2:1 0:2
    # len=4 => 1:3 0:1, 2:2 0:2, 3:1 0:3
    for n in $(seq 1 $((len-1)))
    do
        init=${name:n:len-n}
        rest=${name:0:n}
        # echo $init$rest
        which /usr/bin/$init$rest 2>/dev/null >/dev/null && echo $name $init$rest $n
    done 
done

Jika menemukan urutan yang lebih lama juga, seperti (arj, jar) atau (luatex, texlua) yang tidak valid setelah setiap shift, tetapi hanya setelah beberapa shift tertentu, yang saya salah baca pada awalnya, tetapi ada beberapa, jadi mudah untuk menyaringnya dengan tangan.

Contoh Python Trivial:

"a""b""c""d""e""f""g""h""i""j""k""l""m""n""o""p""q""r""s""t""u""v""w""x""y""z""";print

Dapat digeser tiga karakter berulang-ulang untuk mengungkapkan alfabet lebih banyak.

Python

123456789.0

Cukup evaluasi beberapa angka

dc sudah digunakan, tetapi program berikut selalu menghasilkan output yang sama , tidak peduli rotasi: D

d

ouputs

dc: stack empty