dividiendo un número sin usar el operador de división en c

¿Cómo puedo dividir un número con un número desconocido sin usar estos operadores ('*', '/', '%') . Denominador se da durante el tiempo de ejecución.

Puedes usar esta función

 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; } 

Puede pasar un numerador y un denominador a esta función y obtener el cociente requerido.

 void main(){ int a,b,i=0; clrscr(); printf("Enter the dividend and divisor"); scanf("%d%d",&a,&b); while(a>=b){ a=ab; i++; } printf("qoutient is :%d \n remainder : %d",i,a); getch(); } 

Manera más simple:

 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; } 

Para la división entera, puede usar las funciones div , ldiv o lldiv de la biblioteca estándar:

 #include  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); 

El siguiente método es la implementación de la división binaria considerando que ambos números son positivos. Si la resta es una preocupación, podemos implementar eso también utilizando operadores binarios.

======

 -(int)binaryDivide:(int)numerator with:(int)denominator { if (numerator ==0 || denominator ==1) { return numerator; } if (denominator ==0) { #ifdef DEBUG NSAssert(denominator==0, @"denominator should be greater then 0"); #endif return INFINITY; } // if (numerator <0) { // numerator = abs(numerator); // } int maxBitDenom = [self getMaxBit:denominator]; int maxBitNumerator = [self getMaxBit:numerator]; int msbNumber = [self getMSB:maxBitDenom ofNumber:numerator]; int qoutient = 0; int subResult = 0; int remainingBits = maxBitNumerator-maxBitDenom; if(msbNumber>=denominator){ qoutient |=1; subResult = msbNumber- denominator; } else{ subResult = msbNumber; } while(remainingBits>0){ int msbBit = (numerator & (1<<(remainingBits-1)))>0?1:0; subResult = (subResult <<1) |msbBit; if(subResult >= denominator){ subResult = subResult-denominator; qoutient= (qoutient<<1)|1; } else{ qoutient = qoutient<<1; } remainingBits--; } return qoutient; } -(int)getMaxBit:(int)inputNumber { int maxBit =0; BOOL isMaxBitSet = NO; for(int i=0;i>(numbeMaxBit -bits); } 

su pregunta es muy vaga, pero le puedo dar un caso particular de dividir un número con 2. se puede realizar mediante una operación de desplazamiento de bits que desplaza el número uno a la derecha. Esta es una forma de optimización de reducción de fuerza.

Por ejemplo, 1101000 en binario (el número decimal 104), desplazado un lugar a la derecha, es 0110100 (el número decimal 52): el bit de orden más bajo, un 1, se elimina. De manera similar, la división por cualquier potencia de dos (2 pow k) puede realizarse mediante k posiciones de desplazamiento a la derecha. Porque los cambios de bits son a menudo operaciones mucho más rápidas que la división.

código para probar que:

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

Este es un enfoque muy simple para el problema; utilizando bucles y operadores básicos [+ -].

Si necesita una respuesta en decimales, puede usar una función times_ten y divide_by_ten. En ese caso, deberías echar un vistazo a la función atoi () ; times_ten extraería el entero en una matriz de caracteres, agregando un ‘0’ al final antes de volverlo a convertir en entero. divide_by_ten almacenaría el último carácter de un entero, restará este carácter con un ‘.’ y agregar el último dígito almacenado nuevamente a la matriz antes de convertirlo de nuevo a entero. Atoi () redondeará el número entero basándose en el decimal que manipulamos en la matriz de caracteres.

Aquí hay una versión que solo admite resultados enteros, con una función adicional (leftover_division ()) que reemplaza al operador ‘%’. [b] Pasar los punteros a los enteros en lugar de los enteros regulares a la función divide_cerrado () y ajustar el valor de ‘a’ en divide_cerrado () debería hacer que la función sobrante sea redundante, ahorrando una gran cantidad de tiempo de cálculo si necesita saber el lefover. [/ b]

 #include  #include  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); 

}

Código psuedo en python para dividir por constante

n_bits = Número de bits de entrada sobre los que se espera que la división sea precisa

den = divisor

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

La multiplicación se puede implementar con turnos y adiciones.