Hoe een integer-divisie uitvoeren, en ontvang de rest, in JavaScript?

In JavaScript , hoe krijg ik:

1. Het geheel aantal malen een gegeven geheel getal gaat in de andere?
2. de rest?

Antwoord 1, Autoriteit 100%

Voor een bepaald nummer yEN SOMMIGE DIVISOR xBereken het quotiënt (quotient) en RESTER (remainder) AS:

var quotient = Math.floor(y/x);
var remainder = y % x;

Antwoord 2, Autoriteit 29%

Ik ben geen expert in bitwise-operators, maar hier is een andere manier om het hele nummer te krijgen:

var num = ~~(a / b);

Hiermee werkt u ook op de juiste manier voor negatieve getallen, terwijl Math.floor()in de verkeerde richting ronddraaien.

Dit lijkt ook correct:

var num = (a / b) >> 0;

Antwoord 3, Autoriteit 17%

Ik heb wat snelheidstests op Firefox gedaan.

-100/3             // -33.33..., 0.3663 millisec
Math.floor(-100/3) // -34,       0.5016 millisec
~~(-100/3)         // -33,       0.3619 millisec
(-100/3>>0)        // -33,       0.3632 millisec
(-100/3|0)         // -33,       0.3856 millisec
(-100-(-100%3))/3  // -33,       0.3591 millisec
/* a=-100, b=3 */
a/b                // -33.33..., 0.4863 millisec
Math.floor(a/b)    // -34,       0.6019 millisec
~~(a/b)            // -33,       0.5148 millisec
(a/b>>0)           // -33,       0.5048 millisec
(a/b|0)            // -33,       0.5078 millisec
(a-(a%b))/b        // -33,       0.6649 millisec

Het bovenstaande is gebaseerd op 10 miljoen proeven voor elk.

Conclusie:gebruik (a/b>>0)(of (~~(a/b))of (a/b|0)) om ongeveer 20% efficiëntiewinst te behalen. Houd er ook rekening mee dat ze allemaal niet consistent zijn met Math.floor, wanneer a/b<0 && a%b!=0.

Antwoord 4, autoriteit 14%

ES6 introduceert de nieuwe Math.truncmethode. Dit maakt het mogelijk om @MarkElliot’s antwoordte corrigeren om het ook voor negatieve getallen te laten werken:

var div = Math.trunc(y/x);
var rem = y % x;

Merk op dat Math-methoden het voordeel hebben ten opzichte van bitsgewijze operatoren dat ze werken met getallen groter dan 2³¹.

Antwoord 5, autoriteit 2%

var remainder = x % y;
return (x - remainder) / y;

Antwoord 6, autoriteit 2%

Normaal gebruik ik:

const quotient =  (a - a % b) / b;
const remainder = a % b;

Het is waarschijnlijk niet de meest elegante, maar het werkt.

Antwoord 7

Je kunt de functie parseIntgebruiken om een afgekapt resultaat te krijgen.

parseInt(a/b)

Gebruik de mod-operator om een rest te krijgen:

a%b

parseInt heeft enkele valkuilen met strings, om te voorkomen dat je de radix-parameter met grondtal 10 gebruikt

parseInt("09", 10)

In sommige gevallen kan de tekenreeksrepresentatie van het getal een wetenschappelijke notatie zijn, in dit geval zal parseInt een verkeerd resultaat opleveren.

parseInt(100000000000000000000000000000000, 10) // 1e+32

Deze oproep levert 1 op.

Antwoord 8

Math.floor(operation)retourneert de naar beneden afgeronde waarde van de bewerking.

Voorbeeld van 1^evraag:

var x = 5;
var y = 10.4;
var z = Math.floor(x + y);
console.log(z);

Console:

15

Voorbeeld van 2^evraag:

var x = 14;
var y = 5;
var z = Math.floor(x%y);
console.log(x);

Console:

4

Antwoord 9

