Produza o programa mais curto que recebe dois números inteiros assinados como entrada (por meio de stdin ou como argumentos) e exibe 3 saídas diferentes, dependendo de o primeiro número ser (1) maior que, (2) menor que ou (3) igual ao segundo número.

A pegada

Você não pode usar nenhum dos seguintes itens no seu programa:

• Os operadores de comparação padrão: <, >, <=, >=, ==, !=.
• Qualquer arquivo de biblioteca para além de conio, stdioou iostream.
• Qualquer caractere ASCII não ASCII ou imprimível.

O vencedor

O programa com o menor número de caracteres vence.

53 bytes

main(a,b){scanf("%d%d",&a,&b);printf("%ld",0l+a-b);}

Somente o primeiro caractere da saída é relevante. As três saídas diferentes são:

1. '-' se b> a
2. '0' se a == b
3. qualquer outro caractere se a> b

Ele funciona para todo o intervalo de entrada de int em todas as plataformas em que sizeof (long)> sizeof (int).

Edit: custa um caractere extra para fazer com que o caso 3 imprima um '+' exclusivamente:

main(a,b){scanf("%d%d",&a,&b);printf("%+ld",0l+a-b);}

Talvez eu esteja perdendo algo nas regras, mas ...

81 bytes

main(a,b){scanf("%d%d",&a,&b);long long l=a;l-=b;printf("%lld%d",--l>>63,l>>63);}

Ouputs 00se a > b, -10se a == be -1-1se a < b.

90 bytes

Se pudermos usar stdio, por que não usar seus recursos de formatação para realizar comparações?

main(a,b){scanf("%d%d",&a,&b);snprintf(&a,2,"%d",b-a);a&=63;putchar(51-!(a-45)-!!(a-48));}

Supõe codificação compatível com ASCII e pouca endianidade.

72 bytes

Os quocientes são arredondados para zero, mas os turnos à direita são (na prática) "arredondados para baixo". Essa é uma oferta morta.

main(a,b){scanf("%d%d",&a,&b);a-=b;putchar(a?a|=1,a/2-(a>>1)?60:62:61);}

65 79 bytes

Outra propriedade distintiva dos números negativos é que eles produzem módulo negativo. Este não depende de representação inteira; funciona até na minha torradeira excesso 127 de 8 bits! Ah, e como podemos usar conio, por que não salvar dois bytes com putch? Agora, se eu pudesse encontrar minha cópia do TurboC ...

main(a,b){scanf("%d%d",&a,&b);long long d=a;d-=b;putch(d?d|=1,d%2-1?60:62:61);}

EDIT : lidar com grandes diferenças, assumindo que long longé maior que int.

64 61 caracteres

main(a,b){scanf("%d%d",&a,&b);for(a-=b;a/2;a/=2);putchar(a);}

Imprime os valores dos caracteres -1, 0 e 1 para menos que, igual a ou maior que, respectivamente.

Essa implementação depende de um comportamento indefinido por bser do tipo inte por entradas fora do intervalo INT_MIN / 2para INT_MAX / 2. Nas plataformas em que o excesso de sinal assinado envolve, seja o complemento 2s (basicamente todos eles) ou a magnitude do sinal, ele falhará em 25% dos possíveis pares válidos int. Curiosamente (para mim de qualquer maneira), ele funcionará corretamente em plataformas onde o excesso de sinal assinado satura.

66 102 bytes

main(a,b,c,d,e){scanf("%d %d",&a,&b);e=1<<31;c=a&e;d=b&e;putchar(a-b?c&~d?48:d&~c?49:a-b&e?48:49:50);}

Lê os números inteiros de STDIN e imprime 0(a <b), 1(a> b) ou 2(a == b).

Editar: Agora também deve funcionar para diferenças grandes demais para caber em um número inteiro de 32 bits. Tenho certeza de que o ternário aninhado pode ser reduzido com um pouco mais de mágica.

52 bytes

Infelizmente, este só funciona para números inteiros positivos, mas achei interessante o conceito de usar operadores puramente aritméticos:

main(a,b){scanf("%d%d",&a,&b);putchar(b%a/b-a%b/a);}

Saídas:

• Código ASCII 0xFF: a menor que b
• Código ASCII 0x00: a igual a b
• Código ASCII 0x01: a maior que b

 59    54 caracteres

54 charcters com um compilador como o gcc que não se opõe a main(x,y):

main(x,y){scanf("%d%d",&x,&y);y-=x;putchar(y>>31|!y);}

59 caracteres caso contrário:

main(){int x,y;scanf("%d%d",&x,&y);y-=x;putchar(y>>31|!y);}

Resultado:

• Código ASCII 0x00 se x <y
• Código ASCII 0xFF se x> y
• Código ASCII 0x01 se x == y

66 bytes

main(a,b){scanf("%d%d",&a,&b);putchar((0l+b-a>>63)-(0l+a-b>>63));}

