Potentiellement très difficile, mais j'ai vu des choses incroyables sortir de ce site.

Le but est d'écrire un programme, dans n'importe quelle langue, qui fait ce que vous voulez. Le hic, c'est que le programme doit être valide après tout décalage circulaire des caractères.

Un décalage de caractère circulaire est très similaire à un décalage circulaire . Quelques exemples mes choses claires.

Pour le programme int main() { return 0; }

un décalage vers la gauche de 6 caractères donne: in() { return 0; }int ma

un décalage vers la gauche de 1 caractère donne: nt main() { return 0; }i

un décalage vers la droite de 10 caractères donne: eturn 0; }int main() { r

Cependant, ce programme n'est évidemment pas conforme aux règles.

Règles

• N'importe quel langage
• Le gagnant est déterminé par le nombre de votes positifs
• Les solutions qui font la même chose, ou des choses complètement différentes pour chaque rotation, recevront 100 votes virtuels positifs à leur score.

MISE À JOUR Je pense que cela a duré assez longtemps. Le gagnant, avec le plus de votes (votes virtuels inclus) est Mark Byers. Bien joué!

Utilisez la bonne langue pour la tâche. Dans ce cas, c'est Befunge .

Ce langage permet naturellement des rotations car:

• Toutes les commandes sont un seul caractère.
• Le contrôle retourne à la fin du programme, en recommençant depuis le début.

Ce programme Befunge imprime exactement la même sortie ("Bonjour") quel que soit le nombre de "changements de caractères circulaires" que vous utilisez:

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

Il fonctionne sur Befungee . Cela nécessite que le plateau soit augmenté (pas le caractère par défaut de 80 caractères). Il peut être exécuté comme ceci:

python befungee.py -w400 hello.bef

Il fonctionne en générant et en stockant dynamiquement un programme qui imprime "Bonjour", puis en écrasant le premier octet pour rediriger le contrôle dans le programme nouvellement écrit. Le programme est écrit deux fois de sorte que si un octet n'est pas écrit correctement la première fois, il sera corrigé la deuxième fois.

L'idée pourrait être étendue pour produire n'importe quel programme d'une complexité arbitraire.

Brainf * ck

Choisissez le bon outil pour le travail - un adage qui n'a jamais été aussi pertinent que ce travail ici!

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

Le programme non décalé que vous voyez ici s'imprime simplement SHIFT(plus une nouvelle ligne). Des décalages circulaires atypiques produiront diverses autres sorties, bien qu'il produise toujours six caractères ASCII.

Commodore 64 BASIC

?est l'abréviation de PRINT, et :est un séparateur d'instructions, donc:

?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

Des variations plus longues sont bien sûr possibles:

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

etc...

Golfscript

Ce programme imprime quelques chiffres qui totalisent toujours 2, quelle que soit la façon dont le programme est décalé:

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

La première ligne s'imprime 1010(10 en binaire), la deuxième ligne s'imprime 02et toutes les autres lignes s'impriment 2.

Mise à jour:

Le programme peut être testé ici . Veuillez noter que j'ai ajouté des ns à la fin de chaque ligne uniquement pour formater la sortie; ceux-ci peuvent être supprimés et le programme fonctionne toujours.

Ruby, probablement l'une des solutions les plus courtes possibles:

p

Et un autre un peu plus long et plus intéressant:

;;p";p;";p

x86 16 bits binaire

Construit manuellement à l'aide de ces ( 1 2 ) tableaux, nasm et ndisasm. Cela retournera toujours sans plantage ou boucle infinie, car aucun octet ne fait de saut ou ne modifie la pile et il est rempli de NOP pour se terminer par une retinstruction à un octet dans tous les cas.

Dans la plupart des cas, cela produira FOOou une sous-chaîne de cela. Si AXest cassé, cela appellera un int 10 aléatoire (cela a changé la vitesse de clignotement du curseur dans l'un de mes tests), mais cela ne provoque généralement pas de plantage.

Pour l'essayer, mettez l'hexdump dans un fichier et utilisez xxd -r foo.hex > foo.com, puis exécutez dans un environnement dos (j'ai utilisé dosbox).

Voici un vidage hexadécimal de ce fichier:

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

Et quelques décalages intéressants démontés:

+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

(pour les exemples ci-dessous, le reste du binaire est toujours valide)

+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

(les autres décalages ne sont que des répétitions de ce qui précède)

+58

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

Réponse unaire:

000000 ... 00000

^ 44391 Zéros

Programme chat. Quelle que soit la rotation, c'est le même programme.

PHP

Voilà, un programme PHP valide:

Is this still funny?

Scala

A citations imbriquées:

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

C ++ / Java / C # / Scala

Commentaire:

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

Commande vide:

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

Frapper

Combinaison intégrée de commentaire, d'espaces blancs et de shell:

#

:

Sed

Commandes valides autonomes:

p P n N g G d D h H

Une combinaison des éléments ci-dessus:

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

AWK

Pour imprimer chaque ligne du fichier:

1

ou

//

N'imprimez rien:

0

Perl

abcd

J

Tout d'abord, un script pour vérifier les rotations valides d'un programme s:

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

Par exemple, le programme +/1 5(somme de 1 et 5) donne:

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

Ensuite, un programme ennuyeux et valide:

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

dc

Les programmes DC sont facilement valides dans n'importe quelle rotation. Par exemple:

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

Langage machine

Que diriez-vous du code machine Z80 / Intel 8051 pour NOP .

Bien sûr, il ne fait aucune opération, mais il prend un cycle ou deux ... vous pouvez en avoir autant ou aussi peu que vous le souhaitez.

Et je ne suis pas d'accord avec la réponse de Ruby ci-dessus - je pense qu'un seul octet 00h est plus court qu'un Ruby p.

k

.""

Évalue une chaîne vide

"."

Renvoie un caractère point

"".

Renvoie l'application partielle de '.' (forme dyanique) dans une liste de caractères vide.

sh, bash

cc
cc: no input files

cc en rotation est de nouveau cc, mais il n'est pas très sympathique s'il est appelé ainsi nu.

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

dh debhelper n'est pas non plus très coopératif, tandis que hexdump attend juste l'entrée.

gs
sg 

Ghostscript démarre le mode interactif, tandis que le groupe de commutateurs affiche un message d'utilisation - une solution valide ici, à mon humble avis également.

Et voici le script pour trouver des candidats pour de tels programmes:

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

Si trouve également des séquences plus longues, comme (arj, jar) ou (luatex, texlua) qui ne sont pas valides après chaque quart de travail, mais seulement après certains décalages, que j'ai mal lus au début, mais il y en a peu, donc c'est facile pour les filtrer à la main.

Exemple Trivial Python:

"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

Peut être déplacé de trois caractères à plusieurs reprises pour révéler de plus en plus de l'alphabet.

Python

123456789.0

Évaluez simplement quelques chiffres

dc est déjà utilisé, mais le programme suivant génère toujours la même chose , quelle que soit la rotation: D

d

sorties

dc: stack empty