Créez un programme avec un simple GOTO

Votre tâche consiste à créer le plus grand programme possible qui utilise exactement un GOTO, sans lequel l'ensemble du programme (ou du moins une énorme partie) doit être complètement restructuré. Le score est compté comme le nombre d'instructions dans votre code qui changent de place ou sont nouvellement introduites (la suppression des instructions n'ajoute pas à votre score) lorsque le code est restructuré sans le GOTO (d'autres sont autorisés à contester votre restructuration en présentant un plus élégant). Comme il s'agit de bowling de code, le meilleur score l'emporte.

Remarque: je ne revendique aucune responsabilité pour les attaques de vélociraptors en tentant ce défi.

C fizzbuzz

Cette solution tourne autour de l'idée des interruptions et des variables d'étiquette (gcc uniquement, désolé). Le programme met en place une minuterie qui appelle périodiquement main, où nous sommes arrivés à l'endroit où la dernière exécution de notre gestionnaire d'interruption (main) nous a dit que nous devrions.

Je n'ai jamais utilisé de minuteries ou de variables d'étiquette auparavant, donc je pense qu'il y a beaucoup à jouer ici.

#include <sys/time.h>
#include <signal.h>
#include <stdio.h>

int main(int argc)
{
    static int run = 1;
    static int* gotoloc = &&init;
    static int num = 0;
    static int limit = 50;

    goto *gotoloc;
init:
    signal(SIGVTALRM, (void (*)(int)) main);
    gotoloc = &&loop;

    struct itimerval it_val;

    it_val.it_value.tv_sec = 0;
    it_val.it_value.tv_usec = 100000;
    it_val.it_interval.tv_sec = 0;
    it_val.it_interval.tv_usec = 100000;
    setitimer(ITIMER_VIRTUAL, &it_val, NULL);

    while(run);

loop:
    num = num + 1;
    run = num < limit;
    gotoloc = &&notfizz + (&&fizz - &&notfizz) * !(num % 3);
    return 1;

fizz:
    printf("fizz");
    gotoloc = &&notbuzz + (&&buzz - &&notbuzz) * !(num % 5);
    return 1;

notfizz:
    gotoloc = &&notfizzbuzz + (&&buzz - &&notfizzbuzz) * !(num % 5);
    return 1;

buzz:
    printf("buzz\n");
    gotoloc = &&loop;
    return 1;

notbuzz:
    printf("\n");
    gotoloc = &&loop;
    return 1;

notfizzbuzz:
    printf("%d\n", num);
    gotoloc = &&loop;
    return 1;
}

Perl

Je ne suis pas très bon au bowling, mais je pense que cela peut intéresser l'OP. Il s'agit d'un tamis d'Eratosthène utilisant une variable goto. Si cela devait être «refactorisé», je doute que tout soit réutilisable, à part peut-être les premières lignes. Lorsque le tamis se termine, tous les 1s restants du @primestableau correspondent à des valeurs premières.

Pour plus de plaisir, aucun ands, ors, ternaires, conditionnels ou opérateurs de comparaison de toute nature sont utilisés.

@primes[2..1e4]=(1)x9999;
$a=2;
Y:
  $b=$a*~-$a;
X:
  $primes[$b+=$a+=$c=$a/100%2+$b/1e4%2]=0;
  goto"$c"^h;
Z:

C

Mon utilisation des macros n'en fait peut-être pas "un GOTO".
Et c'est assez court, donc "complètement restructuré" n'est pas grand-chose.
Mais voici ma tentative de toute façon.

Lit un nombre à partir de l'entrée standard, l'imprime modulu 3.

int main() {
    char s[100], *p, r=0;
    void *pl[] = { &&a, &&b, &&c, &&d, &&e, &&f, &&g, &&h, &&i, &&j, &&a, &&b, &&x, &&y, &&z }, *p1;
    p = gets(s);
    #define N(n) (pl+n)[!*p*60+*p-48];p++;goto *p1
    a: p1=N(0);
    b: p1=N(1);
    c: p1=N(2);
    d: p1=N(0);
    e: p1=N(1);
    f: p1=N(2);
    g: p1=N(0);
    h: p1=N(1);
    i: p1=N(2);
    j: p1=N(0);
    z: r++;
    y: r++;
    x: printf("%d\n", r);

    return 0;
}