C++: How do I round arithmetically after a division with BASIC operations?

Question

I just started learning how to program in C++ and I'm already desperate because of one task. I'm only allowed to use the following operations: + - * / % and brackets and int variables and declaration, e.g. a = b;

The task is to divide int numbers a and b. The output should be the mathematically / arithmetically correct rounding to the next int. How do I do that? I can't use if/else, define new functions etc. I really don't know and I've tried a couple of things but they don't work for every case (a and b can be all positive integers).

Thanks a lot for your help!!!!

EDIT: As we didn't learn what bool etc. is, I can't use it. It should output, for example 5/2 = 3 (rounded up) 7/3 = 2 (rounded down)

Please show your code. What did you try? Why did it not work? — 463035818_is_not_an_ai, Sep 23 '20 at 20:03
Not sure what exactly you are allowed to do, but my idea is to convert the remainder to `bool` — Ranoiaetep, Sep 23 '20 at 20:06
We don't have bool yet, so I cant use it ;( c = (a+(b-1))/b; std::cout << c; — kp00, Sep 23 '20 at 20:08
Why is `5 / 2` rounded up while `7 / 2` rounded down? That doesn't make any sense — NathanOliver, Sep 23 '20 at 20:12
Rounding halfway to odd is very uncommon, do you actually mean `5/2 == 2` and `7/2 == 4` ("Bankers' rounding")? Also, do you care about possible overflow of large integers? — chtz, Sep 23 '20 at 20:14
Sorry, 7/3 = 2.33 , should round down to 2. I'm already so tired that I can't calculate any more... — kp00, Sep 23 '20 at 20:15
So they are not "rounding to the next int", but round to the closest? — Ranoiaetep, Sep 23 '20 at 20:17
Please clarify which operations should round up and which should round down. — n. m. could be an AI, Sep 23 '20 at 20:38

463035818_is_not_an_ai · Answer 1 · 2020-09-23T22:30:03.373

2

I assume that you want to round to nearest, and that .5 goes to the next bigger integer. And we restrict to a > 0 and b > 0.

Consider that you already get the correct answer for half of the cases from simple integer arithmetics (because it is always rounding down). To get also the other half correct, you can shift the numerator by half the denominator:

#include <iostream>

int divide(int a, int b){
    return (a+b/2) / b;
}

void test(int a, int b){
    std::cout << a << " / " << b  << " = " << (double)a/b << " == " << divide(a,b) << "\n";
}

int main(){
    for (int i=0;i<20;++i){
        test(i,3);
    }

}

Output:

0 / 3 = 0 == 0
1 / 3 = 0.333333 == 0
2 / 3 = 0.666667 == 1
3 / 3 = 1 == 1
4 / 3 = 1.33333 == 1
5 / 3 = 1.66667 == 2
6 / 3 = 2 == 2
7 / 3 = 2.33333 == 2
8 / 3 = 2.66667 == 3
9 / 3 = 3 == 3
10 / 3 = 3.33333 == 3
11 / 3 = 3.66667 == 4
12 / 3 = 4 == 4
13 / 3 = 4.33333 == 4
14 / 3 = 4.66667 == 5
15 / 3 = 5 == 5
16 / 3 = 5.33333 == 5
17 / 3 = 5.66667 == 6
18 / 3 = 6 == 6
19 / 3 = 6.33333 == 6

I will try to visualize what happens here, actually it is rather simple:

For denomiator 3:

a          0   1   2   3   4   5   6  
a/3        000000000   111111111   222222    <- integer arithmetics
round(a/3) 00000   111111111   2222222222    <- desired result
a/3==n.5         ^           ^

For denominator b

a          0   1   2  ... b/2   ...   b-1   b   b+1    
a/b        000000000000000000000000000000   111111111111   
round(a/3) 000000000000   111111111111111111111111111111
a/b==n.5                  ^

With denominator b=3 we need to add an offset of 1 to a to get correct results. In general we need to add an offset of b/2. I hope the tables speak more than words.

Note that a+b/2 is suspectible to overflows. There are other mathematically equivalent epxressions that do not overflow that easily. As the final result for sure fits in an int we can use unsigned for the intermediate addition:

int div = (static_cast<unsigned>(a) + static_cast<unsigned>(b/2)) / b;

For typical implementations where unsigned can store the sum of any two positive ints this avoids the overflow.

edited Sep 23 '20 at 22:30

answered Sep 23 '20 at 20:16

463035818_is_not_an_ai

109,796
11
89
185

1

@kp00 please look at the code more carefully. The solution is `(a+b/2) / b;` thats all. The rest of the code is only to produce the output – 463035818_is_not_an_ai Sep 23 '20 at 20:21
@kp00 if there is something in the code that you do not understand please ask so I can clarify – 463035818_is_not_an_ai Sep 23 '20 at 20:21
Thank you a lot. It worked! You saved my day! Could you please explain why it worked? – kp00 Sep 23 '20 at 20:24
2

`a+b/2` could overflow. If all inputs are positive `(a-b/2)/b+1` should be fine. – chtz Sep 23 '20 at 20:26
@kp00 I can try to explain but it will take a while – 463035818_is_not_an_ai Sep 23 '20 at 20:29
`(a+b/2) / b` can overflow and may also be incorrect with negative operands. @chtz `(a-b/2)/b+1` has similar problems. – chux - Reinstate Monica Sep 23 '20 at 20:30
I would love if you could explain... btw I study maths... – kp00 Sep 23 '20 at 20:30
1

@chux-ReinstateMonica a and b are positive – 463035818_is_not_an_ai Sep 23 '20 at 20:32
@chux-ReinstateMonica but yes, I should have mentioned it in the answer also – 463035818_is_not_an_ai Sep 23 '20 at 20:33
@chtz Fair enough. – chux - Reinstate Monica Sep 23 '20 at 20:33
1

@chtz Try `a=1, b= 100` with `(a-b/2)/b+1`. I get 1, is not 0 expected? `a/b + (a%b + b/2)/b` might handle all `0 < a,b <= INT_MAX` without overflow but is ponderous. – chux - Reinstate Monica Sep 23 '20 at 20:37
@chux, you are right (regarding the `a – chtz Sep 23 '20 at 20:44
@chtz Yes, a better approach is to take my own advice and form a [test harness](https://stackoverflow.com/a/64029982/2410359). – chux - Reinstate Monica Sep 23 '20 at 20:47
@chtz is it possible to avoid the overflow by doing the intermediate addition with `unsigned`s? The final result for sure fits in an `int` – 463035818_is_not_an_ai Sep 23 '20 at 21:07
1

@idclev463035818 `unsigned` range overwhelmingly is about twice the positive range of `int` and well handles overflow concerns here and is a reasonable idea. e.g. (change `2` to `2u`). By C spec, `UINT_MAX == INT_MAX` (same positive range), is possible, yet is rare if ever seen these days. – chux - Reinstate Monica Sep 23 '20 at 21:37

C++: How do I round arithmetically after a division with BASIC operations?

1 Answers1