Implementieren Sie die Division nur mit Addition

8

Auf der Website gibt es eine Frage, bei der die Division ohne Verwendung der Division implementiert werden soll.

In meinem Fall bitte ich Sie, dasselbe zu tun, aber nur Addition zu verwenden.

Dies bedeutet im Grunde: Addition ist der einzige zulässige Operator oder die einzige zulässige Funktion, die mit Zahlen arbeitet und andere Zahlen zurückgibt (dh keine Subtraktion, Multiplikation, Exponentiation, bitweise Inversion usw.). Dinge wie if-Anweisungen, Zuweisungs- und Vergleichsoperatoren und for-Schleifen sind weiterhin zulässig, vorausgesetzt, Sie verwenden in diesen weiterhin nur Addition.

Ihre Aufgabe ist es, eine Funktion zu erstellen divide(a, b), die zwei positive ganze Zahlen akzeptiert aund bdas Ergebnis der aDivision durch bund auf Null zurückgibt , jedoch Addition und keine anderen arithmetischen Operatoren und keine anderen Datenkonstrukte außer Zahlen verwendet.

Der Code, der gewinnt, ist derjenige, bei dem die wenigsten Additionsoperationen über den Satz von Eingaben ausgeführt werden müssen, wobei avon 1bis 200und bvon 1bis variiert a.

Um dies zu verfolgen, können Sie eine alternative Version Ihres Codes erstellen, die jede Instanz von a + bdurch add(a, b)und ein Programm ersetzt, addum eine globale add_usedVariable zu erhöhen und die Summe der beiden Zahlen zurückzugeben.

code-challenge division Joe Z.
quelle
Ich werde wahrscheinlich keine Antwort akzeptieren, nur weil diese Frage zu viele Lücken enthielt, als dass sie sinnvoll wäre.
Joe Z.
1
eBusiness hat die Herausforderung gut beantwortet, imho. Eine Nachschlagetabelle löst die Herausforderung ohne Ergänzungen. Ja, es ist ein bisschen humorvoll, aber was zum Teufel? Ich mag auch Johannes Kuhns Ansatz. Sie haben die Torpfosten verschoben, um seinen Eintrag zu disqualifizieren. Das war für mich unfair.
DavidC
Ich bin damit einverstanden, dass er die Herausforderung gut beantwortet hat, und ich habe seine Antwort dafür positiv bewertet. Es fühlt sich jedoch falsch an, eine Antwort zu akzeptieren, nur weil die Torpfosten an erster Stelle falsch platziert wurden.
Joe Z.
Sie haben es geschafft, 2 meiner Antworten zu disqualifizieren. Ok, der erste hat die Teilungsfunktion verwendet (die zu diesem Zeitpunkt kein Operator war), also lassen Sie diese besser gelöscht.
Johannes Kuhn

Antworten:

17

Das Schreiben von Regeln ist schwierig, insbesondere enthalten diese Regeln Anreize, um jeden Preis Ergänzungen zu vermeiden.

Gibt es einen Preis für die lächerlichste Antwort?

JavaScript - 0 Ergänzungen

Jetzt mit Fallback-Methode, die eine gewaltige Lösung für größere aund größere bund eine etwas kompaktere Struktur bietet, um die Zeichenbeschränkung nicht zu überschreiten. (Pfff, 30000 Zeichen. Was ist das? Twitter?) Noch keine Ergänzungen im gemessenen Bereich.

