JavaScript'te kalanla tamsayı bölümü?

In JavaScript , nasıl alabilirim:

1. Belirli bir tamsayının diğerine kaç kez girdiği?
2. Kalan?

Bir sayı yve bazı bölen xiçin ( quotient) ve kalan ( remainder) bölümünü şu şekilde hesaplayın :

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

Bitsel operatörler konusunda uzman değilim, ancak tüm sayıyı almanın başka bir yolu:

var num = ~~(a / b);

Bu, negatif sayılar için de düzgün çalışacak Math.floor(), yanlış yönde yuvarlanacaktır.

Bu da doğru görünüyor:

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

Firefox'ta bazı hız testleri yaptım.

-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

Yukarıda belirtilenler her biri için 10 milyon denemeye dayanmaktadır.

Sonuç: Kullanım (a/b>>0)(veya (~~(a/b))veya (a/b|0)) verimliliğinde 20 yaklaşık% kazancı elde etmek. Ayrıca, bunların Math.floorne zaman tutarsız olduklarını da unutmayın a/b<0 && a%b!=0.

ES6 yeni Math.truncyöntemi tanıttı . Bu, @ MarkElliot'un cevabını negatif sayılar için de çalışmasını sağlamak için düzeltmeye izin verir :

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

MathYöntemlerin, 2 ³¹ üzerindeki sayılarla çalıştıkları bitsel işleçlere göre avantajları olduğunu unutmayın .

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

Normalde kullanıyorum:

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

Muhtemelen en zarif değil, ama işe yarıyor.

parseIntKesilmiş bir sonuç elde etmek için işlevi kullanabilirsiniz .

parseInt(a/b)

Geriye kalanları almak için mod operatörünü kullanın:

a%b

parseInt, taban 10 ile radix parametresini kullanmaktan kaçınmak için dizeleri olan bazı tuzaklar var

parseInt("09", 10)

Bazı durumlarda, sayının dize temsili bilimsel bir gösterim olabilir, bu durumda parseInt yanlış bir sonuç üretecektir.

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

Bu çağrı sonuç olarak 1 üretecektir.

JavaScript, negatif sayıların tabanını ve tamsayı olmayan sayıların kalanını hesaplar ve matematiksel tanımları izler.

FLOOR, "parametreden daha küçük en büyük tam sayı" olarak tanımlanır, bu nedenle:

• pozitif sayılar: FLOOR (X) = X'in tamsayı kısmı;
• negatif sayılar: FLOOR (X) = X eksi 1'in tamsayı kısmı (çünkü parametreden KÜÇÜK olmalıdır, yani daha negatif!)

HATIRLATMA, bir bölümün (Öklid aritmetiği) "geride bırakılması" olarak tanımlanır. Temettü bir tamsayı olmadığında, bölüm genellikle bir tamsayı değildir, yani, kalan yoktur, ancak bölüm bir tamsayı olmaya zorlanırsa (ve birisi bir kişinin kalanını veya modülünü almaya çalıştığında bu olur kayan nokta sayısı), açık bir şekilde tamsayı olmayan bir "kalan" olacaktır.

JavaScript her şeyi beklendiği gibi hesaplar, bu nedenle programcı doğru soruları sormaya dikkat etmelidir (ve insanlar sorulan soruları cevaplamaya dikkat etmelidir!) Yarin'in ilk sorusu "X'in Y'nin tamsayı bölümü nedir" DEĞİLDİR, ancak, bunun yerine, "belirli bir tamsayının bir başkasına GİRİŞ sayısı". Pozitif sayılar için, cevap her ikisi için de aynıdır, ancak negatif sayılar için aynı değildir, çünkü tamsayı bölümü (bölenle temettü), bir sayının (bölen) "diğerine" (temettü) "gittiği zamandan -1 daha küçük olacaktır. Başka bir deyişle, FLOOR negatif bir sayının tamsayı bölümü için doğru cevabı döndürecektir, ancak Yarin bunu sormadı!

