Comparing two integers and insert a comparison sign <,>= between the two numbers - c

Question

I would like to compare two positive integers and add a comparison sign between them. I may not use any logical, relational or bitwise operators and no if then else or while loop or ternary operator.
I found the max and min of these two numbers.
How can I preserve the order and still insert the comparison sign? Any ideas?
E.g.:
4 6 was entered by user output must be 4 < 6
10 2 was entered by user output must be 10 > 2
2 2 was entered by user output must be 2 = 2
f1 = x / y;
f2 = y / x;
f1 = (f1 + 2) % (f1 + 1);
f2 = (f2 + 2) % (f2 + 1);
max = f1 * x + f2 * y ;
max = max / (f1 + f2);

Answer 1

You can use an array of char:
#include <stdio.h>
int main(void)
{
unsigned a, b;
scanf("%u %u", &a, &b);
size_t cmp = (_Bool)(a / b) - (_Bool)(b / a);
char relation = "<=>"[cmp + 1];
printf("%u %c %u\n", a, relation, b);
return 0;
}
This approach don't require min and max found out.
Explanation:
(_Bool)exp will be 1 if exp is non-zero, and 0 if exp equals to 0.
Since a and b are positive integers, a / b will be 0 when a < b, and 1 when a >= b. See the truth table below for details.
(_Bool)(a / b) (_Bool)(b / a) (_Bool)(a / b) - (_Bool)(b / a)
a > b 1 0 1
a = b 1 1 0
a < b 0 1 -1
As a result, cmp evaluates to -1, 0, 1, like a typical comparison function. And thus, cmp + 1 will conveniently lead to 0, 1, 2 valid array indexes.
Thanks #janos for his help.
Edit:
As #chux carefully points out,
OP stated "I may not use any logical, ... operators". The C spec has
"... the logical negation operator !...". §6.5.3.3 5. Using ! may not
meet OP's goals.
So I changed !!exp to (_Bool)exp to meet OP's demand.
Edit II:
OP commented:
Thanks. This does not work when one of the inputs is 0.
But isn't the input numbers granted to be positive? Well, to handle zeros you can use size_t cmp = (_Bool)((a + (_Bool)(a - UINT_MAX)) / (b + (_Bool)(b - UINT_MAX))) - (_Bool)((b + (_Bool)(b - UINT_MAX)) / (a + (_Bool)(a - UINT_MAX)));. Don't forget to #include <limits.h>.
EDIT III (The last edit, I hope):
#include <stdio.h>
#include <limits.h>
#define ISEQUAL(x, y) (_Bool)((_Bool)((x) - (y)) - 1) // 1 if x == y, 0 if x != y
#define NOTEQUAL(x, y) (_Bool)((x) - (y)) // 0 if x == y, 1 if x != y
int main(void)
{
unsigned a, b;
printf("%u\n", UINT_MAX);
scanf("%u %u", &a, &b);
_Bool hasZero = NOTEQUAL(ISEQUAL(a, 0) + ISEQUAL(b, 0), 0);
_Bool hasMax = NOTEQUAL(ISEQUAL(a, UINT_MAX) + ISEQUAL(b, UINT_MAX), 0);
int hasBoth = ISEQUAL(hasZero + hasMax, 2);
int cmp = (_Bool)((a + hasZero + hasBoth) / (b + hasZero + hasBoth))\
- (_Bool)((b + hasZero + hasBoth) / (a + hasZero + hasBoth));
// "+ hasZero + hasBoth" to avoid div 0: UINT_MAX -> 1, while 0 -> 2.
hasBoth = 1 - hasBoth * 2; // 1 if hasBoth == 0, or -1 if hasBoth == 1
char relation = "<=>"[hasBoth * cmp + 1]; // reverse if has both 0 and UINT_MAX
printf("%u %c %u\n", a, relation, b);
return 0;
}
Fixed a bug when a == UINT_MAX - 1 and b == UINT_MAX at #chux points out.
Used macro to improve readability.
Added some comments.

Answer 2

As OP has x, y and has computed their minimum min and maximum max
void prt(unsigned x, unsigned y, unsigned min, unsigned max) {
// min not used
unsigned cmp = 1 + x/max - y/max;
printf("%u %c %u\n", x, "<=>"[cmp], y);
}

Answer 3

#include <stdio.h>
static unsigned int cmpgt(const unsigned int a, const unsigned int b)
{
return b?(a/b ? (a-b):0):a;
// if B is 0, then return A. non zero A will be treated as true
// if a is zero then is false
// if b is not zero then do a/b, if non zero then return (a-b)
// non zero (a-b) will be treated as true
// if (a-b) is zero then will be treated as false
//
// This is a very ugly way of implementing operator >
// There are other ways to do it
// But the point is, you need operator >, but you can not use it
// ( for whatever reason), then you just make it, which is doable
}
static const char *mark(const unsigned int a, const unsigned int b)
{
return cmpgt(a, b)?">":(cmpgt(b,a)?"<":"=");
// no if-else, but ternary operator is a good alternative
// so those are two nested operator ?:
// basically :
// if a>b then return ">"
// else if a<b return "<"
// else return "="
// with cmpgt/operator > implemented, this is a lot easier
}
int main(void) {
const int input[] = {1,3,4,5,5,2,3,4}; //test input
size_t input_size = sizeof(input)/sizeof(int);
for (size_t i=0;cmpgt(input_size-1, i);i++){
// while loop is banned, but for loop is still usable
// the loop condition is handled by cmpgt
printf("%d %s ",input[i],mark(input[i], input[i+1]));
}
printf("%d\n", input[input_size-1]);
return 0;
}
sample output:
1 < 3 < 4 < 5 = 5 > 2 < 3 < 4
https://ideone.com/dFHWnn

Answer 4

A simple compare is to use <=, >= and then lookup the compare character from a string.
void cmp1(unsigned x, unsigned y) {
int cmp = (x >= y) - (x <= y);
printf("%u %c %u\n", x, "<=>"[cmp + 1], y);
}
Yet since we cannot use various operators, etc., All we need to do is replace >=.
_Bool foo_ge(unsigned x, unsigned y) {
_Bool yeq0 = 1 - (_Bool)y; // y == 0?
_Bool q = (x + yeq0)/(y + yeq0); // Offset both x,y, by yeq0
return q + yeq0;
}
void cmp2(unsigned x, unsigned y) {
int cmp = foo_ge(x,y) - foo_ge(y,x)
printf("%u %c %u\n", x, "<=>"[cmp + 1], y);
}
Heavy use of _Bool credit to #sun qingyao