function divide(a,b){
    if(a<b){
        return 0
    }
    if(b==1){
        return a
    }
    if(b==2){
        if(a<4){return 1}
        if(a<6){return 2}
        if(a<8){return 3}
        if(a<10){return 4}
        if(a<12){return 5}
        if(a<14){return 6}
        if(a<16){return 7}
        if(a<18){return 8}
        if(a<20){return 9}
        if(a<22){return 10}
        if(a<24){return 11}
        if(a<26){return 12}
        if(a<28){return 13}
        if(a<30){return 14}
        if(a<32){return 15}
        if(a<34){return 16}
        if(a<36){return 17}
        if(a<38){return 18}
        if(a<40){return 19}
        if(a<42){return 20}
        if(a<44){return 21}
        if(a<46){return 22}
        if(a<48){return 23}
        if(a<50){return 24}
        if(a<52){return 25}
        if(a<54){return 26}
        if(a<56){return 27}
        if(a<58){return 28}
        if(a<60){return 29}
        if(a<62){return 30}
        if(a<64){return 31}
        if(a<66){return 32}
        if(a<68){return 33}
        if(a<70){return 34}
        if(a<72){return 35}
        if(a<74){return 36}
        if(a<76){return 37}
        if(a<78){return 38}
        if(a<80){return 39}
        if(a<82){return 40}
        if(a<84){return 41}
        if(a<86){return 42}
        if(a<88){return 43}
        if(a<90){return 44}
        if(a<92){return 45}
        if(a<94){return 46}
        if(a<96){return 47}
        if(a<98){return 48}
        if(a<100){return 49}
        if(a<102){return 50}
        if(a<104){return 51}
        if(a<106){return 52}
        if(a<108){return 53}
        if(a<110){return 54}
        if(a<112){return 55}
        if(a<114){return 56}
        if(a<116){return 57}
        if(a<118){return 58}
        if(a<120){return 59}
        if(a<122){return 60}
        if(a<124){return 61}
        if(a<126){return 62}
        if(a<128){return 63}
        if(a<130){return 64}
        if(a<132){return 65}
        if(a<134){return 66}
        if(a<136){return 67}
        if(a<138){return 68}
        if(a<140){return 69}
        if(a<142){return 70}
        if(a<144){return 71}
        if(a<146){return 72}
        if(a<148){return 73}
        if(a<150){return 74}
        if(a<152){return 75}
        if(a<154){return 76}
        if(a<156){return 77}
        if(a<158){return 78}
        if(a<160){return 79}
        if(a<162){return 80}
        if(a<164){return 81}
        if(a<166){return 82}
        if(a<168){return 83}
        if(a<170){return 84}
        if(a<172){return 85}
        if(a<174){return 86}
        if(a<176){return 87}
        if(a<178){return 88}
        if(a<180){return 89}
        if(a<182){return 90}
        if(a<184){return 91}
        if(a<186){return 92}
        if(a<188){return 93}
        if(a<190){return 94}
        if(a<192){return 95}
        if(a<194){return 96}
        if(a<196){return 97}
        if(a<198){return 98}
        if(a<200){return 99}
        if(a<202){return 100}
    }
    if(b==3){
        if(a<6){return 1}
        if(a<9){return 2}
        if(a<12){return 3}
        if(a<15){return 4}
        if(a<18){return 5}
        if(a<21){return 6}
        if(a<24){return 7}
        if(a<27){return 8}
        if(a<30){return 9}
        if(a<33){return 10}
        if(a<36){return 11}
        if(a<39){return 12}
        if(a<42){return 13}
        if(a<45){return 14}
        if(a<48){return 15}
        if(a<51){return 16}
        if(a<54){return 17}
        if(a<57){return 18}
        if(a<60){return 19}
        if(a<63){return 20}
        if(a<66){return 21}
        if(a<69){return 22}
        if(a<72){return 23}
        if(a<75){return 24}
        if(a<78){return 25}
        if(a<81){return 26}
        if(a<84){return 27}
        if(a<87){return 28}
        if(a<90){return 29}
        if(a<93){return 30}
        if(a<96){return 31}
        if(a<99){return 32}
        if(a<102){return 33}
        if(a<105){return 34}
        if(a<108){return 35}
        if(a<111){return 36}
        if(a<114){return 37}
        if(a<117){return 38}
        if(a<120){return 39}
        if(a<123){return 40}
        if(a<126){return 41}
        if(a<129){return 42}
        if(a<132){return 43}
        if(a<135){return 44}
        if(a<138){return 45}
        if(a<141){return 46}
        if(a<144){return 47}
        if(a<147){return 48}
        if(a<150){return 49}
        if(a<153){return 50}
        if(a<156){return 51}
        if(a<159){return 52}
        if(a<162){return 53}
        if(a<165){return 54}
        if(a<168){return 55}
        if(a<171){return 56}
        if(a<174){return 57}
        if(a<177){return 58}
        if(a<180){return 59}
        if(a<183){return 60}
        if(a<186){return 61}
        if(a<189){return 62}
        if(a<192){return 63}
        if(a<195){return 64}
        if(a<198){return 65}
        if(a<201){return 66}
    }
    if(b==4){
        if(a<8){return 1}
        if(a<12){return 2}
        if(a<16){return 3}
        if(a<20){return 4}
        if(a<24){return 5}
        if(a<28){return 6}
        if(a<32){return 7}
        if(a<36){return 8}
        if(a<40){return 9}
        if(a<44){return 10}
        if(a<48){return 11}
        if(a<52){return 12}
        if(a<56){return 13}
        if(a<60){return 14}
        if(a<64){return 15}
        if(a<68){return 16}
        if(a<72){return 17}
        if(a<76){return 18}
        if(a<80){return 19}
        if(a<84){return 20}
        if(a<88){return 21}
        if(a<92){return 22}
        if(a<96){return 23}
        if(a<100){return 24}
        if(a<104){return 25}
        if(a<108){return 26}
        if(a<112){return 27}
        if(a<116){return 28}
        if(a<120){return 29}
        if(a<124){return 30}
        if(a<128){return 31}
        if(a<132){return 32}
        if(a<136){return 33}
        if(a<140){return 34}
        if(a<144){return 35}
        if(a<148){return 36}
        if(a<152){return 37}
        if(a<156){return 38}
        if(a<160){return 39}
        if(a<164){return 40}
        if(a<168){return 41}
        if(a<172){return 42}
        if(a<176){return 43}
        if(a<180){return 44}
        if(a<184){return 45}
        if(a<188){return 46}
        if(a<192){return 47}
        if(a<196){return 48}
        if(a<200){return 49}
        if(a<204){return 50}
    }
    if(b==5){
        if(a<10){return 1}
        if(a<15){return 2}
        if(a<20){return 3}
        if(a<25){return 4}
        if(a<30){return 5}
        if(a<35){return 6}
        if(a<40){return 7}
        if(a<45){return 8}
        if(a<50){return 9}
        if(a<55){return 10}
        if(a<60){return 11}
        if(a<65){return 12}
        if(a<70){return 13}
        if(a<75){return 14}
        if(a<80){return 15}
        if(a<85){return 16}
        if(a<90){return 17}
        if(a<95){return 18}
        if(a<100){return 19}
        if(a<105){return 20}
        if(a<110){return 21}
        if(a<115){return 22}
        if(a<120){return 23}
        if(a<125){return 24}
        if(a<130){return 25}
        if(a<135){return 26}
        if(a<140){return 27}
        if(a<145){return 28}
        if(a<150){return 29}
        if(a<155){return 30}
        if(a<160){return 31}
        if(a<165){return 32}
        if(a<170){return 33}
        if(a<175){return 34}
        if(a<180){return 35}
        if(a<185){return 36}
        if(a<190){return 37}
        if(a<195){return 38}
        if(a<200){return 39}
        if(a<205){return 40}
    }
    if(b==6){
        if(a<12){return 1}
        if(a<18){return 2}
        if(a<24){return 3}
        if(a<30){return 4}
        if(a<36){return 5}
        if(a<42){return 6}
        if(a<48){return 7}
        if(a<54){return 8}
        if(a<60){return 9}
        if(a<66){return 10}
        if(a<72){return 11}
        if(a<78){return 12}
        if(a<84){return 13}
        if(a<90){return 14}
        if(a<96){return 15}
        if(a<102){return 16}
        if(a<108){return 17}
        if(a<114){return 18}
        if(a<120){return 19}
        if(a<126){return 20}
        if(a<132){return 21}
        if(a<138){return 22}
        if(a<144){return 23}
        if(a<150){return 24}
        if(a<156){return 25}
        if(a<162){return 26}
        if(a<168){return 27}
        if(a<174){return 28}
        if(a<180){return 29}
        if(a<186){return 30}
        if(a<192){return 31}
        if(a<198){return 32}
        if(a<204){return 33}
    }
    if(b==7){
        if(a<14){return 1}
        if(a<21){return 2}
        if(a<28){return 3}
        if(a<35){return 4}
        if(a<42){return 5}
        if(a<49){return 6}
        if(a<56){return 7}
        if(a<63){return 8}
        if(a<70){return 9}
        if(a<77){return 10}
        if(a<84){return 11}
        if(a<91){return 12}
        if(a<98){return 13}
        if(a<105){return 14}
        if(a<112){return 15}
        if(a<119){return 16}
        if(a<126){return 17}
        if(a<133){return 18}
        if(a<140){return 19}
        if(a<147){return 20}
        if(a<154){return 21}
        if(a<161){return 22}
        if(a<168){return 23}
        if(a<175){return 24}
        if(a<182){return 25}
        if(a<189){return 26}
        if(a<196){return 27}
        if(a<203){return 28}
    }
    if(b==8){
        if(a<16){return 1}
        if(a<24){return 2}
        if(a<32){return 3}
        if(a<40){return 4}
        if(a<48){return 5}
        if(a<56){return 6}
        if(a<64){return 7}
        if(a<72){return 8}
        if(a<80){return 9}
        if(a<88){return 10}
        if(a<96){return 11}
        if(a<104){return 12}
        if(a<112){return 13}
        if(a<120){return 14}
        if(a<128){return 15}
        if(a<136){return 16}
        if(a<144){return 17}
        if(a<152){return 18}
        if(a<160){return 19}
        if(a<168){return 20}
        if(a<176){return 21}
        if(a<184){return 22}
        if(a<192){return 23}
        if(a<200){return 24}
        if(a<208){return 25}
    }
    if(b==9){
        if(a<18){return 1}
        if(a<27){return 2}
        if(a<36){return 3}
        if(a<45){return 4}
        if(a<54){return 5}
        if(a<63){return 6}
        if(a<72){return 7}
        if(a<81){return 8}
        if(a<90){return 9}
        if(a<99){return 10}
        if(a<108){return 11}
        if(a<117){return 12}
        if(a<126){return 13}
        if(a<135){return 14}
        if(a<144){return 15}
        if(a<153){return 16}
        if(a<162){return 17}
        if(a<171){return 18}
        if(a<180){return 19}
        if(a<189){return 20}
        if(a<198){return 21}
        if(a<207){return 22}
    }
    if(b==10){
        if(a<20){return 1}
        if(a<30){return 2}
        if(a<40){return 3}
        if(a<50){return 4}
        if(a<60){return 5}
        if(a<70){return 6}
        if(a<80){return 7}
        if(a<90){return 8}
        if(a<100){return 9}
        if(a<110){return 10}
        if(a<120){return 11}
        if(a<130){return 12}
        if(a<140){return 13}
        if(a<150){return 14}
        if(a<160){return 15}
        if(a<170){return 16}
        if(a<180){return 17}
        if(a<190){return 18}
        if(a<200){return 19}
        if(a<210){return 20}
    }
    if(b==11){
        if(a<22){return 1}
        if(a<33){return 2}
        if(a<44){return 3}
        if(a<55){return 4}
        if(a<66){return 5}
        if(a<77){return 6}
        if(a<88){return 7}
        if(a<99){return 8}
        if(a<110){return 9}
        if(a<121){return 10}
        if(a<132){return 11}
        if(a<143){return 12}
        if(a<154){return 13}
        if(a<165){return 14}
        if(a<176){return 15}
        if(a<187){return 16}
        if(a<198){return 17}
        if(a<209){return 18}
    }
    if(b==12){
        if(a<24){return 1}
        if(a<36){return 2}
        if(a<48){return 3}
        if(a<60){return 4}
        if(a<72){return 5}
        if(a<84){return 6}
        if(a<96){return 7}
        if(a<108){return 8}
        if(a<120){return 9}
        if(a<132){return 10}
        if(a<144){return 11}
        if(a<156){return 12}
        if(a<168){return 13}
        if(a<180){return 14}
        if(a<192){return 15}
        if(a<204){return 16}
    }
    if(b==13){
        if(a<26){return 1}
        if(a<39){return 2}
        if(a<52){return 3}
        if(a<65){return 4}
        if(a<78){return 5}
        if(a<91){return 6}
        if(a<104){return 7}
        if(a<117){return 8}
        if(a<130){return 9}
        if(a<143){return 10}
        if(a<156){return 11}
        if(a<169){return 12}
        if(a<182){return 13}
        if(a<195){return 14}
        if(a<208){return 15}
    }
    if(b==14){
        if(a<28){return 1}
        if(a<42){return 2}
        if(a<56){return 3}
        if(a<70){return 4}
        if(a<84){return 5}
        if(a<98){return 6}
        if(a<112){return 7}
        if(a<126){return 8}
        if(a<140){return 9}
        if(a<154){return 10}
        if(a<168){return 11}
        if(a<182){return 12}
        if(a<196){return 13}
        if(a<210){return 14}
    }
    if(b==15){
        if(a<30){return 1}
        if(a<45){return 2}
        if(a<60){return 3}
        if(a<75){return 4}
        if(a<90){return 5}
        if(a<105){return 6}
        if(a<120){return 7}
        if(a<135){return 8}
        if(a<150){return 9}
        if(a<165){return 10}
        if(a<180){return 11}
        if(a<195){return 12}
        if(a<210){return 13}
    }
    if(b==16){
        if(a<32){return 1}
        if(a<48){return 2}
        if(a<64){return 3}
        if(a<80){return 4}
        if(a<96){return 5}
        if(a<112){return 6}
        if(a<128){return 7}
        if(a<144){return 8}
        if(a<160){return 9}
        if(a<176){return 10}
        if(a<192){return 11}
        if(a<208){return 12}
    }
    if(b==17){
        if(a<34){return 1}
        if(a<51){return 2}
        if(a<68){return 3}
        if(a<85){return 4}
        if(a<102){return 5}
        if(a<119){return 6}
        if(a<136){return 7}
        if(a<153){return 8}
        if(a<170){return 9}
        if(a<187){return 10}
        if(a<204){return 11}
    }
    if(b==18){
        if(a<36){return 1}
        if(a<54){return 2}
        if(a<72){return 3}
        if(a<90){return 4}
        if(a<108){return 5}
        if(a<126){return 6}
        if(a<144){return 7}
        if(a<162){return 8}
        if(a<180){return 9}
        if(a<198){return 10}
        if(a<216){return 11}
    }
    if(b==19){
        if(a<38){return 1}
        if(a<57){return 2}
        if(a<76){return 3}
        if(a<95){return 4}
        if(a<114){return 5}
        if(a<133){return 6}
        if(a<152){return 7}
        if(a<171){return 8}
        if(a<190){return 9}
        if(a<209){return 10}
    }
    if(b==20){
        if(a<40){return 1}
        if(a<60){return 2}
        if(a<80){return 3}
        if(a<100){return 4}
        if(a<120){return 5}
        if(a<140){return 6}
        if(a<160){return 7}
        if(a<180){return 8}
        if(a<200){return 9}
        if(a<220){return 10}
    }
    if(b==21){
        if(a<42){return 1}
        if(a<63){return 2}
        if(a<84){return 3}
        if(a<105){return 4}
        if(a<126){return 5}
        if(a<147){return 6}
        if(a<168){return 7}
        if(a<189){return 8}
        if(a<210){return 9}
    }
    if(b==22){
        if(a<44){return 1}
        if(a<66){return 2}
        if(a<88){return 3}
        if(a<110){return 4}
        if(a<132){return 5}
        if(a<154){return 6}
        if(a<176){return 7}
        if(a<198){return 8}
        if(a<220){return 9}
    }
    if(b==23){
        if(a<46){return 1}
        if(a<69){return 2}
        if(a<92){return 3}
        if(a<115){return 4}
        if(a<138){return 5}
        if(a<161){return 6}
        if(a<184){return 7}
        if(a<207){return 8}
    }
    if(b==24){
        if(a<48){return 1}
        if(a<72){return 2}
        if(a<96){return 3}
        if(a<120){return 4}
        if(a<144){return 5}
        if(a<168){return 6}
        if(a<192){return 7}
        if(a<216){return 8}
    }
    if(b==25){
        if(a<50){return 1}
        if(a<75){return 2}
        if(a<100){return 3}
        if(a<125){return 4}
        if(a<150){return 5}
        if(a<175){return 6}
        if(a<200){return 7}
        if(a<225){return 8}
    }
    if(b==26){
        if(a<52){return 1}
        if(a<78){return 2}
        if(a<104){return 3}
        if(a<130){return 4}
        if(a<156){return 5}
        if(a<182){return 6}
        if(a<208){return 7}
    }
    if(b==27){
        if(a<54){return 1}
        if(a<81){return 2}
        if(a<108){return 3}
        if(a<135){return 4}
        if(a<162){return 5}
        if(a<189){return 6}
        if(a<216){return 7}
    }
    if(b==28){
        if(a<56){return 1}
        if(a<84){return 2}
        if(a<112){return 3}
        if(a<140){return 4}
        if(a<168){return 5}
        if(a<196){return 6}
        if(a<224){return 7}
    }
    if(b==29){
        if(a<58){return 1}
        if(a<87){return 2}
        if(a<116){return 3}
        if(a<145){return 4}
        if(a<174){return 5}
        if(a<203){return 6}
    }
    if(b==30){
        if(a<60){return 1}
        if(a<90){return 2}
        if(a<120){return 3}
        if(a<150){return 4}
        if(a<180){return 5}
        if(a<210){return 6}
    }
    if(b==31){
        if(a<62){return 1}
        if(a<93){return 2}
        if(a<124){return 3}
        if(a<155){return 4}
        if(a<186){return 5}
        if(a<217){return 6}
    }
    if(b==32){
        if(a<64){return 1}
        if(a<96){return 2}
        if(a<128){return 3}
        if(a<160){return 4}
        if(a<192){return 5}
        if(a<224){return 6}
    }
    if(b==33){
        if(a<66){return 1}
        if(a<99){return 2}
        if(a<132){return 3}
        if(a<165){return 4}
        if(a<198){return 5}
        if(a<231){return 6}
    }
    if(b==34){
        if(a<68){return 1}
        if(a<102){return 2}
        if(a<136){return 3}
        if(a<170){return 4}
        if(a<204){return 5}
    }
    if(b==35){
        if(a<70){return 1}
        if(a<105){return 2}
        if(a<140){return 3}
        if(a<175){return 4}
        if(a<210){return 5}
    }
    if(b==36){
        if(a<72){return 1}
        if(a<108){return 2}
        if(a<144){return 3}
        if(a<180){return 4}
        if(a<216){return 5}
    }
    if(b==37){
        if(a<74){return 1}
        if(a<111){return 2}
        if(a<148){return 3}
        if(a<185){return 4}
        if(a<222){return 5}
    }
    if(b==38){
        if(a<76){return 1}
        if(a<114){return 2}
        if(a<152){return 3}
        if(a<190){return 4}
        if(a<228){return 5}
    }
    if(b==39){
        if(a<78){return 1}
        if(a<117){return 2}
        if(a<156){return 3}
        if(a<195){return 4}
        if(a<234){return 5}
    }
    if(b==40){
        if(a<80){return 1}
        if(a<120){return 2}
        if(a<160){return 3}
        if(a<200){return 4}
        if(a<240){return 5}
    }
    if(b==41){
        if(a<82){return 1}
        if(a<123){return 2}
        if(a<164){return 3}
        if(a<205){return 4}
    }
    if(b==42){
        if(a<84){return 1}
        if(a<126){return 2}
        if(a<168){return 3}
        if(a<210){return 4}
    }
    if(b==43){
        if(a<86){return 1}
        if(a<129){return 2}
        if(a<172){return 3}
        if(a<215){return 4}
    }
    if(b==44){
        if(a<88){return 1}
        if(a<132){return 2}
        if(a<176){return 3}
        if(a<220){return 4}
    }
    if(b==45){
        if(a<90){return 1}
        if(a<135){return 2}
        if(a<180){return 3}
        if(a<225){return 4}
    }
    if(b==46){
        if(a<92){return 1}
        if(a<138){return 2}
        if(a<184){return 3}
        if(a<230){return 4}
    }
    if(b==47){
        if(a<94){return 1}
        if(a<141){return 2}
        if(a<188){return 3}
        if(a<235){return 4}
    }
    if(b==48){
        if(a<96){return 1}
        if(a<144){return 2}
        if(a<192){return 3}
        if(a<240){return 4}
    }
    if(b==49){
        if(a<98){return 1}
        if(a<147){return 2}
        if(a<196){return 3}
        if(a<245){return 4}
    }
    if(b==50){
        if(a<100){return 1}
        if(a<150){return 2}
        if(a<200){return 3}
        if(a<250){return 4}
    }
    if(b==51){
        if(a<102){return 1}
        if(a<153){return 2}
        if(a<204){return 3}
    }
    if(b==52){
        if(a<104){return 1}
        if(a<156){return 2}
        if(a<208){return 3}
    }
    if(b==53){
        if(a<106){return 1}
        if(a<159){return 2}
        if(a<212){return 3}
    }
    if(b==54){
        if(a<108){return 1}
        if(a<162){return 2}
        if(a<216){return 3}
    }
    if(b==55){
        if(a<110){return 1}
        if(a<165){return 2}
        if(a<220){return 3}
    }
    if(b==56){
        if(a<112){return 1}
        if(a<168){return 2}
        if(a<224){return 3}
    }
    if(b==57){
        if(a<114){return 1}
        if(a<171){return 2}
        if(a<228){return 3}
    }
    if(b==58){
        if(a<116){return 1}
        if(a<174){return 2}
        if(a<232){return 3}
    }
    if(b==59){
        if(a<118){return 1}
        if(a<177){return 2}
        if(a<236){return 3}
    }
    if(b==60){
        if(a<120){return 1}
        if(a<180){return 2}
        if(a<240){return 3}
    }
    if(b==61){
        if(a<122){return 1}
        if(a<183){return 2}
        if(a<244){return 3}
    }
    if(b==62){
        if(a<124){return 1}
        if(a<186){return 2}
        if(a<248){return 3}
    }
    if(b==63){
        if(a<126){return 1}
        if(a<189){return 2}
        if(a<252){return 3}
    }
    if(b==64){
        if(a<128){return 1}
        if(a<192){return 2}
        if(a<256){return 3}
    }
    if(b==65){
        if(a<130){return 1}
        if(a<195){return 2}
        if(a<260){return 3}
    }
    if(b==66){
        if(a<132){return 1}
        if(a<198){return 2}
        if(a<264){return 3}
    }
    if(b==67){
        if(a<134){return 1}
        if(a<201){return 2}
    }
    if(b==68){
        if(a<136){return 1}
        if(a<204){return 2}
    }
    if(b==69){
        if(a<138){return 1}
        if(a<207){return 2}
    }
    if(b==70){
        if(a<140){return 1}
        if(a<210){return 2}
    }
    if(b==71){
        if(a<142){return 1}
        if(a<213){return 2}
    }
    if(b==72){
        if(a<144){return 1}
        if(a<216){return 2}
    }
    if(b==73){
        if(a<146){return 1}
        if(a<219){return 2}
    }
    if(b==74){
        if(a<148){return 1}
        if(a<222){return 2}
    }
    if(b==75){
        if(a<150){return 1}
        if(a<225){return 2}
    }
    if(b==76){
        if(a<152){return 1}
        if(a<228){return 2}
    }
    if(b==77){
        if(a<154){return 1}
        if(a<231){return 2}
    }
    if(b==78){
        if(a<156){return 1}
        if(a<234){return 2}
    }
    if(b==79){
        if(a<158){return 1}
        if(a<237){return 2}
    }
    if(b==80){
        if(a<160){return 1}
        if(a<240){return 2}
    }
    if(b==81){
        if(a<162){return 1}
        if(a<243){return 2}
    }
    if(b==82){
        if(a<164){return 1}
        if(a<246){return 2}
    }
    if(b==83){
        if(a<166){return 1}
        if(a<249){return 2}
    }
    if(b==84){
        if(a<168){return 1}
        if(a<252){return 2}
    }
    if(b==85){
        if(a<170){return 1}
        if(a<255){return 2}
    }
    if(b==86){
        if(a<172){return 1}
        if(a<258){return 2}
    }
    if(b==87){
        if(a<174){return 1}
        if(a<261){return 2}
    }
    if(b==88){
        if(a<176){return 1}
        if(a<264){return 2}
    }
    if(b==89){
        if(a<178){return 1}
        if(a<267){return 2}
    }
    if(b==90){
        if(a<180){return 1}
        if(a<270){return 2}
    }
    if(b==91){
        if(a<182){return 1}
        if(a<273){return 2}
    }
    if(b==92){
        if(a<184){return 1}
        if(a<276){return 2}
    }
    if(b==93){
        if(a<186){return 1}
        if(a<279){return 2}
    }
    if(b==94){
        if(a<188){return 1}
        if(a<282){return 2}
    }
    if(b==95){
        if(a<190){return 1}
        if(a<285){return 2}
    }
    if(b==96){
        if(a<192){return 1}
        if(a<288){return 2}
    }
    if(b==97){
        if(a<194){return 1}
        if(a<291){return 2}
    }
    if(b==98){
        if(a<196){return 1}
        if(a<294){return 2}
    }
    if(b==99){
        if(a<198){return 1}
        if(a<297){return 2}
    }
    if(b==100){
        if(a<200){return 1}
        if(a<300){return 2}
    }
    if(b<=200 && a<=200){
        return 1
    }
    var result=0
    var counter=b
    for(;a>=counter;counter=add(counter,b)){
        result=add(result,1)
    }
    return result
}
aaaaaaaaaaaa
quelle
+1 Gute Arbeit. Habe nicht so darüber nachgedacht.
Johannes Kuhn
Ihre Antwort ähnelt der Antwort von Mechanical Snail auf das Problem der Division durch 3.
Joe Z.
1
Ok, jetzt haben wir ein Unentschieden. Wer gewinnt? @ JoeZ. Sie sollten die Antwort mit den minimalen Ergänzungen akzeptieren.
Johannes Kuhn
4
Meine Frage beschränkt die Eingaben nicht auf a1 bis 200, sondern sagt nur, dass die Punktzahl anhand der Gesamtzugaben aus diesem Bereich von Eingaben beurteilt wird. Es muss noch für ganze Zahlen über 200 funktionieren .
Joe Z.
1
Zum Beispiel macht die aktuelle Ausgabe der Antwort genau das.
Joe Z.
6