JavaScript berekent precies de bodem van negatieve getallen en de rest van niet-gehele getallen, volgens de wiskundige definities ervoor.

FLOOR wordt gedefinieerd als “het grootste gehele getal kleiner dan de parameter”, dus:

• positieve getallen: FLOOR(X)=geheel deel van X;
• negatieve getallen: FLOOR(X)=geheel deel van X min 1 (omdat het KLEINER moet zijn dan de parameter, d.w.z. negatiever!)

De rest wordt gedefinieerd als de “overblijvende” van een divisie (Euclidische rekenkunde). Wanneer het dividend geen geheel getal is, is het quotiënt meestal ook geen geheel getal, dat wil zeggen, er is geen rest, maar als het quotiënt wordt gedwongen een geheel getal te zijn (en dat is wat er gebeurt wanneer iemand de rest of modulus van een gebeurt. drijvend nummer), er is een niet-integer “overgebleven”, uiteraard.

JavaScript berekent alles zoals verwacht, dus de programmeur moet voorzichtig zijn om de juiste vragen te stellen (en mensen moeten voorzichtig zijn om te antwoorden wat wordt gevraagd!) Yarin’s eerste vraag was niet “Wat is de integer-divisie van x door y” , maar in plaats daarvan, “het hele aantal keren een gegeven geheel getal in een andere”. Voor positieve nummers is het antwoord hetzelfde voor beide, maar niet voor negatieve getallen, omdat de integer-divisie (dividend door deelnemer) -1 kleiner is dan de tijden (divisor) “in” een ander (dividend). Met andere woorden, vloer zal het juiste antwoord retourneren voor een integer-divisie van een negatief getal, maar Yarin heeft dat niet gevraagd!

Gammax beantwoord correct, die code werkt als gevraagd door Yarin. Aan de andere kant is Samuel verkeerd, hij deed de wiskunde niet, denk ik, of hij zou hebben gezien dat het werkt (ook, hij zei niet wat de deler van zijn voorbeeld was, maar ik hoop dat het het was 3):

rest = x% y = -100% 3 = -1

goesinto = (x – resten) / y = (-100 – -1) / 3 = -99 / 3 = -33

Trouwens, ik heb de code getest op Firefox 27.0.1, het werkte zoals verwacht, met positieve en negatieve getallen en ook met niet-gehele getalwaarden, zowel voor dividend als deler. Voorbeeld:

-100.34 / 3.57: Goesinto = -28, rest = -0.3800000000000079

Ja, ik heb gemerkt dat er een precisieprobleem is, maar ik had geen tijd om het te controleren (ik weet niet of het een probleem is met Firefox, Windows 7 of met de FPU van mijn CPU). Voor Yarin’s vraag, waarbij alleen gehele getallen betrokken zijn, werkt de gammax-code echter perfect.

Antwoord 10

Alex Moore-Niemi‘s reactie als antwoord:

Voor Rubyists hier van Google op zoek naar divmod, je kunt het als zodanig implementeren:

function divmod(x, y) {
  var div = Math.trunc(x/y);
  var rem = x % y;
  return [div, rem];
}

Resultaat:

// [2, 33]

Antwoord 11

const idivmod = (a, b) => [a/b |0, a%b];

er wordt ook aan een voorstel gewerkt
Modulus en aanvullende integere wiskunde

Antwoord 12

Als je gewoon deelt met machten van twee, kun je bitsgewijze operatoren gebruiken:

export function divideBy2(num) {
  return [num >> 1, num & 1];
}
export function divideBy4(num) {
  return [num >> 2, num & 3];
}
export function divideBy8(num) {
  return [num >> 3, num & 7];
}

(De eerste is het quotiënt, de tweede de rest)

Antwoord 13

Het aantal pagina’s berekenen kan in één stap:
Math.ceil(x/y)

Antwoord 14

U kunt ternary gebruiken om te beslissen hoe u ook positieve en negatieve gehele getallen wilt verwerken.

var myInt = (y > 0) ? Math.floor(y/x) : Math.floor(y/x) + 1

