Divisi integer dengan sisa dalam JavaScript?

Dalam JavaScript , bagaimana saya mendapatkan:

1. Berapa kali integer yang diberikan masuk ke integer lain?
2. Pengingat?

Untuk beberapa nomor ydan beberapa pembagi xmenghitung hasil bagi ( quotient) dan sisanya ( remainder) sebagai:

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

Saya bukan ahli dalam operator bitwise, tapi inilah cara lain untuk mendapatkan seluruh nomor:

var num = ~~(a / b);

Ini akan bekerja dengan baik untuk angka negatif juga, sementara Math.floor()akan membulatkan arah yang salah.

Ini tampaknya benar juga:

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

Saya melakukan beberapa tes kecepatan di Firefox.

-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

Di atas didasarkan pada 10 juta percobaan untuk masing-masing.

Kesimpulan: Gunakan (a/b>>0)(atau (~~(a/b))atau (a/b|0)) untuk mencapai efisiensi sekitar 20%. Juga perlu diingat bahwa mereka semua tidak konsisten dengan Math.floor, kapan a/b<0 && a%b!=0.

ES6 memperkenalkan Math.truncmetode baru . Ini memungkinkan untuk memperbaiki jawaban @ MarkElliot untuk membuatnya berfungsi untuk angka negatif juga:

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

Perhatikan bahwa Mathmetode memiliki keunggulan dibandingkan operator bitwise yang mereka gunakan dengan angka di atas 2 ³¹ .

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

Saya biasanya menggunakan:

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

Ini mungkin bukan yang paling elegan, tetapi berhasil.

Anda dapat menggunakan fungsi ini parseIntuntuk mendapatkan hasil yang terpotong.

parseInt(a/b)

Untuk mendapatkan sisanya, gunakan mod operator:

a%b

parseInt memiliki beberapa perangkap dengan string, untuk menghindari penggunaan parameter radix dengan basis 10

parseInt("09", 10)

Dalam beberapa kasus representasi string nomor dapat menjadi notasi ilmiah, dalam hal ini, parseInt akan menghasilkan hasil yang salah.

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

Panggilan ini akan menghasilkan 1 sebagai hasilnya.

JavaScript menghitung dengan tepat lantai bilangan negatif dan sisa bilangan non-integer, mengikuti definisi matematika untuknya.

LANTAI didefinisikan sebagai "bilangan bulat terbesar yang lebih kecil dari parameter", dengan demikian:

• angka positif: FLOOR (X) = bilangan bulat bagian X;
• angka negatif: FLOOR (X) = bilangan bulat bagian X minus 1 (karena itu harus KECIL daripada parameter, yaitu, lebih negatif!)

REMAINDER didefinisikan sebagai "sisa" dari suatu divisi (Euclidean arithmetic). Ketika dividen bukan bilangan bulat, hasil bagi biasanya juga bukan bilangan bulat, yaitu, tidak ada sisa, tetapi jika hasil bagi dipaksa menjadi bilangan bulat (dan itulah yang terjadi ketika seseorang mencoba untuk mendapatkan sisa atau modulus dari suatu angka floating-point), akan ada "sisa" non-integer, jelas.

JavaScript memang menghitung semuanya seperti yang diharapkan, sehingga programmer harus berhati-hati untuk mengajukan pertanyaan yang tepat (dan orang-orang harus berhati-hati untuk menjawab apa yang ditanyakan!) Pertanyaan pertama Yarin bukanlah "apa pembagian bilangan X dengan Y", tapi, sebagai gantinya, "SELURUH berapa kali bilangan bulat yang diberikan PERGI ke yang lain". Untuk bilangan positif, jawabannya adalah sama untuk keduanya, tetapi tidak untuk bilangan negatif, karena pembagian bilangan bulat (dividen dengan pembagi) akan -1 lebih kecil daripada kali angka (pembagi) "masuk ke" yang lain (dividen). Dengan kata lain, FLOOR akan mengembalikan jawaban yang benar untuk pembagian bilangan bulat dari angka negatif, tetapi Yarin tidak menanyakan itu!

