Escreva um programa que produza comportamentos diferentes em tantas plataformas diferentes quanto possível. Cada plataforma diferente concede um ponto (incluindo uma plataforma inicial, o que significa que você não pode pontuar menos de 1 *). Mecanismos destinados a determinar a plataforma de destino / execução (por exemplo, através de instruções de compilação de plataforma ou APIs como o Environment.OSVersion.Platform do .NET) não devem ser usados. A resposta com a pontuação mais alta vence (onde os votos positivos são os desempate).

Por exemplo, considere o seguinte programa na linguagem Blub: print (1+2). Se esse programa fosse impresso 3em todas as plataformas em que é compilado e executado, sua pontuação seria 1. No entanto, se, por qualquer motivo, fosse impresso 4nos PDP-11, sua pontuação seria 2. Etc. Mas o seguinte C fragmento, por exemplo, é uma entrada inválida: #ifdef WIN32 ... #endif.

Definições / detalhes:

• Plataforma distinta: a combinação de a) arquitetura de hardware b) sistema operacional e seu número de versão MAJOR (por exemplo, 1.0.0 e 1.1.0 são considerados o mesmo sistema operacional)

• Comportamento diferente: dois comportamentos são iguais se produzirem efeitos colaterais semelhantes (por exemplo, criar o mesmo arquivo com o mesmo conteúdo) ou se o efeito colateral for erros do mesmo tipo. Por exemplo, se um programa segfaults em duas plataformas distintas, mas a mensagem segfault for diferente nessas plataformas, isso ainda será considerado o mesmo comportamento; enquanto um programa que produz um erro de divisão zero em uma plataforma e um erro de estouro de pilha (veja o que eu fiz lá?;) em outra está produzindo um comportamento diferente.

• Todos os comportamentos indefinidos são considerados equivalentes.

• O programa deve ser chamado de maneira equivalente em todas as plataformas (no entanto; isso significa que você pode passar parâmetros da linha de comando, se desejar)

* Bem, eu acho que você marcará zero se o seu programa for executado em plataformas zero. Mas um ... Sim deixa pra lá.

C

Vou dar uma facada nele com um exemplo de manual:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char a[] = {1,2,3,4,5,6,7,8};
    if (sizeof(&a) > sizeof(int)) {
        printf("foo %d %d\n", *(int *)a, *(long *)a);
    } else {
        printf("bar %d %d\n", *(int *)a, *(long *)a);
    }
}

Impressões da plataforma de 64 bits: foo

Impressões da plataforma de 32 bits: bar

Plataformas Little Endian: 67305985

Plataformas Big Endian: 16909060

Portanto, há pelo menos 4 combinações.

Além disso, algumas plataformas muito antigas foram intdefinidas como 16 bits. E alguma plataforma foi longdefinida como 64 bits. Portanto, o resultado também será diferente.

C tem uma plataforma específica, se você se aprofundar o suficiente. Não é difícil criar milhares de combinações (2 ^ 10 +).

Conjunto x86 / x64 de 16/32/64 bits, 16 bytes, 4 combinações

Código de bytes:

31 C9 41 E2 0A 66 49 41 74 05 0F 00 C0 03 C1 C3

Desmontagem (16 bits):

    xor  cx, cx ;cx=0
    inc  cx     ;cx=1
    loop l1     ;fall through
    dec  cx     ;cx=FFFF
    inc  ecx    ;cx=0000
    je   l1     ;branch taken
    ;...
l1: ret

Desmontagem (32 bits):

    xor  ecx, ecx ;ecx=0
    inc  ecx      ;ecx=1
    loop l1       ;fall through
    dec  cx       ;ecx=0000FFFF
    inc  ecx      ;ecx=00010000
    je   l1       ;branch not taken
    sldt ax       ;detect VMware, VirtualPC, Parallels, etc.
    add  ecx, eax ;conditionally modify ecx
l1: ret

Desmontagem (64 bits):

    xor   ecx, ecx ;rcx=0 (implicit 64-bit zero-extension)
    loopq l1       ;rcx becomes FFFFFFFFFFFFFFFF, branch taken
    ...
l1: ret

Retorna:
- CX = 0000 no modo de 16 bits;
- ECX = 10000 no modo não virtual de 32 bits;
- ECX = (aleatório) no modo virtual de 32 bits;
- RCX = FFFFFFFFFFFFFFFF no modo de 64 bits.