Montag, Januar 27, 2020

Schreiben Sie eine Funktion zum dividieren eine Zahl durch 3 ohne die Verwendung von /, % und * Operatoren. itoa() zur Verfügung?

Habe ich versucht, es zu lösen mich, aber ich konnte nicht bekommen keine Ahnung.

Mir bitte helfen, diese zu lösen.

  • Wenn Sie erlauben, + und – ist es nicht sinnvoll, zu verhindern /, * und % verwenden. man kann drive-Funktion an. Oder + und – sollte auch verboten werden.. 🙂
InformationsquelleAutor SIVA | 2010-01-15

17 Kommentare

  1. 14

    Sind Sie soll Verwendung itoa() für diese Aufgabe? Denn dann könnte man verwenden, um eine Konvertierung in eine Basis-3-string, löschen Sie das Letzte Zeichen, und dann wieder zurück zur Basis 10.

  2. 10

    EDIT: UPS, habe ich falsch verstanden, der Titel ist Frage. Operator „multiplizieren“ ist ebenfalls verboten.

    Trotzdem glaube ich, dass es gut ist, nicht zu löschen diese Antwort für diejenigen, die nicht wissen, über die Aufteilung, indem Sie nicht die macht von zwei Konstanten.


    Die Lösung ist, um zu multiplizieren, die durch eine Magische Zahl und dann das extrahieren der 32 leftmost bits:

    Division durch 3 ist äquivalent zu vermehren, indem 1431655766 und dann shift um 32, in C:

    int divideBy3(int n)
    {
      return (n * 1431655766) >> 32;
    }
    

    Sehen Hacker ‚ s Delight Magische Zahl-Rechner.

    • Vermehren ist nicht erlaubt
    • Den Titel Lesen: „ohne die mithilfe /, % und *„.
    • ja nur ich falsch verstanden, der Titel. Ich Schnitt meine Antwort, während Sie schreiben Ihren Kommentar
    • Ich habe Mitleid mit der Narr, der hat zu Holen, die sich für die Wartung… 🙂
    • ist das nicht non-portable?
    • mit kommentierten code, es könnte nicht ein problem sein. Es ist gut, dass es in Ihrem Optimierungs-tricks und auch Teile des Codes, die nicht wirklich performance-kritischen muss es nicht benutzen, offensichtlich
    • Ich mag diese Antwort. Die Multiplikation kann geschrieben werden als for(int i = 0; i < 1431655766) n += n; Als die Antwort ist im Einklang mit den Anforderungen.
    • n;. n += n führt n * 2^1431655766 🙂
    • es sollte ein schöner Weg, um >> und + schnell multiplizieren von großen zahlen. Zum Beispiel 5*x == (x<<2) + x. Ein langer Ausdruck, mit vielen << sollte in der Lage sein zu tun *1431655766
    • Ich von Ihnen positiv bewertet werden, weil ich bemerkt Multiplikation von 1431655766 in der compiler-Ausgabe, habe eine Google-Suche für die Reihe und lernte, Dank dieser Antwort, dass das, was passiert war, wurde die division durch 3. (Sorry.)

  3. 10

    Mithilfe der mathematischen relation:

    1/3 == Sum[1/2^(2n), {n, 1, Infinity}]
    

    Wir haben

    int div3 (int x) {
       int64_t blown_up_x = x;
       for (int power = 1; power < 32; power += 2)
          blown_up_x += ((int64_t)x) << power;
       return (int)(blown_up_x >> 33);
    }
    

    Wenn Sie können verwenden Sie nur 32-bit-Ganzzahlen,

    int div3 (int x) {
         int two_third = 0, four_third = 0;
         for (int power = 0; power < 31; power += 2) {
            four_third += x >> power;
            two_third += x >> (power + 1);
         }
         return (four_third - two_third) >> 2;
    }
    

    Den 4/3 - 2/3 Behandlung verwendet wird, da x >> 1 ist floor(x/2) statt round(x/2).

    • Wenn das funktioniert, dann ist es eine wirklich Coole Lösung!
    • Der „64-bit“ – version nicht zu arbeiten. Die „32-bit“ – version wird bei den meisten ausgeschaltet werden durch 1 oder -1.
    • dies ist genau die binäre Darstellung von 1/3
  4. 4

    Hier ist eine Lösung in C++ implementiert:

    #include <iostream>
    
    int letUserEnterANumber()
    {
        int numberEnteredByUser;
        std::cin >> numberEnteredByUser;
        return numberEnteredByUser;
    }
    
    int divideByThree(int x)
    {
        std::cout << "What is " << x << " divided by 3?" << std::endl;
        int answer = 0;
        while ( answer + answer + answer != x )
        {
            answer = letUserEnterANumber();
        }
    }
    

    😉

  5. 3
    if(number<0){ //Edited after comments
    number = -(number);
    }
    quotient = 0;
    while (number-3 >= 0){ //Edited after comments..
    number = number-3;
    quotient++;
    }//after loop exits value in number will give you reminder
    

    EDIT: Getestet und funktioniert einwandfrei 🙁

    Hoffe, dass dies geholfen. 🙂

    • Funktioniert nicht mit negativen zahlen
    • Es wird besser sein, wenn die while-Bedingung wird number >= 3 da man diese: 5:3=2
    • Immer noch nicht arbeiten. Wird es wieder einem zu viel. Versuchen Sie, number=3, werden Sie feststellen, wie wird es wieder quotient=2 statt quotient = 1
    • es wouldnt return quotient = 2 für die Anzahl=3.. check mal wieder 🙁 ..sonst meine Augen und mein Gehirn sein sollte, trickst mich.. ich auch getestet, das selbe.. bitte überprüfen Sie den code sorgfältig, bevor Sie Kommentare und down-voting.. pls
    • 5/3 ist 1.66666..ich Stimme dir zu…hier ist der 1 quotient.. wenn Sie das Kontrollkästchen mein code, es gibt Sie-Quotienten als 1 und Erinnerung 2.. 2/3 0.66666…also beide zusammen geben Sie 1.6666..
    • Sind Sie richtig. Nicht sicher, was ich dachte 🙂

  6. 1

    Klingt wie Hausaufgaben 🙂

    Ich ein Bild Sie können eine Funktion schreiben, die iterativ teilt eine Zahl. E. g. Sie können Modell, was Sie tun, mit einem Stift und einem Stück Papier zu zahlen teilen. Oder Sie können verwenden Sie shift-Operatoren-und +, um herauszufinden, ob Ihre Zwischenergebnisse zu klein/groß und iterativ anwenden Korrekturen. Ich werde nicht schreiben Sie den code, aber …

  7. 1
    long divByThree(int x)
    {    
      char buf[100];
      itoa(x, buf, 3); 
      buf[ strlen(buf) - 1] = 0; 
      char* tmp; 
      long res = strtol(buf, &tmp, 3);
    
      return res;
    }
    
  8. 1
    int divideby3(int n)
    {
        int x=0;
        if(n<3) { return 0; }
        while(n>=3)
        {
            n=n-3;
            x++;
        }
        return x;
    }
    
  9. 1

    können Sie eine Eigenschaft aus der zahlen: Eine Zahl ist durch 3 teilbar, wenn Ihre Summe ist teilbar by3.
    Nehmen Sie die einzelnen Ziffern von itoa() und dann mit switch-Funktion für Sie rekursiv mit Ergänzungen und itoa()

    Hoffe, das hilft

  10. 1

    Dies ist sehr einfach, so einfach, ich bin nur noch der Hinweis auf die Antwort –

    Grundlegende Boolesche Logik-Gatter (und,oder,nicht,xor,…) nicht Sparte. Trotz dieses handicaps CPUs tun können. division. Ihre Lösung liegt auf der Hand: finden Sie einen Verweis, der Ihnen sagt, wie man einen divisor mit boolescher Logik und code schreiben, um zu realisieren, dass.

    • Ich sollte Hinzugefügt haben, dass, wenn Sie möchten, könnten Sie implementieren eine Schaltung, die nur teilt sich durch 3, aber warum nicht realisieren einer Schaltung für die Allgemeine Abteilung.
    • auch Division durch eine Konstante verwenden, weniger Tore – oft eine wichtige Optimierung in hardware-design (denke, es hängt davon ab, welche Klasse das ist)
  11. 0

    Wie wäre es damit, in eine Art von Python, wie pseudo-code. Es teilt die Antwort in einen ganzzahligen Teil und einen Bruchteil. Wenn Sie wollen, es zu konvertieren, um eine floating-point-Darstellung, dann bin ich nicht sicher der beste Weg das zu tun.

     x = <a number>  
     total = x
     intpart = 0
     fracpart = 0
    
     % Find the integer part
     while total >= 3
        total = total - 3
        intpart = intpart + 1
    
     % Fraction is what remains
     fracpart = total
    
    
     print "%d /3 = %d + %d/3" % (x, intpart, fracpart)
    

    Beachten Sie, dass dies funktioniert nicht für negative zahlen. Um dies zu beheben, müssen Sie ändern Sie den Algorithmus:

      total = abs(x)
      is_neg = abs(x) != x
    
      ....
    
      if is_neg
          print "%d /3 = -(%d + %d/3)" % (x, intpart, fracpart)
    
  12. 0

    für positive integer-division

    result = 0
    while (result + result + result < input)
     result +=1
    return result
    
    • Nur integer-division. Funktioniert nicht mit negativen zahlen. Wenn der Eingang ist groß, eine Menge der unneccesary Ergänzungen vorgenommen werden.
    • yep, aber es funktioniert tatsächlich mit diesen Einschränkungen im Gegensatz zu anderen, ähnlichen Antwort
    • Ja, es ist viel besser in dieser Hinsicht 🙂
  13. 0
    unsigned int  div3(unsigned int m) {
       unsigned long long n = m;
       n += n << 2;
       n += n << 4;
       n += n << 8;
       n += n << 16;
       return (n+m) >> 32;
    }
    
  14. 0

    Konvertieren 1/3 in binären

    also 1/3=0.01010101010101010101010101

    und dann einfach „multiplizieren“ mit dieser Nummer, mit Verschiebungen und die Summe

  15. -1

    Langsam und naiv, aber es sollte funktionieren, wenn eine exakte Teiler existiert. Außerdem ist erlaubt, richtig?

    for number from 1 to input
      if number == input+input+input
        return number
    

    Verlängerung für fractional-Teiler ist Links als übung für den Leser.
    Im Grunde testen bei +1 und +2, denke ich…

    • Nein, das immer wieder Eingang (mult anstelle des “ Teile-und-falsch-loop-Bereich) und übernimmt-Eingang > 0
    • Uhm, dies nicht tun, Teilung und nie etwas zurückzugeben. „Anzahl“ kann bei den meisten „input“, also „Zahl == Eingabe + Eingabe + Eingabe“ wird niemals wahr sein.
    • ersetzen Sie die ‚Anzahl == Eingang+Eingang+Eingang „durch“ Eingabe == Zahl+Zahl+Zahl“

Kostenlose Online-Tests