gammax menjawab dengan benar, kode itu berfungsi seperti yang diminta oleh Yarin. Di sisi lain, Samuel salah, dia tidak menghitung, kurasa, atau dia akan melihat bahwa itu berhasil (juga, dia tidak mengatakan apa yang menjadi pembagi dari teladannya, tetapi saya berharap itu adalah 3):

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

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

By the way, saya menguji kode pada Firefox 27.0.1, itu berfungsi seperti yang diharapkan, dengan angka positif dan negatif dan juga dengan nilai-nilai non-integer, baik untuk dividen dan pembagi. Contoh:

-100.34 / 3.57: GoesInto = -28, Sisa = -0.380000000000000079

Ya, saya perhatikan, ada masalah presisi di sana, tapi saya tidak punya waktu untuk memeriksanya (saya tidak tahu apakah itu masalah dengan Firefox, Windows 7 atau dengan FPU CPU saya). Namun untuk pertanyaan Yarin, yang hanya melibatkan bilangan bulat, kode gammax berfungsi dengan baik.

Math.floor(operation) mengembalikan nilai pembulatan operasi.

Contoh 1 ^st pertanyaan:

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

console.log(z);

Menghibur:

15

Contoh 2 ^nd pertanyaan:

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

console.log(x);

Menghibur:

4

Menghitung jumlah halaman dapat dilakukan dalam satu langkah: Math.ceil (x / y)

Komentar Alex Moore-Niemi sebagai jawaban:

Untuk Rubyist di sini dari Google dalam pencarian divmod, Anda dapat mengimplementasikannya seperti:

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

Hasil:

// [2, 33]

Jika Anda hanya membagi dengan kekuatan dua, Anda dapat menggunakan operator bitwise:

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

(Yang pertama adalah hasil bagi, yang kedua sisanya)

Anda dapat menggunakan ternary untuk memutuskan bagaimana menangani nilai integer positif dan negatif juga.

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

Jika angkanya positif, semuanya baik-baik saja. Jika angkanya negatif, itu akan menambah 1 karena cara Math.floor menangani negatif.

Ini akan selalu terpotong menuju nol. Tidak yakin apakah sudah terlambat, tapi begini saja:

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

Jika Anda perlu menghitung sisanya untuk bilangan bulat yang sangat besar, yang runtime JS tidak dapat wakili seperti itu (bilangan bulat lebih besar dari 2 ^ 32 diwakili sebagai float dan karena itu kehilangan presisi), Anda perlu melakukan beberapa trik.

Ini sangat penting untuk memeriksa banyak kasus digit cek yang ada dalam banyak contoh kehidupan sehari-hari kita (nomor rekening bank, kartu kredit, ...)

Pertama-tama Anda memerlukan nomor Anda sebagai string (jika tidak, Anda telah kehilangan presisi dan sisanya tidak masuk akal).

str = '123456789123456789123456789'

Anda sekarang harus memisahkan string Anda menjadi bagian-bagian yang lebih kecil, cukup kecil sehingga rangkaian sisa dan seutas tali dapat muat dalam 9 digit.

digits = 9 - String(divisor).length

Persiapkan ekspresi reguler untuk memisahkan string

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

Misalnya, jika digits7, regexp adalah

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

Ini cocok dengan nonempty substring dengan panjang maksimum 7, yang diikuti ( (?=...)adalah lookahead positif) oleh sejumlah karakter yang kelipatan dari 7. The 'g' adalah untuk membuat ekspresi dijalankan melalui semua string, tidak berhenti pada pertandingan pertama.

Sekarang konversikan setiap bagian menjadi bilangan bulat, dan hitung sisanya dengan reduce(menambahkan kembali sisa sebelumnya - atau 0 - dikalikan dengan kekuatan 10 yang benar):

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

Ini akan berfungsi karena algoritme sisa "pengurangan":

n mod d = (n - kd) mod d

yang memungkinkan untuk mengganti 'bagian awal' dari representasi desimal dari angka dengan sisanya, tanpa mempengaruhi sisa akhir.

Kode akhir akan terlihat seperti:

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