Potenzialmente molto difficile, ma ho visto cose straordinarie uscire da questo sito.

L'obiettivo è scrivere un programma, in qualsiasi lingua, che faccia quello che vuoi. Il problema è che il programma deve essere valido dopo ogni spostamento circolare dei caratteri.

Uno spostamento di carattere circolare è molto simile a uno spostamento circolare . Alcuni esempi chiariscono le mie cose.

Per il programma int main() { return 0; }

spostando a sinistra di 6 caratteri si ottiene: in() { return 0; }int ma

spostandosi a sinistra di 1 carattere si ottiene: nt main() { return 0; }i

spostando a destra di 10 caratteri si ottiene: eturn 0; }int main() { r

Tuttavia, questo programma ovviamente non è conforme alle regole.

Regole

• Qualunque lingua
• Il vincitore viene deciso dal conteggio dei voti positivi
• Le soluzioni che fanno la stessa cosa, o cose completamente diverse per ogni rotazione, riceveranno 100 voti virtuali al loro punteggio.

AGGIORNAMENTO Penso che questo sia andato avanti abbastanza a lungo. Il vincitore, con il maggior numero di voti (voti virtuali inclusi) è Mark Byers. Molto bene!

Usa la lingua giusta per l'attività. In questo caso, quello è Befunge .

Questo linguaggio consente naturalmente le rotazioni perché:

• Tutti i comandi sono un singolo carattere.
• Il controllo si avvolge quando raggiunge la fine del programma, ricominciando dall'inizio.

Questo programma Befunge stampa esattamente lo stesso risultato ("Hello") indipendentemente da quanti "spostamenti di caratteri circolari" usi:

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

Funziona su Befungee . Richiede che il tabellone sia aumentato (non il valore predefinito di 80 caratteri). Può essere eseguito in questo modo:

python befungee.py -w400 hello.bef

Funziona generando e archiviando dinamicamente un programma che stampa "Hello" e quindi sovrascrive il primo byte per reindirizzare il controllo nel programma appena scritto. Il programma viene scritto due volte in modo tale che se un byte non viene scritto correttamente la prima volta, verrà corretto la seconda volta.

L'idea potrebbe essere estesa per produrre qualsiasi programma di complessità arbitraria.

Brainf * ck

Scegli lo strumento giusto per il lavoro - un adagio che non è mai stato più rilevante di questo lavoro proprio qui!

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

Il programma non spostato che vedi qui viene semplicemente stampato SHIFT(più una nuova riga). I turni arbitrariamente circolari produrranno varie altre uscite, anche se produrranno sempre sei caratteri ASCII.

Commodore 64 BASIC

?è l'abbreviazione di PRINT, ed :è un separatore di istruzioni, quindi:

?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

Naturalmente sono possibili variazioni più lunghe:

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

eccetera...

Golfscript

Questo programma stampa alcune cifre che si sommano sempre fino a 2, indipendentemente da come viene spostato il programma:

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

La prima riga viene stampata 1010(10 in binario), la seconda riga viene 02stampata e tutte le altre righe vengono stampate 2.

Aggiornare:

Il programma può essere testato qui . Si noti che ho aggiunto ns alla fine di ogni riga solo per la formattazione dell'output; questi possono essere rimossi e il programma funziona ancora.

Ruby, probabilmente una delle soluzioni più brevi possibili:

p

E un altro leggermente più lungo e più interessante:

;;p";p;";p

x86 16 bit binario

Costruito manualmente con l'aiuto di queste ( 1 2 ) tabelle, nasm e ndisasm. Questo ritornerà sempre senza un arresto anomalo o un ciclo infinito, perché nessun byte è un salto o modifica lo stack e viene riempito con NOP per terminare con retun'istruzione a byte singolo in ogni caso.

Nella maggior parte dei casi questo produrrà FOOo una sottostringa di quello. Se AXè rotto, questo chiamerà un int 10 casuale (questo ha cambiato la velocità di lampeggiamento del cursore in uno dei miei test), ma di solito non provoca un arresto anomalo.

Per provare, inserisci hexdump in un file e usa xxd -r foo.hex > foo.com, quindi esegui in un ambiente DOS (ho usato Dosbox).

Ecco un dump esadecimale di questo file:

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

E alcuni offset disassemblati interessanti:

+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

(per gli esempi seguenti, il resto del binario è ancora valido)

+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

(altri offset sono solo ripetizioni di quanto sopra)

+58

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

Risposta unaria:

000000 ... 00000

^ 44391 Zeri

Programma Cat. Non importa come ruoti, è lo stesso programma.

PHP

Ecco a voi un programma PHP valido:

Is this still funny?

Scala

Citazioni nidificate:

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

C ++ / Java / C # / Scala

Commento:

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

Comando vuoto:

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

bash

Combinazione integrata di commenti, spazi bianchi e Shell:

#

:

sed

Comandi validi indipendenti:

p P n N g G d D h H

Una combinazione di quanto sopra:

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

AWK

Per stampare ogni riga del file:

1

o

//

Non stampare nulla:

0

Perl

abcd

J

Innanzitutto, uno script per verificare le rotazioni valide di un programma s:

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

Ad esempio, il programma +/1 5(somma di 1 e 5) fornisce:

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

Quindi, un programma noioso e valido:

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

dc

i programmi in cc sono facilmente validi in qualsiasi rotazione. Per esempio:

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

Codice macchina

Che ne dici del codice macchina Z80 / Intel 8051 per NOP .

Certo che non fa alcuna operazione, ma occupa un ciclo o due ... puoi averne quante ne vuoi quante ne vuoi.

E non sono d'accordo con la risposta di Ruby sopra - penso che un singolo byte 00h sia più corto di un Ruby p.

K

.""

Valuta una stringa vuota

"."

Restituisce un carattere punto

"".

Restituisce l'applicazione parziale di '.' (forma dianica) in un elenco di caratteri vuoto.

sh, bash

cc
cc: no input files

cc ruotato è di nuovo cc, ma non è molto amichevole se chiamato così nudo.

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

Anche il debhelper non è molto cooperativo, mentre hexdump attende solo l'input.

gs
sg 

Ghostscript avvia la modalità interattiva, mentre switch group mostra un messaggio di utilizzo: anche qui una soluzione valida.

Ed ecco la sceneggiatura per trovare candidati per tali programmi:

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

Se trova anche sequenze più lunghe, come (arj, jar) o (luatex, texlua) che non sono valide dopo ogni turno, ma solo dopo alcuni turni, che ho letto male all'inizio, ma ce ne sono pochi, quindi è facile per filtrarli a mano.

Trivial Python esempio:

"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

Può essere spostato ripetutamente di tre caratteri per rivelare sempre più l'alfabeto.

Pitone

123456789.0

Valuta solo alcuni numeri

dc è già utilizzato, ma il seguente programma emette sempre lo stesso , indipendentemente dalla rotazione: D

d

ouputs

dc: stack empty