dividing a number without using division operator in c [duplicate]

Answer 1

This is a very simple approach to the problem; using loops and basic [+-]operators.

If you need an answer in decimals, you could use a times_ten and divide_by_ten function. In that case, you should take a look at the atoi() function; times_ten would extract the integer in a char-array, adding a '0' in the end before converting it back to integer. divide_by_ten would store the last character of an integer, substract this character with a '.' and adding the stored last digit back to the array before converting it back to integer. Atoi() will round the integer based on the decimal which we manipulated in the char-array.

Heres a version only supporting integer results, with an extra function (leftover_division()) replacing the '%'-operator. [b]Passing pointers to integers instead of regular integers to the divide_rounded() function and adjusting the value of 'a' in divide_rounded() should make the leftover function redundant, saving a lot of calculation time if you'd need to know the lefover.[/b]

#include <stdio.h>
#include <stdlib.h>



int divide_rounded(int a, int b){
   int outcome_rounded = 0;
   while(a > b){
      a = a - b;
      outcome_rounded ++;
   }
   return outcome_rounded;
}

int leftover_division(int a, int b){
   while (a >= b){
      a = a - b;
   }
   return a;//this will return remainder

}

main(){
   int number = 20;
   int divisor = 3;
   int outcome;
   int leftover;

   outcome = divide_rounded(number, divisor);
   leftover = leftover_division(number, divisor);

   printf("[%d] divided by [%d] = [%d] + [%d]\n", number, divisor, outcome, leftover);

}

Answer 2

For integer division, you can use div, ldiv or lldiv functions from the standard library:

#include <stdlib.h>
div_t div(int numer, int denom);
ldiv_t ldiv(long int numer, long int denom);
lldiv_t lldiv(long long int numer, long long int denom);

Answer 3

your question is very vague, but I can give you a particular case of dividing a number with 2. it can be performed by a bit shift operation that shifts the number one place to the right. This is a form of strength reduction optimization.

For example, 1101000 in binary (the decimal number 104), shifted one place to the right, is 0110100 (the decimal number 52): the lowest order bit, a 1, is removed. Similarly, division by any power of two (2 pow k) may be performed by right-shifting k positions. Because bit shifts are often much faster operations than division.

code to test that :

#include <stdio.h>

main()
{
   int i = 104; 
   int k = 3; //
   int j = i >> k ; //==>  i / 2 pow k 
  printf("j = %d \n",j);
}

Answer 4

You can use this function

int divide(int nu, int de) {

    int temp = 1;
    int quotient = 0;

    while (de <= nu) {
        de <<= 1;
        temp <<= 1;
    }

    //printf("%d %d\n",de,temp,nu);
    while (temp > 1) {
        de >>= 1;
        temp >>= 1;

        if (nu >= de) {
            nu -= de;
            //printf("%d %d\n",quotient,temp);
            quotient += temp;
        }
    }

    return quotient;
}

You can pass a numerator and a denominator to this function and get the required quotient.

Answer 5

Psuedo code in python for divide by constant

n_bits = Number of bits of input over which division is expected to be accurate

den = divisor

prec = int(math.ceil(math.log(den,2)))
shift = n_bits + prec
mult = int(math.ceil((1<<shift)/float(den)))
answer = (x*mult) >> shift
err = sum([round(x/den) - ((x*mult) >> shift) for x in range(1<<n_bits)])

Multiplication can be implemented with shifts and adds

Answer 6

Simplest way:

int divideIntegers(int num, int den){
    int sign = (num*den < 0)? -1 : 1;
    num = abs(num);
    den = abs(den);
    int quo = 0;
    while( (num -= den) >= 0 )
        quo++;
    return sign*quo;
}