Có khả năng rất khó khăn, nhưng tôi đã thấy một số điều tuyệt vời đến từ trang web này.

Mục tiêu là viết một chương trình, bằng bất kỳ ngôn ngữ nào, đó là bất cứ điều gì bạn muốn. Điều hấp dẫn là chương trình phải hợp lệ sau bất kỳ sự dịch chuyển vòng tròn nào của các ký tự.

Dịch chuyển ký tự tròn rất giống với Dịch chuyển tròn . Một số ví dụ rõ ràng của tôi lên.

Cho chương trình int main() { return 0; }

dịch chuyển sang trái bởi 6 ký tự mang lại: in() { return 0; }int ma

dịch chuyển sang trái bởi 1 ký tự mang lại: nt main() { return 0; }i

dịch chuyển sang phải bằng 10 ký tự: eturn 0; }int main() { r

Tuy nhiên, chương trình này rõ ràng không tuân thủ các quy tắc.

Quy tắc

• Bất kỳ ngôn ngữ
• Người chiến thắng được quyết định bằng cách tăng số phiếu
• Các giải pháp thực hiện cùng một điều, hoặc những điều hoàn toàn khác nhau cho mỗi vòng quay, sẽ nhận được 100 phiếu bầu ảo cho điểm số của họ.

CẬP NHẬT Tôi nghĩ rằng điều này đã diễn ra đủ lâu. Người chiến thắng, với nhiều phiếu bầu nhất (bao gồm cả phiếu ảo) là Mark Byers. Làm tốt!

Sử dụng ngôn ngữ phù hợp cho nhiệm vụ. Trong trường hợp này, đó là Befunge .

Ngôn ngữ này tự nhiên cho phép xoay vòng vì:

• Tất cả các lệnh là một ký tự duy nhất.
• Kiểm soát kết thúc tốt đẹp khi nó kết thúc chương trình, bắt đầu lại từ đầu.

Chương trình Befunge này in cùng một đầu ra chính xác ("Xin chào") bất kể bạn sử dụng bao nhiêu "ký tự tròn":

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

Nó chạy trên Befungee . Nó yêu cầu bảng được tăng lên (không phải mặc định 80 ký tự). Nó có thể được chạy như thế này:

python befungee.py -w400 hello.bef

Nó hoạt động bằng cách đầu tiên tự động tạo và lưu trữ một chương trình in "Xin chào" và sau đó ghi đè byte đầu tiên để chuyển hướng điều khiển vào chương trình mới được viết. Chương trình được viết hai lần để nếu một byte không được viết đúng lần đầu tiên, nó sẽ được sửa lại lần thứ hai.

Ý tưởng có thể được mở rộng để sản xuất bất kỳ chương trình phức tạp tùy ý.

Brainf * ck

Chọn công cụ phù hợp cho công việc - một câu ngạn ngữ chưa bao giờ phù hợp hơn công việc này ngay tại đây!

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

Chương trình chưa được dịch chuyển mà bạn thấy ở đây chỉ đơn giản là in SHIFT(cộng với một dòng mới). Các dịch chuyển vòng tròn bất thường sẽ tạo ra các đầu ra khác nhau, mặc dù nó sẽ luôn xuất ra sáu ký tự ASCII.

Hàng hóa 64 CƠ BẢN

?là viết tắt của PRINT, và :là một dấu phân cách câu lệnh, vì vậy:

?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

Tất nhiên, các biến thể dài hơn là có thể:

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

Vân vân...

Golf

Chương trình này in một số chữ số luôn có tổng bằng 2, bất kể chương trình được dịch chuyển như thế nào:

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

Dòng đầu tiên in 1010(10 ở dạng nhị phân), dòng thứ hai in 02và tất cả các dòng khác in2 .

Cập nhật:

Chương trình có thể được thử nghiệm ở đây . Xin lưu ý rằng tôi đã thêm ns ở cuối mỗi hàng chỉ để định dạng đầu ra; những cái này có thể được gỡ bỏ và chương trình vẫn hoạt động.

Ruby, có lẽ là một trong những giải pháp ngắn nhất có thể:

p

Và một cái khác hơi dài và thú vị hơn:

;;p";p;";p

nhị phân x86 16 bit

Được xây dựng thủ công với sự trợ giúp của các bảng ( 1 2 ), nasm và ndisasm này. Điều này sẽ luôn trở lại mà không có sự cố hoặc vòng lặp vô hạn, bởi vì không có byte nào nhảy hoặc thay đổi ngăn xếp và nó được lấp đầy bằng NOP để kết thúc bằng một retlệnh byte đơn trong mọi trường hợp.

Trong hầu hết các trường hợp, điều này sẽ xuất ra FOOhoặc một chuỗi con của điều đó. Nếu AXbị hỏng, điều này sẽ gọi một số 10 ngẫu nhiên (điều này đã thay đổi tốc độ nhấp nháy của con trỏ trong một trong các thử nghiệm của tôi), nhưng nó thường không dẫn đến sự cố.

Để thử, đặt hexdump vào một tệp và sử dụng xxd -r foo.hex > foo.com, sau đó chạy trong môi trường dos (tôi đã sử dụng dosbox).

Đây là một kết xuất hex của tập tin này:

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......

Và một số bù đắp thú vị đã được tháo gỡ:

+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

(đối với các ví dụ bên dưới, phần còn lại của nhị phân vẫn hợp lệ)

+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

(các phần bù khác chỉ là sự lặp lại ở trên)

+58

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

Trả lời đơn phương:

000000 ... 00000

^ 44391 Số không

Chương trình mèo. Bất kể bạn xoay như thế nào, đó là cùng một chương trình.

PHP

Ở đây bạn đi, một chương trình PHP hợp lệ:

Is this still funny?

Scala

Một trích dẫn lồng nhau:

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

C ++ / Java / C # / Scala

Bình luận:

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

Lệnh rỗng:

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

Bash

Kết hợp bình luận, khoảng trắng và Shell dựng sẵn:

#

:

Trầm tích

Các lệnh hợp lệ độc lập:

p P n N g G d D h H

Một sự kết hợp của trên:

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

AWK

Để in mọi dòng của tệp:

1

hoặc là

//

Đừng in bất cứ thứ gì:

0

Perl

abcd

J

Đầu tiên, một kịch bản để kiểm tra các vòng quay hợp lệ của một chương trình s:

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

Ví dụ: chương trình +/1 5(tổng 1 và 5) đưa ra:

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

Sau đó, một chương trình hợp lệ, nhàm chán:

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

đc

chương trình dc dễ dàng hợp lệ trong bất kỳ vòng quay. Ví dụ:

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

Mã máy

Làm thế nào về mã máy Z80 / Intel 8051 cho NOP .

Chắc chắn rằng nó không hoạt động, nhưng nó mất một hoặc hai chu kỳ ... bạn có thể có bao nhiêu hoặc ít trong số chúng như bạn muốn.

Và tôi không đồng ý với câu trả lời của Ruby ở trên - Tôi nghĩ rằng một byte đơn 00h ngắn hơn Ruby p.

k

.""

Đánh giá một chuỗi rỗng

"."

Trả về một ký tự dấu chấm

"".

Trả về ứng dụng một phần của '.' (dạng dyanic) vào một danh sách ký tự trống.

sh, bash

cc
cc: no input files

cc xoay là cc một lần nữa, nhưng nó không thân thiện lắm nếu được gọi là quá trần trụi.

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

dh debrcper không hợp tác quá, trong khi hexdump chỉ chờ đầu vào.

gs
sg 

Ghostscript bắt đầu chế độ tương tác, trong khi nhóm chuyển đổi hiển thị thông báo sử dụng - một giải pháp hợp lệ ở đây, imho, quá.

Và đây là kịch bản để tìm ứng viên cho các chương trình như vậy:

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

Nếu cũng tìm thấy các chuỗi dài hơn, như (arj, jar) hoặc (luatex, texlua) không hợp lệ sau mỗi ca, nhưng chỉ sau một số ca nhất định, mà tôi đã đọc sai lúc đầu, nhưng có rất ít, vì vậy rất dễ để lọc chúng ra bằng tay.

Ví dụ Python tầm thường:

"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

Có thể được thay đổi ba ký tự nhiều lần để tiết lộ ngày càng nhiều bảng chữ cái.

Con trăn

123456789.0

Chỉ cần đánh giá một số con số

dc đã được sử dụng, nhưng chương trình sau luôn xuất ra như nhau , bất kể xoay vòng: D

d

đầu ra

dc: stack empty