Produire le programme le plus court qui prend en entrée deux entiers signés (via stdin ou comme arguments) et affiche 3 sorties différentes selon que le premier nombre est (1) supérieur à, (2) inférieur à ou (3) égal au second nombre.

The Catch

Vous ne pouvez utiliser aucun des éléments suivants dans votre programme:

• Les opérateurs de comparaison standard: <, >, <=, >=, ==, !=.
• Tout fichier de bibliothèque à part conio, stdioou iostream.
• Tout caractère ASCII non ASCII ou non imprimable.

Le gagnant

Le programme avec le plus petit nombre de caractères gagne.

53 octets

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

Seul le premier caractère de la sortie est pertinent. Les trois sorties différentes sont:

1. '-' si b> a
2. '0' si a == b
3. tout autre caractère si a> b

Il fonctionne pour la plage d'entrée complète de int sur toutes les plates-formes où sizeof (long)> sizeof (int).

Edit: il faut un caractère supplémentaire pour que le cas 3 imprime un '+' uniquement à la place:

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

Peut-être que je manque quelque chose dans les règles, mais ...

81 octets

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

Ouputs 00si a > b, -10si a == bet -1-1si a < b.

90 octets

Si nous pouvons utiliser stdio, pourquoi ne pas utiliser ses capacités de formatage pour effectuer une comparaison?

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

Suppose un encodage compatible ASCII et peu d'endianisme.

72 octets

Les quotients sont arrondis vers zéro mais les décalages vers la droite sont (en pratique) "arrondis vers le bas". C'est un cadeau mort.

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

65 79 octets

Une autre propriété distinctive des nombres négatifs est qu'ils produisent un modulo négatif. Celui-ci ne dépend pas du tout de la représentation entière; ça marche même sur mon grille-pain 8 bits en excès-127! Oh, et puisque nous pouvons utiliser conio, pourquoi ne pas enregistrer deux octets avec putch? Maintenant, si je pouvais seulement trouver ma copie de 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 : gérer de grandes différences en supposant qu'il long longest plus large que int.

64 61 caractères

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

Imprime les valeurs de caractères -1, 0 et 1 pour respectivement inférieur, égal ou supérieur à.

Cette implémentation repose sur un comportement non défini pour bêtre de type intet pour des entrées en dehors de la plage INT_MIN / 2de INT_MAX / 2. Sur les plates-formes où le débordement signé s'enroule, qu'il s'agisse d'un complément 2s (essentiellement tous) ou d'une amplitude de signe, il échouera pour 25% des paires possibles de paires valides int. Fait intéressant (pour moi en tout cas), cela fonctionnera correctement sur les plateformes où le débordement signé sature.

66 102 octets

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);}

Lit les entiers de STDIN et imprime 0(a <b), 1(a> b) ou 2(a == b).

Edit: Maintenant, il devrait également fonctionner pour les différences qui sont trop grandes pour tenir dans un entier 32 bits. Je suis sûr que le ternaire imbriqué peut être raccourci avec un peu plus de magie magique.

52 octets

Malheureusement, celui-ci ne fonctionne que pour des nombres entiers positifs, mais je pensais que le concept d'utiliser des opérateurs purement arithmétiques était intéressant:

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

Les sorties:

• Code ASCII 0xFF: a inférieur à b
• Code ASCII 0x00: a égal à b
• Code ASCII 0x01: a supérieur à b

 59    54 caractères

54 caractères avec un compilateur comme gcc qui ne rechigne pas à main(x,y):

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

59 caractères sinon:

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

Production:

• Code ASCII 0x00 si x <y
• Code ASCII 0xFF si x> y
• Code ASCII 0x01 si x == y

66 octets

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

Imprime l'octet 0x00 if a == b, 0x01 if a < bet 0xff if a > b.

Étant donné que le caractère ASCII non ASCII ou non imprimable dans [mon] programme et si quelque chose n'est pas explicitement interdit dans la question, alors il est autorisé , le caractère non imprimable dans la sortie devrait être tout à fait correct .

87 caractères

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

Utilisation de l'astuce 2 ^ 31 pour convertir en int non signés

Casting de la division sur unsigned pour gérer le bit supérieur en tant que données, pas signer

En utilisant ^ à XOR a et b, quand ils sont égaux, cela renvoie 0

Utilisation de conditions imbriquées (?) Pour obtenir "<", ">" ou "=" pour alimenter les options put ()

71 octets

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

http://ideone.com/uvXm6c

68 caractères

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

Place le caractère ASCII 1, 2 ou 3 pour respectivement inférieur, supérieur ou égal.

88 89 octets

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);}

Cela commence par ajouter 1<<31( INT_MIN) à a et b, de sorte que 0 correspond maintenant INT_MIN. Ensuite, boucle et décrémente a et b chaque boucle jusqu'à ce que soit 0, puis imprime 0, 1 ou 2 selon que a, b ou les deux sont 0.

120 119 octets

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);}

Ce n'est pas la solution la plus courte, mais elle pourrait être un peu golfée par un meilleur golfeur que moi. (Ou juste des gens avec plus de connaissance de C que moi)

L'idée est de masquer chaque bit, en commençant par celui de gauche et en vérifiant les inégalités. Le reste devrait s'expliquer. Étant donné que les nombres négatifs commencent par 1 bit, j'inverse d'abord le premier bit avec a^=1<<31.

Je pense que je ne vais même pas essayer d'écrire du code court. Ce que je vais tenter est d'effectuer cette comparaison d'une manière qui est portable selon la spécification C99.

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

L'opérateur modulo conserve le signe, mais il peut très bien produire un zéro (y compris un zéro négatif), nous nous assurons donc d'avoir une valeur à la fois impaire et paire à vérifier (même sans savoir si nous utilisons des compléments). Les opérations arithmétiques peuvent déborder, mais pas au niveau du bit, et en veillant à ce qu'il y ait des bits à la fois définis et effacés, nous évitons de convertir par inadvertance notre nombre en zéro négatif ou en valeur d'interruption. Le fait que deux opérations soient nécessaires pour le faire étrangement ne devrait pas avoir d'importance, car la représentation d'interruption possible ne provoque pas de comportement indéfini jusqu'à ce qu'elle soit mise dans une valeur l. Faire l'opération avec le bit 0 basculé garantit que nous obtenons exactement un reste non nul. Armé de la connaissance des deux signes, nous pouvons décider comment procéder à la comparaison.

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];
}

Cette méthode peut être l'une des rares à permettre d'extraire le signe d'un zéro négatif entier. Nous résolvons cela en vérifiant explicitement zéro. Si nous jouions au golf pour de vrai, nous pourrions bien sûr permettre la comparaison de deux zéros pour effectuer également la soustraction.

C 80 caractères

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);}

Il imprime '<', '>' ou '=', comme il se doit.

C 63 caractères

Une nouvelle approche:

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

Imprime «1», «2» ou «3».

En 64 caractères sans stdio.h

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

affiche '>' si a> b, '<' si a <b, '=' si a == b int débordement est UB. Ne débordez pas.

// 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) ? ">" : "=");
}