Als het getal positief is, is alles in orde. Als het getal negatief is, wordt er 1 toegevoegd vanwege de manier waarop Math.floor negatieven verwerkt.

Antwoord 15

Dit wordt altijd afgekapt richting nul.
Ik weet niet zeker of het te laat is, maar hier komt het:

function intdiv(dividend, divisor) { 
    divisor = divisor - divisor % 1;
    if (divisor == 0) throw new Error("division by zero");
    dividend = dividend - dividend % 1;
    var rem = dividend % divisor;
    return { 
        remainder: rem, 
        quotient: (dividend - rem) / divisor
    };
}

Antwoord 16

Als u de rest moet berekenen voor zeer grote gehele getallen, die de JS-runtime niet als zodanig kan weergeven (elk geheel getal groter dan 2^32 wordt weergegeven als een float en verliest dus precisie), moet u een trucje uithalen.

Dit is vooral belangrijk voor het controleren van veel controlecijfers die in veel gevallen van ons dagelijks leven voorkomen (bankrekeningnummers, creditcards, …)

Allereerst heb je je nummer als string nodig (anders ben je de precisie al kwijt en de rest slaat nergens op).

str = '123456789123456789123456789'

Je moet nu je string in kleinere delen splitsen, klein genoeg zodat de aaneenschakeling van een rest en een stuk string in 9 cijfers past.

digits = 9 - String(divisor).length

Bereid een reguliere expressie voor om de tekenreeks te splitsen

splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g')

Als digitsbijvoorbeeld 7 is, is de regexp

/.{1,7}(?=(.{7})+$)/g

Het komt overeen met een niet-lege subtekenreeks van maximale lengte 7, die wordt gevolgd ((?=...)is een positieve vooruitblik) door een aantal tekens dat een veelvoud is van 7. De ‘g ‘ is om de uitdrukking door alle tekenreeksen te laten lopen en niet te stoppen bij de eerste overeenkomst.

Converteer nu elk deel naar een geheel getal en bereken de resten door reduce(de vorige rest optellen – of 0 – vermenigvuldigd met de juiste macht van 10):

reducer = (rem, piece) => (rem * Math.pow(10, digits) + piece) % divisor

Dit werkt vanwege het “aftrekken” restalgoritme:

n mod d = (n - kd) mod d

waarmee het ‘begingedeelte’ van de decimale weergave van een getal kan worden vervangen door de rest, zonder de laatste rest te beïnvloeden.

De uiteindelijke code ziet er als volgt uit:

function remainder(num, div) {
  const digits = 9 - String(div).length;
  const splitter = new RegExp(`.{1,${digits}}(?=(.{${digits}})+$)`, 'g');
  const mult = Math.pow(10, digits);
  const reducer = (rem, piece) => (rem * mult + piece) % div;
  return str.match(splitter).map(Number).reduce(reducer, 0);
}

Antwoord 17

Hier is een manier om dit te doen. (Persoonlijk zou ik het niet op deze manier doen, maar ik vond het een leuke manier om het bijvoorbeeld te doen)

function intDivide(numerator, denominator) {
  return parseInt((numerator/denominator).toString().split(".")[0]);
}
let x = intDivide(4,5);
let y = intDivide(5,5);
let z = intDivide(6,5);
console.log(x);
console.log(y);
console.log(z);

function integerDivison(dividend, divisor){
        this.Division  = dividend/divisor;
        this.Quotient = Math.floor(dividend/divisor);
         this.Remainder = dividend%divisor;
        this.calculate = ()=>{
            return {Value:this.Division,Quotient:this.Quotient,Remainder:this.Remainder};
        }
    }
  var divide = new integerDivison(5,2);
  console.log(divide.Quotient)      //to get Quotient of two value 
  console.log(divide.division)     //to get Floating division of two value 
  console.log(divide.Remainder)     //to get Remainder of two value 
  console.log(divide.calculate())   //to get object containing all the values