Rumah > Artikel > hujung hadapan web > Bagaimana untuk menyelesaikan masalah ingatan timbunan JavaScript untuk mencari nombor perdana?

Bagaimana untuk menyelesaikan masalah ingatan timbunan JavaScript untuk mencari nombor perdana?

王林ke hadapan: 2023-08-27 18:01:021255semak imbas

Seperti yang ditunjukkan oleh mesej ralat "Out of Heap", ralat ini berlaku apabila mana-mana kod JavaScript menggunakan lebih banyak memori daripada yang diperuntukkan. Apabila kami menjalankan sebarang program JavaScript, komputer memperuntukkan memori khusus untuk program JavaScript.

Apabila kami menjalankan kod dalam JavaScript atau mana-mana bahasa pengaturcaraan, komputer mencipta proses dan memperuntukkan jumlah memori yang tetap. Apabila atur cara memerlukan lebih banyak ruang memori, ia membuang ralat seperti keluar dari ingatan timbunan. Sebagai contoh, jika kita mencipta tatasusunan bersaiz 1020 dan cuba memulakan setiap indeks tatasusunan dengan nilai tertentu, timbunan akan kehabisan memori dan membuang ralat.

Dalam tutorial ini, kita akan belajar cara menyelesaikan isu kehabisan memori timbunan JavaScript apabila mencari faktor utama set nilai yang sangat besar.

Pengguna boleh mengikuti contoh berikut untuk menggambarkan ralat limpahan timbunan.

Contoh (kesilapan visualisasi)

Dalam contoh di bawah, kami telah mencipta fungsi getPrimeFactors() yang mengembalikan faktor perdana bagi sebarang nombor. Apabila kita melepasi nilai kecil (hampir 10³) ia berfungsi dengan sempurna, tetapi apabila kita melepasi nilai besar (hampir 10⁹) sebagai hujah untuk mencari faktor utama, ia memberikan ralat, Dan tetingkap penyemak imbas menjadi skrin hitam.

Dalam contoh ini, memandangkan kami menggunakan dua gelung bersarang untuk mengulangi tatasusunan, ralat memori berlaku dan kerumitan masa program menjadi O(N²), iaitu lebih daripada memori yang diperuntukkan.

<html>
<body>
   <h2>Visualizing the <i>Process out of memory</i> while finding all prime factors of a number in JavaScript </h2>
</body>
<script>
   try {
      function getPrimeFactors(num) {
         var factor = []; 
         let primes = [];
         for (let m = 2; m <= num; m++) {
            if (!factor[m]) {
               primes.push(m);
               for (let n = m << 1; n <= num; n += m) {
                  factor[n] = true;
               }
            }
         }
         return primes;
      }
      getPrimeFactors(1212121212323)
   } catch (err) {
      console.log(err.message)
   }
</script>
</html>

Dalam output contoh di atas, pengguna boleh melihat ralat limpahan timbunan. Untuk menyingkirkan masalah ini, kita perlu mengoptimumkan kerumitan masa dan ruang kod.

Di bawah, kami akan mengoptimumkan kerumitan masa kod dalam Contoh 1 untuk mencari semua faktor perdana unik bagi nombor tertentu.

Tatabahasa

Pengguna boleh menulis kod yang dioptimumkan mengikut sintaks berikut untuk mencari faktor perdana unik bagi nilai berangka yang diberikan.

for (let m = 2; m * m <= value; m++) {
   if (value % m === 0) {
      
      // store factor to array
      while (value % m === 0) {
         value /= m;
      }
   }
}
if (value > 2) {
   
   // store factor to array
}

Dalam sintaks di atas, kami menggunakan gelung for untuk berulang sehingga m*m kurang daripada nilai. Ini bermakna kita mengulang sehingga punca kuasa dua nilai lebih besar daripada m.

Langkah

Langkah 1 − Gunakan gelung for untuk lelaran sehingga punca kuasa dua nilai lebih besar daripada m, dengan m ialah pembolehubah permulaan bagi gelung for.