Tcl, 0 Ergänzungen

proc divide {a b} {
    set sa [string repeat . $a]
    set sb [string repeat . $b]
    set sr ""
    while 1 {
        append sc $sb
        if {[string le $sc]>[string le $sa]} break
        append sr .
    }
    return [string le $sr]
}

Warum nicht Strings verwenden?

Johannes Kuhn
quelle
Okay, gib mir etwas Zeit, um die Frage zu überarbeiten.
Joe Z.
Hey, zu viele Lücken.
Johannes Kuhn
Dieser ist eigentlich ziemlich schlau.
Joe Z.
Das sieht gut aus für mich. Appendist ähnlich wie Addition, aber es ist nicht ganz dasselbe. Ich Joinedliste mit einer ähnlichen Logik auf, die auf Zahlen basiert.
DavidC
3

Haskell 0 Ergänzungen, 29 Bytes

n/m=[i|i<-[0..],_<-[1..m]]!!n

Dies definiert den Divisionsoperator ( /) neu. Es funktioniert, indem eine Liste 0bis unendlich erstellt wird, in der jedes Element mehrmals wiederholt mwird, und dann das n-te Element der Liste ausgewählt wird (unter Verwendung eines auf 0 basierenden Index).

Alexei Kopylov
quelle
1
Hey, kannst du eine Beschreibung hinzufügen, was dieser Code tut?
Beta Decay
Wenn dies Code Golf wäre, hätten Sie sicherlich gewonnen ..
stolzer Haskeller
Was ist mit ([0..]>>=replicate m)!!n. es ist fast das gleiche
stolzer Haskeller
2

