Potencjalnie bardzo trudne, ale widziałem niesamowite rzeczy z tej strony.

Celem jest napisanie programu w dowolnym języku, który robi wszystko, co chcesz. Problem polega na tym, że program musi być ważny po każdym okrągłym przesunięciu znaków.

Okrągłe przesunięcie znaków jest bardzo podobne do przesunięcia kołowego . Kilka przykładów moich jasnych rzeczy.

Do programu int main() { return 0; }

przesunięcie w lewo o 6 znaków daje: in() { return 0; }int ma

przesunięcie w lewo o 1 znak daje: nt main() { return 0; }i

przesunięcie w prawo o 10 znaków daje: eturn 0; }int main() { r

Jednak ten program oczywiście nie jest zgodny z zasadami.

Zasady

• Dowolny język
• Zwycięzca jest wybierany na podstawie liczby głosów w górę
• Rozwiązania, które robią to samo lub całkowicie różne rzeczy dla każdej rotacji, otrzymają 100 wirtualnych głosów na ich wynik.

AKTUALIZACJA Myślę, że to trwało wystarczająco długo. Zwycięzcą z największą liczbą głosów (w tym głosów wirtualnych) jest Mark Byers. Dobra robota!

Użyj właściwego języka dla zadania. W tym przypadku to Befunge .

Ten język naturalnie dopuszcza rotacje, ponieważ:

• Wszystkie polecenia są jednym znakiem.
• Sterowanie zawija się, gdy osiąga koniec programu, zaczynając od początku od początku.

Ten program Befunge drukuje dokładnie takie same dane wyjściowe („Cześć”) bez względu na liczbę używanych „okrągłych przesunięć znaków”:

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

Działa na Befungee . Wymaga zwiększenia planszy (nie domyślnego 80 znaków). Można go uruchomić w następujący sposób:

python befungee.py -w400 hello.bef

Działa najpierw dynamicznie generując i przechowując program, który wypisuje „Cześć”, a następnie nadpisując pierwszy bajt, aby przekierować sterowanie do nowo napisanego programu. Program jest zapisywany dwukrotnie, więc jeśli bajt nie zostanie poprawnie zapisany za pierwszym razem, zostanie poprawiony za drugim razem.

Pomysł można rozszerzyć, aby stworzyć dowolny program o dowolnej złożoności.

Brainf * ck

Wybierz odpowiednie narzędzie do pracy - powiedzenie, które nigdy nie było bardziej odpowiednie niż ta praca tutaj!

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

Widoczny tutaj nieprzesunięty program po prostu drukuje SHIFT(plus nowy wiersz). Przesunięcia cykliczne w trybie arytmetycznym będą generować różne inne dane wyjściowe, chociaż zawsze będą generować sześć znaków ASCII.

Commodore 64 BASIC

?jest skrótem od PRINTi :jest separatorem instrukcji, więc:

?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

Możliwe są oczywiście dłuższe odmiany:

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

itp...

Golfscript

Ten program wypisuje cyfry, które zawsze sumują się do 2, niezależnie od tego, jak program jest przesunięty:

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

Drukuje się pierwsza linia 1010(10 w systemie binarnym), drukowana jest druga linia 02i wszystkie pozostałe linie 2.

Aktualizacja:

Program można przetestować tutaj . Pamiętaj, że dodałem ns na końcu każdego wiersza tylko w celu sformatowania wyjścia; można je usunąć, a program nadal działa.

Ruby, prawdopodobnie jedno z najkrótszych możliwych rozwiązań:

p

I jeszcze jeden nieco dłuższy i bardziej interesujący:

;;p";p;";p

x86 16 bitów binarnych

Ręcznie wykonana za pomocą tych ( 1 2 ), stoły, NASMa i NDISASM. To zawsze powróci bez awarii lub nieskończonej pętli, ponieważ żadne bajty nie są skokami ani nie zmieniają stosu i są wypełnione NOP, aby retw każdym przypadku zakończyć się instrukcją jednobajtową .

W większości przypadków spowoduje to wyjście FOOlub jego podłańcuch. Jeśli AXjest zepsuty, wywoła to losowe int 10 (to zmieniło szybkość migania kursora w jednym z moich testów), ale zwykle nie powoduje awarii.

Aby wypróbować, umieść xxd -r foo.hex > foo.comzrzut heksowy w pliku i użyj go , a następnie uruchom w środowisku dos (użyłem dosbox).

Oto zrzut heksowy tego pliku:

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

I kilka interesujących zdemontowanych przesunięć:

+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

(w poniższych przykładach reszta pliku binarnego jest nadal ważna)

+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

(inne przesunięcia to tylko powtórzenia powyższego)

+58

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

Unary Odpowiedź:

000000 ... 00000

^ 44391 Zera

Program dla kotów. Bez względu na to, jak się obracasz, jest to ten sam program.

PHP

Proszę, poprawny program PHP:

Is this still funny?

Scala

Zagnieżdżone cytaty:

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

C ++ / Java / C # / Scala

Komentarz:

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

Puste polecenie:

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

Grzmotnąć

Kombinacja wbudowanych komentarzy, białych znaków i powłoki:

#

:

Sed

Autonomiczne prawidłowe polecenia:

p P n N g G d D h H

Połączenie powyższych:

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

AWK

Aby wydrukować każdą linię pliku:

1

lub

//

Nic nie drukuj:

0

Perl

abcd

jot

Najpierw skrypt sprawdzający poprawne obroty programu s:

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

Na przykład program +/1 5(suma 1 i 5) daje:

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

Następnie nudny, prawidłowy program:

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

dc

Programy DC są z łatwością ważne w dowolnym obrocie. Na przykład:

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

Kod maszynowy

Co powiesz na kod maszynowy Z80 / Intel 8051 dla NOP .

Pewnie, że nie wykonuje żadnej operacji, ale zajmuje cykl lub dwa ... możesz mieć ich tyle lub tak mało, jak chcesz.

I nie zgadzam się z powyższą odpowiedzią Ruby - myślę, że jeden bajt 00h jest krótszy niż Ruby p.

k

.""

Ocenia pusty ciąg

"."

Zwraca znak kropki

"".

Zwraca częściowe zastosowanie „.” (forma dyaniczna) do pustej listy znaków.

sh, bash

cc
cc: no input files

Obrócona cc jest znowu cc, ale nie jest zbyt przyjazna, jeśli nazywa się ją tak nagą.

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

dh debhelper też nie bardzo współpracuje, podczas gdy hexdump tylko czeka na dane wejściowe.

gs
sg 

Ghostscript uruchamia tryb interaktywny, podczas gdy grupa przełączników wyświetla komunikat o użyciu - tutaj również jest ważne rozwiązanie, imho.

A oto skrypt do wyszukiwania kandydatów na takie programy:

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

Jeśli znajdzie dłuższe sekwencje, takie jak (arj, jar) lub (luatex, texlua), które nie są ważne po każdej zmianie, ale tylko po pewnych przesunięciach, które błędnie odczytałem na początku, ale jest kilka, więc jest to łatwe aby je odfiltrować ręcznie.

Przykład ciekawego Pythona:

"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

Można wielokrotnie przesuwać trzy znaki, aby odsłonić coraz więcej alfabetu.

Pyton

123456789.0

Po prostu oceń niektóre liczby

dc jest już używane, ale następujący program zawsze wyświetla to samo , bez względu na obrót: D

d

wyjścia

dc: stack empty