gammax doğru cevap verdi, bu kod Yarin tarafından istendiği gibi çalışıyor. Öte yandan Samuel yanılıyor, matematik yapmadı, sanırım ya da işe yaradığını görürdü (ayrıca, örneğinin böleninin ne olduğunu söylemedi, ama umarım öyleydi 3):

Kalan = X% Y = -100% 3 = -1

= (X - Kalan) / Y = (-100 - -1) / 3 = -99 / 3 = -33

Bu arada, Firefox 27.0.1'deki kodu test ettim, beklendiği gibi pozitif ve negatif sayılarla ve hem temettü hem de bölen için tamsayı olmayan değerlerle çalıştı. Misal:

-100.34 / 3.57: Gidiyor = -28, Kalan = -0.3800000000000079

Evet, fark ettim, orada hassas bir sorun var, ama kontrol etmek için zamanım olmadı (Firefox, Windows 7 veya CPU'mun FPU'su ile ilgili bir sorun olup olmadığını bilmiyorum). Ancak Yarin'in sadece tamsayıları içeren sorusu için gammax'ın kodu mükemmel çalışıyor.

Math.floor(operation) işlemin yuvarlanmış değerini döndürür.

1 Örnek ^st sorusuna:

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

console.log(z);

Konsol:

15

^2. soru örneği :

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

console.log(x);

Konsol:

4

Sayfa sayısını hesaplama tek bir adımda yapılabilir: Math.ceil (x / y)

Alex Moore-Niemi'nin bir cevap olarak yorumu:

Burada arama yapan Google'dan Rubyistler için divmodbunu şu şekilde uygulayabilirsiniz:

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

Sonuç:

// [2, 33]

Sadece iki güçle bölüyorsanız, bitsel operatörleri kullanabilirsiniz:

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

(Birincisi bölüm, ikincisi kalan)

Pozitif ve negatif tamsayı değerlerinin nasıl ele alınacağına karar vermek için üçlü kullanabilirsiniz.

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

Sayı pozitifse, her şey yolunda demektir. Sayı negatifse, Math.floor negatifleri nasıl işlediğinden 1 ekler.

Bu her zaman sıfıra doğru kesilir. Çok geç olup olmadığından emin değilim, ama işte gidiyor:

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

JS çalışma zamanının böyle gösteremediği çok büyük tamsayıların kalanını hesaplamanız gerekiyorsa (2 ^ 32'den büyük herhangi bir tam sayı bir kayan nokta olarak gösterilir ve bu nedenle kesinlik kaybeder), biraz hile yapmanız gerekir.

Bu, günlük hayatımızın birçok örneğinde (banka hesap numaraları, kredi kartları, ...) bulunan birçok kontrol basamağı durumunu kontrol etmek için özellikle önemlidir.

Her şeyden önce numaranızı bir dize olarak ihtiyacınız var (aksi takdirde zaten kesinlik kaybettiniz ve geri kalanı mantıklı değil).

str = '123456789123456789123456789'

Artık dizenizi, daha küçük parçalara ayırmanız gerekir, böylece kalanların ve bir dizenin birleştirilmesi 9 haneye sığabilir.

digits = 9 - String(divisor).length

Dizeyi bölmek için normal bir ifade hazırlama

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

Örneğin digits, 7 ise normal ifade

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

Maksimum uzunluğu 7 olan boş olmayan bir alt dize ile eşleşir (bunu (?=...)pozitif bir ileriye doğru) ve 7'den daha fazla sayıda karakter takip eder. 'G' ifadesi, ilk eşleşmede durmadan tüm dizgiden geçmesini sağlamaktır.

Şimdi her bir parçayı tamsayıya dönüştürün ve kalanları hesaplayın reduce(önceki geri kalanı - veya 0 - 10'un doğru gücüyle çarparak):

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

Bu, "çıkarma" kalan algoritması nedeniyle çalışacaktır:

n mod d = (n - kd) mod d

bu, son sayıyı etkilemeden bir sayının ondalık gösteriminin herhangi bir 'başlangıç ​​kısmının' geri kalanı ile değiştirilmesine izin verir.

Son kod şöyle görünecektir:

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