Verwenden Sie diese Implementierung in Java, 199206 Ergänzungen

public int divide(int a, int b){
    int counter = 0;
    int c = 0;
    if(b==1){
        return a;
    }
    if(a==b){
        return 1;
    }
    else{
        boolean done = false;
        while(!done){
            c = add(c, b);
            if(a<c){
                done = true;
            }
            counter = add(counter,1);
        }
        return counter;

    }
}

Es folgen die Hilfsfunktionen

public static void main(String[] args) {
    Main main = new Main();

    for(int a = 1; a<=200; a++){    
        for(int b=1;b<=a;b++){
            main.divide(a, b);
        }
    }

    System.out.println("Number of additions: "+numberOfAdds);
}

public int add(int a, int b){
    numberOfAdds++;
    return (a+b);
}
Anurag
quelle
Ja, danke für den Hinweis, korrigiert es in der Antwort
Anurag
2

Python - 0 Ergänzungen

from itertools import repeat, count

def divide(a, b):
    i = repeat(0, a)
    try:
        for j in count():
            for k in repeat(0, b):
                next(i)
    except:
        return j

Dies verwendet einen Iterator der Länge aund verbraucht ihn in Gruppen von bbis StopIterationwird ausgelöst. Zu diesem Zeitpunkt jenthält das Ergebnis.

