CareerCup

Good answer. Worth noting that we assume that x + y does not overflow in this solution.

Arghh, just realized that my answer is the same:
(y + (x-1)) / x == (y -1 + x) / x == (y-1)/x + x/x == 1 + (y-1)/ x

@Trickster: yours is incorrect for y = 0. However, aside from that case, I actually prefer your solution because it's safer against overflows.

yup. I mentioned that down below. It only works for y > 0 .

Not exactly. This fails on y=2 and x=1

@jerr: why? it gives an answer of 2.

Sry yeah your right. Dunno what I was thinking

@eugene.yarovoi

1. (y + (x-1)) / x
2. 1 + (y-1)/ x
why do you fell 1st solution is not safer against overflows??

int main()
{
unsigned char result = 0;
unsigned char y = 255;
unsigned char x = 2;

result = (y+x-1)/x;

printf("%d",result);

return 0;
}

the "result" value in the above code will be 128, even though y+x -1 overflows i.e 256.
i think both the solutions are safe against overflows depending on data type of "result".
correct me if am wrong

That's because x and y get promoted to int when doing the addition. The same idea would not save integers from overflowing.

To clarify, do we want the result of this expression to be the exact integer? Let's say y=11, x=3, then (y + (x-1)) / x = 13/3. Perhaps we are assuming integer primitives in which case result is truncated?

@stefanos: yes, I think truncating division is the most plausible interpretation of / in the context of this question.

#include<stdio.h>

int main()
{
	int x=111;
	int y=11;
	(x/(y*1.0))==x/y?printf("%d\n",x/y):printf("%d\n",1+(x/y));
	return 0;
}

y/x + (y-y/x*x)/((y-y/x*x)-1)
sorry forgot braces.

y - (y/x * x) are the remaining bytes i.e. 0 <= remaining bytes < x.
if the remaining bytes is 0, then y/x + 0 else y/x + 1

1 is acheived by (remaining bytes)/(remaining bytes - 1)

so answer is Y/X + ((Y - (Y/X*X))/(Y-(Y/X*X) - 1)

let me know if I am doing something wrong here.

Not sure if this is correct, but even if it is, this solution is just so needlessly complex in comparison to the top-voted answer

It's not even correct actually, because Y-(Y/X*X) can be 1, and then doing (Y-(Y/X*X))/( Y-(Y/X*X) - 1) could result in a division by 0.

Also, would not work when remaining bytes

Y-(Y/X*X)

is 2.

(Y-(Y/X*X))/( Y-(Y/X*X) - 1)  = 2/1

which is not we need.

if y = 12 and x = 10....your solution gives - 1 + 1 * 0 which doesnt seem correct...number of iterations should be 2 for this example.

y/x + 1 - y/x * x/y

That's just y/x + 1 - 1 so why no just say y/x?

And y/x is incorrect.

Also, y/x + 1 - y/x * x/y != y/x, since these are truncating divisions. In fact, unless y = x, one of x/y and y/x is 0, giving y/x +1 as the answer. But if x = y this expression gives y/x.

This is still incorrect, as the answer should be y/x + (x divides y) ? 0 : 1, not y/x + (x == y) ? 0 : 1, like this expression would have it.

(y/x)+1

Not quite. If y is divisible by x, the answer should be just y/x.