Imprime o byte 0x00 se a == b, 0x01 se a < be 0xff se a > b.

Como o caractere ASCII não ASCII ou imprimível no programa [my] e se alguma coisa não for explicitamente proibida na pergunta, é permitido que o caractere não imprimível na saída esteja completamente correto.

87 caracteres

main(a,b,c){scanf("%d%d",&a,&b);c=1<<31;a+=c;b+=c;puts(a^b?(unsigned)a/b?">":"<":"=");}

Usando o truque 2 ^ 31 para converter em int sem sinal

Converter a divisão em não assinado para manipular o bit superior como dados, não assinar

Usando ^ para XOR aeb, quando eles são iguais, isso retorna 0

Usando condicionais aninhados (?) Para obter "<", ">" ou "=" para alimentar feeds a puts ()

71 bytes

main(x,y,z){scanf("%d%d",&x,&y);putchar((z=x-y)?(z&(z>>31))?50:49:51);}

http://ideone.com/uvXm6c

68 caracteres

int main(a,b){scanf("%d%d",&a,&b);putchar(a-b?((unsigned)a-b)>>31:2);}

Coloca o caractere ASCII 1, 2 ou 3 por menos que, maior que ou igual, respectivamente.

88 89 bytes

main(a,b){scanf("%d%d",&a,&b);a+=1<<31;b+=1<<31;for(;a&&b;a--)b--;putchar(a?b?48:49:50);}

Isso começa adicionando 1<<31( INT_MIN) a aeb, para que 0 agora corresponda INT_MIN. Em seguida, faz um loop e decrementa a e b a cada loop até que seja 0 e, em seguida, imprime 0, 1 ou 2, dependendo de a, b ou ambos serem 0.

120 119 bytes

main(a,b,c){scanf("%d%d",&a,&b);c=1<<31;a^=c;b^=c;for(c~=c;!c;c/=2)if(a&c^b&c){putchar(a?48:49);return;}putchar(50);}

Não é a solução mais curta, mas pode ser um pouco melhor para o golfista do que eu. (Ou apenas pessoas com mais conhecimento de C do que eu)

A idéia é mascarar cada bit, começando pelo esquerdo e verificando a desigualdade. O resto deve se explicar. Como os números negativos começam com 1 bit, eu primeiro inverto o primeiro bit com a^=1<<31.

Acho que nem vou tentar escrever código curto. O que tentarei é realizar essa comparação de maneira portátil, de acordo com a especificação C99.

int a, b;   // Let's assume these are initialized
int sign_a = a ? ((a|7)^2)%2 + ((a|7)^3)%2 : 0;

O operador modulo preserva o sinal, mas pode muito bem produzir um zero (incluindo zero negativo), portanto, garantimos que temos um valor ímpar e par para verificar (mesmo sem saber se estamos usando o complemento). As operações aritméticas podem estourar, mas bit a bit não e, ao garantir que haja bits definidos e limpos, evitamos converter inadvertidamente nosso número em zero negativo ou em um valor de trap. O fato de que duas operações são necessárias para fazer isso de maneira estranha não deve importar, porque a possível representação de interceptação não causa comportamento indefinido até colocar um valor l. Fazer a operação com o bit 0 alternado garante que obtemos exatamente um restante diferente de zero. Armado com o conhecimento de ambos os sinais, podemos decidir como proceder com a comparação.

char result="\0<<>=<>>\0"[4+3*sign_a+sign_b]
if (!result) {   // signs matching means subtraction won't overflow
  int diff=a-b;
  int sign_diff=diff ? (diff|7^2)%2 + (diff|7^3)%2 : 0;
  result = ">=<"[1-sign_diff];
}

Este método pode ser um dos poucos que permitem extrair o sinal de um número inteiro negativo zero. Resolvemos isso verificando explicitamente zero. Se estivéssemos jogando golfe de verdade, é claro que poderíamos permitir que a comparação de dois zeros também realizasse a subtração.

C 80 chars

a,b,c=1<<31;main(){scanf("%d%d",&a,&b);putchar(a^b?(a&c^b&c?a:a-b)&c?60:62:61);}

Imprime '<', '>' ou '=', como deveria.

C 63 chars

Uma nova abordagem:

a;main(b){scanf("%d%d",&a,&b);putchar(50+(0L+a-b>>42)+!(a-b));}

Imprime '1', '2' ou '3'.

Em 64 caracteres sem stdio.h

a,b;main(){scanf("%d%d",&a,&b);puts((a-b)>>31?"<":a^b?">":"=");}

imprime '>' se a> b, '<' se a <b, '=' se a == b int overflow for UB. Só não transborde.

// declare a and b as ints
a,b;

// defaults to int
main()
{
  scanf("%d%d",&a,&b);
   /*
    * (a-b)>>31 signbit of a-b
    * a^b a xor b -> 0 if they are equal
    */
  puts(((a-b)>>31) ? "<" : (a^b) ? ">" : "=");
}