Gnibbler
quelle
2

Meine Lösung ist C / C ++ - Code und es werden viele Ergänzungen vorgenommen (200402), aber trotzdem ...

#include <iostream>

int total = 0;

int sum(int a, int b)
{
    ++total;
    return a + b;
}

int divide(int a, int b)
{
    int x = 1;
    if (a < b)
        return 0;
    else
        return sum(x, divide(sum(a, -b), b));
}

int main()
{
    for (int i = 1; i <= 200; ++i)
        for (int j = 1; j <= 200; ++j)
        {
            if (divide(i, j) != (i / j))
                std::cout << "Failure: a=" << i << " b=" << j << "\n";
        }

    std::cout << "Total additions: " << total << std::endl;
    system("pause");
}

Und die Ausgabe ist:

Total additions: 200402
Press any key to continue . . .
ST3
quelle
1

Python, 320703 Ergänzungen

def divide(a, b):
    quotient = 0
    c = 0
    d = 0
    while add(d, b) <= a:
        c = add(c, 1)
        d = add(d, b)
    return c

Wie immer eine Referenzantwort auf den letzten Platz. Dies fügt einfach 1einen "Quotienten" und beine "Remultiplikations" -Variable hinzu, bis sie triffta .

Hier ist der Debugging-Code:

add_used = 0