Langkah 2 - Dalam gelung for, jika nilai boleh dibahagi dengan m, maka ia bermakna m ialah faktor perdana bagi nilai dan simpannya dalam tatasusunan faktor.

Langkah 3 − Selepas ini, bahagikan nilai dengan m dan gunakan gelung sementara untuk membahagi dengan m beberapa kali, jika ia boleh dibahagikan beberapa kali. Di sini, kita perlu menyimpan faktor perdana yang unik, jadi kita hanya menyimpan nilai m sekali dalam tatasusunan.

Langkah 4 - Setelah semua lelaran gelung for selesai, semak jika nilainya lebih besar daripada 2. Jika ya, ini bermakna nilai itu ialah faktor perdana terbesar dan menyimpannya dalam tatasusunan.

Contoh (menyelesaikan kesilapan)

Contoh di bawah menggunakan tatasusunan untuk menyimpan faktor perdana. Tambahan pula, kami telah melaksanakan algoritma di atas untuk mencari faktor utama.

Pengguna boleh cuba mencari faktor utama yang unik dengan nilai yang besar (cth. 1020) dan melihat sama ada kod tersebut dapat dikeluarkan tanpa sebarang ralat.

<html>
<body>
   <h2>Solving the <i> Process out of memory </i> while finding all prime factors of a number in JavaScript</h2>
   <div id = "output"> </div>
</body>
<script>
   let output = document.getElementById('output');
   function getPrimeFactors(value) {
      let initial = value;
      var factors = [];
      for (let m = 2; m * m <= value; m++) {

         // if the value is divisible by m, it is a prime factor
         if (value % m === 0) {
            factors.push(m);

            // divide value by m until it is divisible
            while (value % m === 0) {
               value /= m;
            }
         }
      }

      // push largest prime factor at last
      if (value > 2) {
         factors.push(value); 
      }
      output.innerHTML += "The prime factors of " + initial + " are : " + factors + "<br/>";
   }
   getPrimeFactors(100000000002);
   getPrimeFactors(65416841658746141122);
</script>
</html>

Terjemahan bahasa Cina bagi

Contoh

ialah:

Contoh

Dalam contoh di bawah, kami telah menggunakan set untuk menyimpan faktor perdana dan bukannya menggunakan tatasusunan kerana kami perlu mendapatkan faktor perdana yang unik. Selain itu, kami menggunakan gelung for-of untuk mencetak semua faktor utama yang disimpan dalam set.

<html>
<body>
   <h2>Solving the <i> Process out of memory </i> while finding all prime factors of a number in JavaScript</h2>
   <div id = "output"> </div>
</body>
<script>
   let output = document.getElementById('output');
   function getPrimeFactors(value) {
      let initial = value;
      var factors = new Set();
      for (let m = 2; m * m <= value; m++) {
         if (value % m === 0) {
            factors.add(m);
            while (value % m === 0) {
               value /= m;
            }
         }
      }
      if (value > 2) {
         factors.add(value);
      }
      output.innerHTML += "The prime factors of " + initial + " are : <br/>";

      // print values of a set
      for (let fac of factors) {
         output.innerHTML += fac + "<br/>";
      }
   }
   getPrimeFactors(44352747207453165);
</script>
</html>

Kami belajar menyelesaikan ralat limpahan timbunan apabila mencari faktor perdana bagi sesuatu nombor. Setiap kali kami menghadapi ralat seperti limpahan timbunan, kami perlu mengoptimumkan kod kami seperti yang telah kami lakukan dalam tutorial ini.

Atas ialah kandungan terperinci Bagaimana untuk menyelesaikan masalah ingatan timbunan JavaScript untuk mencari nombor perdana?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

JavaScript for while 循环堆算法

Kenyataan：

Artikel ini dikembalikan pada:tutorialspoint.com. Jika ada pelanggaran, sila hubungi admin@php.cn Padam

Artikel sebelumnya：Perbezaan antara fungsi indexOf dan findIndexArtikel seterusnya：Perbezaan antara fungsi indexOf dan findIndex

Artikel berkaitan

Lihat lagi