Primero echemos un vistazo al código formateado:

#include<stdio.h>

main() {
    int x = 0, y[14], *z = &y;

    *(z++) = 0x48;
    *(z++) = y[x++] + 0x1D;
    *(z++) = y[x++] + 0x07;
    *(z++) = y[x++] + 0x00;
    *(z++) = y[x++] + 0x03;
    *(z++) = y[x++] - 0x43;
    *(z++) = y[x++] - 0x0C;
    *(z++) = y[x++] + 0x57;
    *(z++) = y[x++] - 0x08;
    *(z++) = y[x++] + 0x03;
    *(z++) = y[x++] - 0x06;
    *(z++) = y[x++] - 0x08;
    *(z++) = y[x++] - 0x43;
    *(z++) = y[x] - 0x21;
    x = *(--z);

    while(y[x] != NULL)
        putchar(y[x++]);
}

Como vemos tenemos una matriz 'y' en la que almacenaremos los caracteres de "hello world" y una variable 'x' que sirve como índice para recorrer la matriz e imprimir cada uno de los caracteres en un while. De nuevo se utiliza la representación en ASCII de cada caracter, sin embargo esta vez hay que lidiar con punteros (direcciones de memoria).

El operador & sirve para obtener la dirección de memoria de una variable, mientras que el operador * sirve para referirse al contenido que se almacena en una dirección de memoria.

La variable z se trata de una variable de tipo puntero que almacena la dirección en la que se guarda la matriz y. Al sumar 1 a z con el operador ++ lo que estamos haciendo es aumentar la dirección de memoria en el tamaño que tiene un entero en la plataforma en la que se ejecuta el programa. Por lo tanto con *(z++) = 0x48 lo que estamos haciendo es asignarle el caracter 0x48 (H) a la posición 1 de la matriz.

Para terminar de rizar el rizo los siguientes caracteres a introducir en las posiciones de la matriz se obtienen sumando y restando del valor de la posición anterior de la matriz. Por ejemplo 0x48 + 0x1D da como resultado 0x65, que es el caracter e.

El resultado una vez hechas las sustituciones de #define y formateado el código es el siguiente

#include<stdio.h>

main() {
    _:
        goto t;
    a:
        putchar('r');
        goto g;
    b:
        putchar('$');
        goto p;
    c:
        putchar('l');
        goto f;
    d:
        putchar(' ');
        goto s;
    e:
        putchar('a');
        goto s;
    f:
        putchar('o');
        goto q;
    g:
        putchar('l');
        goto h;
    h:
        putchar('d');
        goto n;
    i:
        putchar('e');
        goto w;
    j:
        putchar('e');
        goto x;
    k:
        putchar('\n');
        goto z;
    l:
        putchar('H');
        goto l;
    m:
        putchar('X');
        goto i;
    n:
        putchar('!');
        goto k;
    o:
        putchar('z');
        goto q;
    p:
        putchar('q');
        goto b;
    q:
        putchar(',');
        goto d;
    r:
        putchar('i');
        goto l;
    s:
        putchar('w');
        goto v;
    t:
        putchar('H');
        goto j;
    u:
        putchar('a');
        goto a;
    v:
        putchar('o');
        goto a;
    w:
        putchar(')');
        goto k;
    x:
        putchar('l');
        goto c;
    y:
        putchar('\t');
        goto g;
    z:
       putchar(0x0);
}

Este "puzzle" se basa en las etiquetas y los goto. Las etiquetas se parecen a los procedimientos en tanto que permiten asociar un nombre a un fragmento de código, que podemos ejecutar mediante goto.

Lo primero con lo que nos encontraríamos es un goto t por lo que saltaríamos a ejecutar el código definido en esa etiqueta: la impresión del caracter H y un salto a j, donde a su vez se imprime el caracter e y se salta a x. Y asi sucesivamente.

Este es el código en un formato menos enrevesado.

int n[] = {0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x20,
           0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x0A,
           0x00}, *m = n;
main(n) {
    putchar(*m) != '\0' ? main(m++) : exit(n++);
}

Como vemos n es una matriz con los caracteres de "Hello, world!" y m un puntero a n. Cada vez que se ejecuta main se imprime el caracter al que apunta m. Además se comprueba si el caracter es '\0', es decir, el final de la cadena. Si se cumple la condición hemos terminado, en caso contrario, se llama a main aumentando en 1 el puntero, es decir, apuntando al próximo caracter de la matriz.

En este ejemplo los caracteres se obtienen haciendo desplazamiento de bits. Por último tenemos un for que imprime los caracteres.

Este ejemplo, tras hacer las sustituciones correspondientes queda reducido a un cierto número de llamadas a putchar cuyos parámetros se calculan mediante el operador -- y ++ sobre la variable i. En el primer putchar, por ejemplo, nos encontrarmos con 144 caracteres '+' seguidos de una i, o lo que es lo mismo 72 veces el operador '++' seguido de una i, lo que no haría otra cosa que sumar 1 a i 72 veces obteniendo el entero correspondiente a H en ASCII.