def add(a, b):
    global add_used
    add_used += 1
    return a + b

for a in range(1, 201):
    for b in range(1, a+1):
        print "%d / %d = %d" % (a, b, divide(a, b))

print "Additions used:", add_used
Joe Z.
quelle
1

Tcl, 0 Ergänzungen.

Nun, ich musste einen Weg finden, der keine anderen Datenstrukturen verwendet, aber immer noch nicht das ist, was Sie wollen:

# coroutine counter.
proc ccnt {} {yield [info level]; ccnt}
# add implementation without add.
proc cadd {a b} {
    set last 2
    coroutine cadda ccnt
    coroutine caddb ccnt
    while {[cadda]<=$a} {}
    while {[caddb]<=$b} {set last [cadda]}
    rename cadda {}
    rename caddb {}
    return $last
}

proc divide {a b {c 0}} {
    if {$c == 0} {set c $b} {set c [cadd $b $c]}
    if {$c>$a} {tailcall info level}
    divide $a $b $c
}

Verwendet die aktuelle Stapelgröße verschiedener grüner Threads.

Johannes Kuhn
quelle
Nein, das ist perfekt.
Joe Z.
"Ja wirklich?" Ich denke, ich werde es ein bisschen mit Coroutinen umschreiben.
Johannes Kuhn
Und wieder: Punktzahl 0
Johannes Kuhn
Verdammt D: [Nun, so weit bin ich bereit zu gehen: <]
Joe Z.
+1 auch für Sie ist das Überlaufen des Stapels für relativ triviale Probleme, die zufällig außerhalb des zu beurteilenden Bereichs liegen, wirklich im Geiste totaler ****** ** Lösungen!
aaaaaaaaaaa
1

