Division einer Zahl ohne Division Operator in c

Question

Wie kann ich eine Nummer mit einer unbekannten Nummer teilen, ohne diese Operatoren ('*', '/', '%') zu verwenden. Der Nenner wird während der Laufzeit angegeben.

Answer 1

können Sie verwenden diese Funktion

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

Sie einen Zähler und einen Nenner zu dieser Funktion übergeben können und den erforderlichen Quotienten erhalten.

Answer 2

Für Integer-Division, können Sie div, ldiv oder lldiv Funktionen aus der Standardbibliothek verwenden:

#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

Ihre Frage ist sehr vage, aber ich kann Ihnen einen besonderen Fall gibt von einer Zahl mit 2 Dividieren Es kann durch eine Bit-Shift-Operation durchgeführt werden, die die Nummer 1 nach rechts verschiebt. Dies ist eine Form der Festigkeitsreduktionsoptimierung.

Zum Beispiel, 1101000 binär (die Dezimalzahl 104), eine Stelle nach rechts verschoben, ist 0110100 (die Dezimalzahl 52): das niedrigste Bit, eine 1, wird entfernt. In ähnlicher Weise kann eine Division durch eine Potenz von zwei (2 pow k) durch Rechtsverschiebung von k Positionen durchgeführt werden. Weil Bitverschiebungen oft viel schnellere Operationen als Division sind.

Code, der testen:

#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

Dies ist eine sehr einfache Annäherung an das Problem; Verwenden von Schleifen und grundlegenden [+ -] Operatoren.

Wenn Sie eine Antwort in Dezimalzahlen benötigen, können Sie die Funktionen times_ten und divide_by_ten verwenden. In diesem Fall sollten Sie sich die atoi() Funktion ansehen; times_ten würde die Ganzzahl in einem char-array extrahieren, wobei am Ende eine '0' hinzugefügt wird, bevor sie in Ganzzahl zurückkonvertiert wird. divide_by_ten würde das letzte Zeichen einer Ganzzahl speichern, subtrahiere dieses Zeichen mit einem '.' und Hinzufügen der gespeicherten letzten Ziffer zurück zu dem Array, bevor sie zurück in Ganzzahl konvertiert wird. Atoi() rundet die ganze Zahl basierend auf der Dezimalzahl, die wir im char-Array manipuliert haben.

Hier ist eine Version, die nur ganzzahlige Ergebnisse unterstützt, wobei eine zusätzliche Funktion (leftover_division()) den '%' - Operator ersetzt. [b] Durch die Übergabe von Zeigern an Ganzzahlen anstelle von regulären Ganzzahlen an die divide_rounded() - Funktion und die Anpassung des Wertes von 'a' in divide_rounded() sollte die übrig gebliebene Funktion überflüssig werden, was viel Rechenzeit spart die 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 5

Below Methode ist die Umsetzung von binären divide Berücksichtigung beiden Zahlen positiv sind. Wenn Subtraktion ein Problem ist, können wir das auch mit binären Operatoren implementieren.

======

-(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<sizeof(inputNumber)*8;i++){ 
     if(inputNumber & (1<<i)){ 
      maxBit = i; 
      isMaxBitSet=YES; 
     } 
    } 
    if (isMaxBitSet) { 
     maxBit+=1; 
    } 
    return maxBit; 
} 



-(int)getMSB:(int)bits ofNumber:(int)number 
{ 
    int numbeMaxBit = [self getMaxBit:number]; 
    return number>>(numbeMaxBit -bits); 
} 

Answer 6

void main(){ 
    int a,b,i=0; 
    clrscr(); 
    printf("Enter the dividend and divisor"); 
    scanf("%d%d",&a,&b); 
    while(a>=b){ 
     a=a-b; 
     i++; 
    } 

    printf("qoutient is :%d \n remainder : %d",i,a); 
    getch(); 
} 

Answer 7

einfachste Weg:

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

Answer 8

Pseudo-Code in Python für Division durch konstante

n_bits = Anzahl der Bits der Eingangsüber welche Division wird voraussichtlich genau sein

der = 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)]) 

Multiplikation mit Verschiebungen und Additionen