Zbuduj program za pomocą jednego prostego GOTO

Twoim zadaniem jest zbudowanie jak największego programu, który używa dokładnie jednego GOTO, bez którego cały program (lub przynajmniej jego duża część) musi zostać całkowicie zrestrukturyzowany. Wynik jest liczony jako liczba instrukcji w kodzie, które zmieniają miejsca lub są nowo wprowadzone (usunięcie instrukcji nie dodaje do wyniku), gdy kod jest restrukturyzowany bez GOTO (inni mogą zakwestionować twoją restrukturyzację, przedstawiając więcej elegancki). Ponieważ jest to kręgle kodu, najwyższy wynik wygrywa.

Uwaga: nie ponoszę żadnej odpowiedzialności za ataki welociraptorów, podejmując wyzwanie.

C fizzbuzz

To rozwiązanie działa na zasadzie przerwań i etykiet zmiennych (tylko gcc, przepraszam). Program ustawia licznik czasu, który okresowo wywołuje main, gdzie mamy miejsce, w którym znajduje się ostatnie wykonanie naszego programu obsługi przerwań (main), który powiedział nam, że powinniśmy.

Nigdy wcześniej nie korzystałem z timerów ani zmiennych etykiet, więc myślę, że jest tu wiele do zrobienia.

#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

Nie jestem zbyt dobry w kręgle, ale podejrzewam, że może to zainteresować OP. To sito Eratostenesa wykorzystujące zmienną goto. Gdyby to „refaktoryzować”, wątpię, by którykolwiek z nich nadawałby się do ponownego wykorzystania, może poza kilkoma pierwszymi liniami. Kiedy sito się kończy, wszystkie pozostałe 1s w @primestablicy odpowiadają wartościom podstawowym.

Dla dodatkowej zabawy używa się żadnych znaków „and”, „or”, trójek, warunkowych lub operatorów porównania.

@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:

do

Moje użycie makr prawdopodobnie nie czyni go „jednym GOTO”.
I jest dość krótki, więc „całkowicie zrestrukturyzowany” to niewiele.
Ale i tak oto moja próba.

Odczytuje liczbę ze standardowego wejścia, drukuje ją 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;
}