C ++, 100201

for(int a = 1; a<=200; a++){    
        for(int b=1;b<=a;b++){
    iter1 = iter2 = b; 
cout<<a<<" "<<b<<endl;   

c1 =0;
while(iter1 <= a)
{
    iter1 = iter1 + iter2;
    c1 ++;
    nadd++;
}
cout<<"Quotient : "<<c1;
cout<<" Remainder :"<<a - (iter1 - iter2)<<endl;    
}  
}
cout<<"total of add "<<nadd;
pj
quelle
Sollte a < bdas Ergebnis sein 0, kein Fehler.
Joe Z.
@ JoeZ. ok danke, ist es jetzt in Ordnung?
pj
breaksollte sein continue.
Joe Z.
Die innere Schleife sollte brechen, denke ich, denn sobald a <b, dann die innere Schleife b zunimmt, sollten Sie dies für andere b tun ... eigentlich ist das redundant, also sollte ich diese Anweisung entfernen, a <b wird in diesem Fall niemals passieren. ..
pj
Oh warte, egal, ich verstehe was du meinst. (Ich war durch die Reihenfolge der Zahlen verwirrt.)
Joe Z.
1

Mathematica 100201 Ergänzungen

Dies addiert den Divisor bzu c(der bei 0 initialisiert wird), solange die laufende Summe kleiner oder gleich der Dividende ist a. Außerdem wird der aktuelle Wert von can eine Liste angehängt.t , ohne dass eine arithmetische Operation ausgeführt werden muss.

Wenn die WhileSchleife endet, gibt die Funktion die Länge von aus t, die genau dem Quotienten der Ganzzahldivision entspricht. Somit ist die Anzahl der Ergänzungen für eine gegebenedivide[a,b] genau dem Quotienten.

100201 ist die Summe der Quotienten in der Tabelle 200 x 200. So oft cwurde um erhöht b. Es waren keine weiteren Ergänzungen erforderlich. Es wurden nur positive ganze Zahlen verwendet.

divide[a_, b_] := Module[{c = 0, t = {}}, While[c <= a, t = Append[t, c]; c += b]; 
Length[Rest@t]]

Es ist effizienter, eine Nachschlagetabelle zu erstellen, nach der jede Suche fast sofort erfolgt.

n = 200;
d[a_, b_] := Module[{c = 0, t = {}}, While[c <= a, t = Append[t, c]; c += b]; 
Length[Rest@t]]
quotients = PadRight[#, n] & /@ Table[d[i, j], {i, 1, n}, {j, 1, i}];
divide[a_, b_] := quotients[[a, b]]

Verwendungszweck

divide[97, 13]

7

DavidC
quelle
1
Also mehr oder weniger meine stringbasierte Lösung? Ohh, und kannst du die n++Sache erklären ? Sieht nach Ergänzung für mich aus.
Johannes Kuhn
1
Ja, die Nachfolgerfunktion zählt als Addition, ohne die es nicht erlaubt ist.
Joe Z.
@ Johannes Kuhn. Ich habe das entfernt n++, was völlig unnötig war. Nach allem, was ich sagen kann (ich kenne TCL nicht), ist meine Lösung wie Ihre, speichert die Elemente jedoch in mehreren Sätzen und nicht in Zeichenfolgen.
DavidC
1
Was ist mit no other data constructs besides numbers?
Ugoren
@Ugoren Glaubst du nicht, dass ein Basis-Eins-Zahlensystem sich mit Zahlen befasst? Ich denke, die fragliche Frage ist, ob das Beitreten das Hinzufügen darstellt oder nicht.
DavidC
1

R - 0 Addition

divide<-function(a,b){
    options(warn=-1)
    A<-matrix(1:b,nrow=a,ncol=1)
    length(split(A,A)[[b]])
    }

Verwendet R-Vektor-Recycling.
Die zweite Zeile erstellt eine Längenmatrix, adie von einem Längenvektor bgefüllt wird, der bis zum Erreichen der Länge recycelt wird a.
Die dritte Zeile teilt die Matrix nach ihrem Wert und gibt die Länge des letzten Elements zurück (daher das Ergebnis der ganzzahligen Division von adurch b).
Das Auffüllen einer Matrix mit einem Vektor, dessen Länge nicht ein Vielfaches der Länge der Matrix ist, löst eine Warnung aus. Wenn wir jedoch die Warnung vorher unterdrücken (Zeile 1), funktioniert dies.

Um ein konkretes Beispiel zu geben, wenn wir 5 durch 3 teilen, Awird ein Vektor sein, der 1 2 3 1 2 enthält (dh 1 2 3, recycelt auf eine Länge von 5). Das Ergebnis der Aufteilungsoperation ist eine Liste mit dem ersten Element, das 1 1, das zweite 2 2 und das dritte 3 enthält (da es nur eine 3 in gibt A). Das Ergebnis ist daher 1.

Planapus
quelle
Ein Matix klingt nach einer anderen Datenstruktur als eine Zahl.
Johannes Kuhn
Ah, in der Tat habe ich den Teil verpasst, in dem angegeben wurde, dass das einzige zulässige Datenkonstrukt Zahlen sind. Mein Fehler. Ich antwortete nach der Bearbeitung, las aber die Frage vorher :)
Planapus
1

In Ruby,

def divide(a,b)
  n, d = 'x' * a, 'x' * b
  l = []
  (l << 'x'; d << 'x' * b) while n.size >= d.size
  l.size
end

Ich kenne TCL nicht, aber ich vermute, dass dies der gleiche Ansatz ist wie die (erste) Antwort von @Johannes.

Cary Swoveland
quelle
Was machen die * und <<? Ich kenne Ruby nicht.
Joe Z.
@ Joe: d = 'x' * 5=> "xxxxx". a << bHängt String ban String an a. Hier d = "xxx"und d << 'x'führt zu d = "xxxx".
Cary Swoveland
1

