Crea un programma con un semplice GOTO

Il tuo compito è quello di costruire il più grande programma possibile che usi esattamente un GOTO, senza il quale l'intero programma (o almeno una parte enorme di esso) deve essere completamente ristrutturato. Il punteggio viene conteggiato come il numero di affermazioni nel tuo codice che cambiano posto o vengono introdotte di recente (la rimozione delle istruzioni non si aggiunge al tuo punteggio) quando il codice viene ristrutturato senza GOTO (ad altri è consentito contestare la tua ristrutturazione presentando un elegante). Poiché si tratta di bowling di codici, il punteggio più alto vince.

Nota: non rivendico alcuna responsabilità per gli attacchi del velociraptor tentando questa sfida.

C fizzbuzz

Questa soluzione gira attorno all'idea di interrupt e variabili di etichetta (solo gcc, scusate). Il programma imposta un timer che chiama periodicamente main, dove andiamo a qualunque punto l'ultima esecuzione del nostro gestore di interrupt (main) ci ha detto che dovremmo.

Non ho mai usato timer o variabili di etichetta prima, quindi penso che ci sia molto da lanciare qui.

#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

Non sono molto bravo a giocare a bowling, ma sospetto che questo possa interessare il PO. Questo è un setaccio di Eratostene usando un goto variabile. Se questo fosse "refactored", dubito che una parte sarebbe riutilizzabile, a parte forse le prime righe. Al termine del setaccio, tutte le rimanenti 1s @primesnell'array corrispondono ai valori primi.

Per ulteriore divertimento, vengono utilizzati no ands, ors, ternaries, condizionals o operatori di confronto di qualsiasi tipo.

@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

Il mio uso delle macro forse non lo rende "un GOTO".
Ed è piuttosto breve, quindi "completamente ristrutturato" non è molto.
Ma ecco comunque il mio tentativo.

Legge un numero dallo standard input, lo stampa 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;
}