Opérations bit à bit équivalentes à supérieures à l'opérateur

Un unsigned variante étant donné qu'on peut utiliser la logique (&&, ||) et de comparaison (!=, ==).

int u_isgt(unsigned int a, unsigned int b)
{
return a != b && (    /* If a == b then a !> b and a !< b.             */
b == 0 ||  /* Else if b == 0 a has to be > b (as a != 0).   */
(a / b)    /* Else divide; integer division always truncate */
);             /*              towards zero. Giving 0 if a < b. */
}

!= et == peuvent facilement être éliminés., c'est à dire:

int u_isgt(unsigned int a, unsigned int b)
{
return a ^ b && (
!(b ^ 0) ||
(a / b)
);
}

Pour connecté on pourrait alors étendre à quelque chose comme:

int isgt(int a, int b)
{
return
(a != b) &&
(
(!(0x80000000 & a) && 0x80000000 & b) ||  /* if a >= 0 && b < 0  */
(!(0x80000000 & a) && b == 0) ||
/* Two more lines, can add them if you like, but as it is homework
* I'll leave it up to you to decide. 
* Hint: check on "both negative" and "both not negative". */
)
;
}

Peut être plus compact /éliminer ops. (au moins un), mais de le mettre comme ça pour plus de clarté.

Au lieu de 0x80000000 l'on puisse dire c'est à dire:

#include <limits.h>
static const int INT_NEG = (1 << ((sizeof(int) * CHAR_BIT) - 1));

À l'aide de ce test:

void test_isgt(int a, int b)
{
fprintf(stdout,
"%11d > %11d = %d : %d %s\n",
a, b,
isgt(a, b), (a > b),
isgt(a, b) != (a>b) ? "BAD!" : "OK!");
}

Résultat:

         33 >           0 = 1 : 1 OK!
-33 >           0 = 0 : 0 OK!
0 >          33 = 0 : 0 OK!
0 >         -33 = 1 : 1 OK!
0 >           0 = 0 : 0 OK!
33 >          33 = 0 : 0 OK!
-33 >         -33 = 0 : 0 OK!
-5 >         -33 = 1 : 1 OK!
-33 >          -5 = 0 : 0 OK!
-2147483647 >  2147483647 = 0 : 0 OK!
2147483647 > -2147483647 = 1 : 1 OK!
2147483647 >  2147483647 = 0 : 0 OK!
2147483647 >           0 = 1 : 1 OK!
0 >  2147483647 = 0 : 0 OK!

Entièrement sans branches version de Kaganar petits isGt fonction pourrait ressembler à de la sorte:

int isGt(int a, int b)
{
int diff = a ^ b;
diff |= diff >> 1;
diff |= diff >> 2;
diff |= diff >> 4;
diff |= diff >> 8;
diff |= diff >> 16;
//1+ on GT, 0 otherwise.
diff &= ~(diff >> 1) | 0x80000000;
diff &= (a ^ 0x80000000) & (b ^ 0x7fffffff);
//flatten back to range of 0 or 1.
diff |= diff >> 1;
diff |= diff >> 2;
diff |= diff >> 4;
diff |= diff >> 8;
diff |= diff >> 16;
diff &= 1;
return diff;
}

Ce horloges à environ 60 instructions pour le calcul (MSVC 2010 compilateur, sur les architectures x86), plus un supplément de 10 pile ops ou alors pour la fonction du prologue/épilogue.

Autant que je ne veux pas faire de quelqu'un d'autre les devoirs, je ne pouvais pas résister à celui-ci.. 🙂 je suis sûr que d'autres peuvent penser d'un plus compact..mais voici la mienne..fonctionne bien, y compris les nombres négatifs..

Edit: il y a quelques bugs. Je vais laisser à l'OP de le trouver et de le corriger.

    #include<unistd.h>
#include<stdio.h>
int a, b, i, ma, mb, a_neg, b_neg, stop;
int flipnum(int *num, int *is_neg) {
*num = ~(*num) + 1;
*is_neg = 1;
return 0;
}
int print_num1() {
return ((a_neg && printf("bigger number %d\n", mb)) ||
printf("bigger number %d\n", ma));
}
int print_num2() {
return ((b_neg && printf("bigger number %d\n", ma)) ||
printf("bigger number %d\n", mb));
}
int check_num1(int j) {
return ((a & j) && print_num1());
}
int check_num2(int j) {
return ((b & j) && print_num2());
}
int recursive_check (int j) {
((a & j) ^ (b & j)) && (check_num1(j) || check_num2(j))  && (stop = 1, j = 0);
return(!stop && (j = j >> 1) && recursive_check(j));
}
int main() {
int j;
scanf("%d%d", &a, &b);
ma = a; mb = b;
i = (sizeof (int) * 8) - 1;
j = 1 << i;
((a & j) && flipnum(&a, &a_neg));
((b & j) && flipnum(&b, &b_neg));
j = 1 << (i - 1);
recursive_check(j);
(!stop && printf("numbers are same..\n"));
}

EDIT: Les contraintes de faire de la simple approche à bas invalide. Je suis ajoutant le binaire fonction de recherche et la comparaison finale de détecter le plus de valeur:

unsigned long greater(unsigned long a, unsigned long b) {
unsigned long x = a;
unsigned long y = b;
unsigned long t = a ^ b;
if (t & 0xFFFF0000) {
x >>= 16;
y >>= 16;
t >>= 16;
}
if (t & 0xFF00) {
x >>= 8;
y >>= 8;
t >>= 8;
}
if (t & 0xf0) {
x >>= 4;
y >>= 4;
t >>= 4;
}
if ( t & 0xc) {
x >>= 2;
y >>= 2;
t >>= 2;
}
if ( t & 0x2) {
x >>= 1;
y >>= 1;
t >>= 1;
}
return (x & 1) ? a : b;
}

L'idée est de commencer par le plus important de la moitié de la parole qui nous intéresse et de voir s'il y a des bits. Si il ya, alors nous n'avons pas besoin le moins significatif de la moitié, donc on décale les indésirables bits loin. Si non, nous ne faisons rien (la moitié est nul de toute façon, donc il ne sera pas dans le chemin). Puisque nous ne pouvons pas garder une trace de l'décalé montant (elle aurait besoin de plus), nous avons également modifier les valeurs d'origine, de sorte que nous pouvons faire la finale and afin de déterminer le plus grand nombre. Nous répétez ce processus avec la moitié de la taille du masque précédent jusqu'à ce que nous effondrement bits intéressants dans la position du bit 0.

Je n'ai pas ajouter de l'égalité des cas ici sur le but.

---

Vieille réponse:

La méthode la plus simple est probablement le meilleur pour faire leurs devoirs. Une fois que vous avez le décalage des bits de valeur, vous commencez avec un autre masque à 0x80000000 (ou quel que soit approprié max bit de position de la taille de mot), et de garder le droit de l'évolution de cette jusqu'à ce que vous frappez un peu qui est définie dans votre incompatibilité de valeur. Si votre maj de droite se termine par 0, puis l'inadéquation entre la valeur est 0.

Je suppose que vous connaissez déjà la dernière étape nécessaire pour déterminer le plus grand nombre.