Java: 92 987 Ergänzungen

Ich benutze die binäre Rekursion a/b == 2 * a/(2b) + maybe 1. Dafür werden Divisor und Rest benötigt. Normalerweise würde es eine Subtraktion a% (2b) - b geben, aber das wird gelöst, indem der Rest als gehalten wird (rem, remNegative). Und 2b = b+bnatürlich.

static int add_used;

static int add(int a, int b) {
    if (a == 0)
        return b;
    if (b == 0)
        return a;
    ++add_used;
    return a + b;
}

private static class DivRem {
    int div;
    int rem;
    int remNegative;

    DivRem(int div, int rem) {
        this.div = div;
        this.rem = rem;
    }
}

public static int divide(int a, int b) {
    add_used = 0;
    return divrem(a, b).div;
}

public static DivRem divrem(int a, int b) {
    if (b > a) {
        return new DivRem(0, a);
    }
    DivRem dr = divrem(a, add(b, b));
    dr.div = add(dr.div, dr.div);
    if (dr.rem >= add(b, dr.remNegative)) {
        dr.div = add(dr.div, 1);
        //dr.rem = add(dr.rem,  -b);
        dr.remNegative = add(dr.remNegative,  b);
    }
    return dr;
}

private static void test(int a, int b) {
    boolean okay = a/b == divide(a, b);
    System.out.printf("%d / %d = %d :: %d : #%d  %s%n", a, b, a/b,
        divide(a, b), add_used, okay);
}

public static void main(String[] args) {
   //test(2352, 324);
   int n = 0;
   for (int a = 1; a <= 200; ++a) {
       for (int b = 1; b <= a; ++b) {
           //test(a, b);
           divide(a, b);
           n += add_used;
       }
   }
   System.out.println("Additions: " + n);
}
Joop Eggen
quelle
Und wie viele Abteilungen verwendet es?
Türknauf
@ Doorknob 92987 (das For-For wurde nicht angezeigt).
Joop Eggen
Eine Bemerkung: Dies zählt weder 0 + x noch x + 0: also ~ 100.000 Additionen.
Joop Eggen
0 
//a lies between 1 and 200, b lies between 1 and a.

int divide(int a,int b){
int x=a,y=b;
int count=1;
while(y<x){
y+=y;
count++;
}
return count;
}
Dinesh Kumar P.
quelle
3
Und wie viele Ergänzungen gibt es?
Johannes Kuhn
0

C # - 0 Ergänzungen

using System.Collections.Generic;
using System.Linq;

static int Divide(int a, int b)
{
    var ints = new List<int>(a);
    while (ints.Count < a)
        ints.AddRange(Enumerable.Range(1, b));

    return ints.Select((x, i) => x == b && i < a).Count(x => x);
}

Füllt eine Liste von Ganzzahlen mit 1..bwiederholten aZeiten. Die Häufigkeit, mit der b(mit Ausnahme des Auftretens mit einem Index> a) angezeigt wird, ist das Ergebnis.

Ich bin mir nicht sicher, ob die Liste nach den Regeln zulässig ist, aber ich sende dies im Geiste der anderen Beiträge, die die Regeln nicht allzu ernst nehmen (schließlich wird die Verwendung von Addition überhaupt nicht umgangen insgesamt herausfordern).

Igby Largeman
quelle
Ja, dem "Geist" der Herausforderung zu folgen, wurde zu diesem Zeitpunkt so gut wie aufgegeben.
Joe Z.
Es gibt 1 Lösung, die alle Regeln ernst nimmt und 0 Ergänzungen enthält.
Johannes Kuhn
@ JohannesKuhn: Das ist umstritten. Die Herausforderung besteht darin, die Division durch Addition durchzuführen. Wenn wir keinen Zusatz verwenden, machen wir die Herausforderung nicht wirklich ...
Igby Largeman
0

C - 85591 Ergänzungen

Auf geht's. Ich denke, das könnte optimal sein. Es verwendet eine Technik der "umgekehrten Division", bei der durch lange Multiplikation die größte Zahl qso aufgebaut wird, dass q * b <= anur +und verwendet werden <=. Es ist sehr sehr schnell.

#include <stdio.h>
#include <assert.h>

// Division function.
q,u,v,z=0;s(a,b){return!a?b:!b?a:(z++,a+b);}
d(a,b,p){if((v=s(b,b))<=a)d(a,v,s(p,p));if((v=s(u,b))<=a)u=v,q=s(p,q);}
divide(a,b){u=q=0;d(a,b,1);return q;}

// Test driver.
main(){for(int a=1;a<=200;a++)for(int b=1;b<=a;b++)assert(divide(a,b)==q);
printf("%d additions\n",z);}

Anmerkungen:

  1. s(a,b)Gibt bei jeder Addition eine Zählervariable für Summe a+bund Inkremente zurück z. Wenn entweder aoder bNull ist, wird die unnötige Addition vermieden.
  2. d(a,b,p)ist eine rekursive Funktion zum Aufbau der internen Teile zum Vergleich und zur Addition. Es verwendet globale Variablen q, uund v. Die maximale Rekursionstiefe ist die Anzahl der Bits a, und die Rekursion ist eher linear als ein Baum. (Beachten Sie dasb in dieser Funktion ist das Original bmultipliziert mit einer Potenz von 2.)
  3. divide(a,b) gibt den Boden (a / b) nach Bedarf zurück.
  4. Kompiliert mit Warnungen (da der Code Golf ist). Läuft gut.
Todd Lehman
quelle
0

J, 0 Ergänzungen, 14 Bytes

Inspiriert von Alexei Kopylovs Antwort .

f=:[{]#i.@>:@[

Verwendet überhaupt keine Mathematik:

f=:                    NB. define function f
             [         NB. take left argument,
          >:@          NB. increment it,
       i.@             NB. generate the list [0..left arg+1)
     ]#                NB. replicate each item in the list by the right argument
                       NB. (so if ]=2, list becomes 0 0 1 1 2 2 3 3 ...)
   [{                  NB. select the ['th item from that list.
Marinus
quelle