Möglicherweise sehr schwierig, aber ich habe einige erstaunliche Dinge gesehen, die aus dieser Site hervorgegangen sind.

Das Ziel ist es, ein Programm in jeder Sprache zu schreiben, das macht, was immer Sie wollen. Der Haken ist, dass das Programm nach jeder zirkulären Verschiebung der Zeichen gültig sein muss .

Eine kreisförmige Zeichenverschiebung ist sehr ähnlich zu einem Ringschiebe . Einige Beispiele meiner klaren Dinge.

Für das Programm int main() { return 0; }

Verschiebung um 6 Zeichen nach links ergibt: in() { return 0; }int ma

Verschiebung um 1 Zeichen nach links ergibt: nt main() { return 0; }i

Verschiebung nach rechts um 10 Zeichen ergibt: eturn 0; }int main() { r

Dieses Programm entspricht jedoch offensichtlich nicht den Regeln.

Regeln

• Jede Sprache
• Der Gewinner wird nach Anzahl der abgegebenen Stimmen ermittelt
• Lösungen, die das Gleiche tun oder für jede Rotation völlig andere Dinge tun, erhalten 100 virtuelle Upstimmen zu ihrer Punktzahl.

UPDATE Ich denke, das hat lange genug gedauert. Der Gewinner mit den meisten Stimmen (einschließlich virtueller Stimmen) ist Mark Byers. Gut gemacht!

Verwenden Sie die richtige Sprache für die Aufgabe. In diesem Fall ist das Befunge .

Diese Sprache erlaubt natürlich Rotationen, weil:

• Alle Befehle sind ein einzelnes Zeichen.
• Das Steuerelement beginnt am Ende des Programms von vorne.

Dieses Befunge-Programm druckt die exakt gleiche Ausgabe ("Hallo"), unabhängig davon, wie viele "kreisförmige Zeichenverschiebungen" Sie verwenden:

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

Es läuft auf Befungee . Das Board muss vergrößert werden (nicht die Standardeinstellung von 80 Zeichen). Es kann so ausgeführt werden:

python befungee.py -w400 hello.bef

Es funktioniert, indem zuerst dynamisch ein Programm generiert und gespeichert wird, das "Hallo" ausgibt, und dann das erste Byte überschrieben wird, um das Steuerelement in das neu geschriebene Programm umzuleiten. Das Programm wird zweimal geschrieben. Wenn ein Byte beim ersten Mal nicht korrekt geschrieben wird, wird es beim zweiten Mal korrigiert.

Die Idee könnte erweitert werden, um jedes Programm von beliebiger Komplexität zu produzieren.

Brainf * ck

Wählen Sie das richtige Werkzeug für den Job - ein Sprichwort, das hier noch nie relevanter war als dieser Job!

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

Das nicht verschobene Programm, das Sie hier sehen, wird einfach gedruckt SHIFT(plus eine neue Zeile). Unbeabsichtigte kreisförmige Verschiebungen erzeugen verschiedene andere Ausgaben, obwohl immer sechs ASCII-Zeichen ausgegeben werden.

Commodore 64 BASIC

?ist eine Abkürzung für PRINTund :ein Anweisungstrennzeichen.

?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

Längere Abweichungen sind selbstverständlich möglich:

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

etc...

Golfscript

Dieses Programm gibt einige Ziffern aus, die unabhängig von der Programmverschiebung immer 2 ergeben:

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

Die erste Zeile wird gedruckt 1010(10 in binär), die zweite Zeile wird gedruckt 02und alle anderen Zeilen werden gedruckt 2.

Aktualisieren:

Das Programm kann hier getestet werden . Bitte beachten Sie, dass ich ns am Ende jeder Zeile nur zum Formatieren der Ausgabe hinzugefügt habe . Diese können entfernt werden und das Programm funktioniert immer noch.

Ruby, wahrscheinlich eine der kürzesten möglichen Lösungen:

p

Und noch eine etwas längere und interessantere:

;;p";p;";p

x86 16-Bit-Binärdatei

Manuell konstruiert mit Hilfe dieser ( 1 2 ) Tabellen, nasm und ndisasm. Dies wird immer ohne einen Absturz oder eine Endlosschleife zurückgegeben, da keine Bytes springen oder den Stapel ändern und es retin jedem Fall mit NOPs gefüllt ist, um mit einem Einzelbyte-Befehl zu enden .

In den meisten Fällen wird dies ausgegeben FOOoder eine Teilzeichenfolge davon. Wenn dies nicht funktioniert AX, wird eine zufällige Ganzzahl 10 aufgerufen (dies hat die Blinkgeschwindigkeit des Cursors in einem meiner Tests geändert), führt jedoch normalerweise nicht zu einem Absturz.

Zum Ausprobieren lege den Hexdump in eine Datei und verwende ihn xxd -r foo.hex > foo.comdann in einer DOS-Umgebung (ich habe Dosbox verwendet).

Hier ist ein Hex-Dump dieser Datei:

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

Und einige interessante demontierte Versätze:

+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

(für die folgenden Beispiele ist der Rest der Binärdatei noch gültig)

+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

(Andere Offsets sind nur Wiederholungen der oben genannten)

+58

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

Unäre Antwort:

000000 ... 00000

^ 44391 Nullen

Katzenprogramm. Egal wie Sie sich drehen, es ist das gleiche Programm.

PHP

Los geht's, ein gültiges PHP-Programm:

Is this still funny?

Scala

Eine geschachtelte Anführungszeichen:

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

C ++ / Java / C # / Scala

Kommentar:

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

Leerer Befehl:

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

Bash

Kommentar, eingebaute Whitespace und Shell Kombination:

#

:

Sed

Standalone-gültige Befehle:

p P n N g G d D h H

Eine Kombination der oben genannten:

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

AWK

So drucken Sie jede Zeile der Datei:

1

oder

//

Nichts drucken:

0

Perl

abcd

J

Zuerst ein Skript, um gültige Rotationen eines Programms zu überprüfen s:

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

Zum Beispiel +/1 5ergibt das Programm (Summe von 1 und 5):

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

Dann ein langweiliges, gültiges Programm:

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

dc

Gleichstromprogramme sind in jeder Umdrehung leicht gültig. Beispielsweise:

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

Maschinensprache

Wie wäre es mit Z80 / Intel 8051 Maschinencode für NOP .

Sicher, es macht keine Operation, aber es nimmt ein oder zwei Zyklen in Anspruch ... Sie können so viele oder so wenige davon haben, wie Sie wollen.

Und ich bin mit der obigen Ruby- Antwort nicht einverstanden - ich denke, ein einzelnes Byte 00h ist kürzer als ein Ruby p.

k

.""

Wertet eine leere Zeichenfolge aus

"."

Gibt ein Punktzeichen zurück

"".

Gibt eine teilweise Anwendung von '.' (dyanische Form) zu einer leeren Zeichenliste.

sh, bash

cc
cc: no input files

cc gedreht ist wieder cc, aber es ist nicht sehr freundlich, wenn man es so nackt nennt.

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

dh debhelper ist auch nicht sehr kooperativ, während hexdump nur auf Eingaben wartet.

gs
sg 

Ghostscript startet den interaktiven Modus, während die Schaltergruppe eine Verwendungsmeldung anzeigt - auch hier eine gültige Lösung.

Und hier ist das Skript, um Kandidaten für solche Programme zu finden:

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

Findet man auch längere Sequenzen wie (arj, jar) oder (luatex, texlua), die nicht nach jeder Schicht gültig sind, sondern erst nach einigen bestimmten Schichten, die ich am Anfang falsch verstanden habe, aber es gibt nur wenige, so ist es einfach um sie von Hand herauszufiltern.

Triviales Python-Beispiel:

"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

Kann wiederholt um drei Zeichen verschoben werden, um mehr und mehr von dem Alphabet zu enthüllen.

Python

123456789.0

Bewerten Sie einfach einige Zahlen

dc wird bereits verwendet, aber das folgende Programm gibt unabhängig von der Drehung immer dasselbe aus : D

d

Ausgänge

dc: stack empty