عرض مصدر Algorithms/prime numbers

<noinclude>{{DISPLAYTITLE:الأعداد الأولية}}</noinclude>
العدد الأولي هو عدد يكون أكبر من 1 ويقبل القسمة على 1 وعلى نفسه فقط.

هناك عدة طرق للتحقق من كون العدد المعطى عددًا أوّليًّا أو لا.

== الخوارزمية البسيطة ==

إن أبسط طريقة للكشف عن كون عدد معيّن (ليكن <code>n</code>) عددًا أوليًا هي في المرور على جميع الأرقام ضمن النطاق <code>2</code> و <code>n-1</code>، ونتحقق عند كل عدد ممّا إذا كان ذلك العدد يقسم <code>n</code> دون باقٍ، فإذا وجد مثل هذا الرقم تعيد الدالة قيمة خاطئة ويكون العدد عددًا غير أولي.

تعرض الأمثلة التالية طريقة تنفيذ هذه الخوارزمية:

* C++‎:

<source lang="c++">#include <bits/stdc++.h> 
using namespace std; 

bool isPrime(int n) 
{ 
	// إن كان العدد المعطى أقل من 1 أو يساويه تعيد الدالة قيمة خاطئة
	if (n <= 1) 
		return false; 

	// n - 1 التحقق ضمن النطاق 2 و
	for (int i = 2; i < n; i++) 
		if (n % i == 0) 
			return false; 

	return true; 
} 

// اختبار الدالة السابقة
int main() 
{ 
	isPrime(11) ? cout << " true\n" : 
				cout << " false\n"; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">def isPrime(n): 
	
	# إن كان العدد المعطى أقل من 1 أو يساويه تعيد الدالة قيمة خاطئة
	if (n <= 1): 
		return False

	# n - 1 التحقق ضمن النطاق 2 و 
	for i in range(2, n): 
		if (n % i == 0): 
			return False

	return True

# اختبار الدالة السابقة 
if isPrime(11): 
	print ("true") 
else: 
	print ("false") 
</source>
* جافا:

<source lang="java">import java.util.*; 

class GFG { 
	
	static boolean isPrime(int n) 
	{ 
		// إن كان العدد المعطى أقل من 1 أو يساويه تعيد الدالة قيمة خاطئة
		if (n <= 1) 
			return false; 
	
		// إن كان العدد المعطى أقل من 1 أو يساويه تعيد الدالة قيمة خاطئة 
		for (int i = 2; i < n; i++) 
			if (n % i == 0) 
				return false; 
	
		return true; 
	} 
	
	/* اختبار الدالة السابقة */
	public static void main(String[] args) 
	{ 
		if(isPrime(11)) 
		System.out.println(" true") ; 
		
		else
		System.out.println(" false"); 
		
	} 
} </source>
تعطي الشيفرات السابقة المخرجات التالية:

<source lang="text">true
false</source>
=== التعقيد الزمني ===

يبلغ التعقيد الزمني لهذه الخوارزمية المقدار <code>O(n)‎</code>.

=== تحسين الخوارزمية البسيطة ===

يمكن إجراء التحسينات التالية على الخوارزمية البسيطة:

* يمكن التحقق من كون العدد المعطى عددًا أوليًّا ضمن النطاق <code>2</code> و ‎<code>√n</code>‎ عوضًا عن <code>n</code>؛ وذلك لأنّ العامل الأكبر للعدد <code>n</code> يجب أن يكون مضاعفًا للعامل الأصغر الذي جرى التحقق منه فعلًا.
* يمكن تحسين الخوارزمية البسيطة بالاعتماد على القاعدة التي تنصّ على أنّ بالإمكان التعبير عن جميع الأعداد الأولية بالصيغة الرياضية <code>6k ± 1</code> باستثناء العددين الأوليين <code>2</code> و <code>3</code>؛ وذلك لأنّ بالإمكا نالتعبير عن جميع الأعداد الصحيحة بالصيغة <code>(6k + i)</code> لبعض الأعداد الصحيحة <code>k</code> ولقيم <code>i</code> التي تساوي ‎‎<code>-1</code>‎ أو <code>0</code> أو <code>1</code> أو <code>2</code> أو <code>3</code> أو <code>4</code>. إذ يقسم العدد <code>2</code> الأعداد <code>(6k + 0)</code> و <code>(6k + 2)</code> و <code>(6k + 4)</code>، ويقسم العدد <code>3</code> العدد <code>(6k + 3)</code>. ولهذا فإنّ الطريقة الأكثر فعالية هي التحقق من أنّ العدد المعطى <code>n</code> يقبل القسمة على <code>2</code> أو <code>3</code>، ثم التحقق من جميع الأرقام التي يمكن التعبير عنها بالصيغة <code>6k ± 1</code>.

تعرض الأمثلة التالية كيفية تنفيذ هذه الطريقة في عدد من لغات البرمجة:

* C++‎:

<source lang="c++">#include <bits/stdc++.h> 
using namespace std; 

bool isPrime(int n) 
{ 
	if (n <= 1) return false; 
	if (n <= 3) return true; 

	// تم التحقق من هذا لذا يمكن تجاوز الأعداد الخمسة الوسطى
	// في الحلقة التكرارية أدناه
	if (n%2 == 0 || n%3 == 0) return false; 

	for (int i=5; i*i<=n; i=i+6) 
		if (n%i == 0 || n%(i+2) == 0) 
		return false; 

	return true; 
} 


// اختبار الدالة السابقة
int main() 
{ 
	isPrime(11)? cout << " true\n": cout << " false\n"; 
	isPrime(15)? cout << " true\n": cout << " false\n"; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">def isPrime(n) : 
	if (n <= 1) : 
		return False
	if (n <= 3) : 
		return True

		# تم التحقق من هذا لذا يمكن تجاوز الأعداد الخمسة الوسطى
		# في الحلقة التكرارية أدناه 
	if (n % 2 == 0 or n % 3 == 0) : 
		return False

	i = 5
	while(i * i <= n) : 
		if (n % i == 0 or n % (i + 2) == 0) : 
			return False
		i = i + 6

	return True


# اختبار الدالة السابقة

if(isPrime(11)) : 
	print(" true") 
else : 
	print(" false") 
	
if(isPrime(15)) : 
	print(" true") 
else : 
	print(" false") 
	
	</source>
* جافا:

<source lang="java">import java.io.*; 

class GFG { 
	
	static boolean isPrime(int n) 
	{ 
		if (n <= 1) return false; 
		if (n <= 3) return true; 
	
		// تم التحقق من هذا لذا يمكن تجاوز الأعداد الخمسة الوسطى
		// في الحلقة التكرارية أدناه 
		if (n % 2 == 0 || n % 3 == 0) return false; 
	
		for (int i = 5; i * i <= n; i = i + 6) 
			if (n % i == 0 || n % (i + 2) == 0) 
			return false; 
	
		return true; 
	} 


	// اختبار التابع السابق
	public static void main(String args[]) 
	{ 
		if(isPrime(11)) 
			System.out.println(" true"); 
		else
			System.out.println(" false"); 
		if(isPrime(15)) 
			System.out.println(" true"); 
		else
			System.out.println(" false"); 
		
	} 
} 
</source>
تعطي الشيفرات السابقة المخرجات التالية:

<source lang="text">true
false</source>
==== التعقيد الزمني ====

يبلغ التعقيد الزمني لهذه الطريقة المقدار <code>O(√n)‎</code>.

== طريقة فيرمات ==

طريقة فيرمات Fermat Method طريقة احتمالية probabilistic وتعتمد على مبرهنة فيرمات الصغيرة، والتي تنصّ على أنّه إن كان <code>n</code> عددًا أوليًّا، فلكل <code>a</code> إذ ‎<code>1 < a < n-1</code>‎ فإنّ:

<source lang="text">a^(n-1) ≡ 1 (mod n)</source>
أو 

<source lang="text">a^(n-1) % n = 1</source>
''مثال:''

العدد 5 عدد أولي:

<source lang="text">2^4 ≡ 1 (mod 5) [2^4%5 = 1],
3^4 ≡ 1 (mod 5) and 4^4 ≡ 1 (mod 5) 

العدد 7 عدد أولي:
2^6 ≡ 1 (mod 7),
3^6 ≡ 1 (mod 7), 4^6 ≡ 1 (mod 7) 
5^6 ≡ 1 (mod 7) and 6^6 ≡ 1 (mod 7) </source>
إن كان العدد المعطى أوليًا فإن هذه الطريقة تعيد قيمة صحيحة دائمًا، ولكن إن كان العدد المعطى مركًّبا composite أو غير أولي، فقد تعيد الطريقة قيمة صحيحة أو خاطئة، ولكن احتمالية إعطاء نتيجة خاطئة مع الأعداد المركبة صغيرة ويمكن تقليلها بإجراء المزيد من عمليات التكرار.

تشير قيمة <code>k</code> المرتفعة إلى زيادة في احتمالية الحصول على نتيجة صحيحة مع الأرقام المركبة، ولكن الأعداد الأولية تعطي نتيجة صحيحة دائمًا.

يمكن تقسيم الخوارزمية إلى الخطوات التالية:

# تكرار الخطوات التالية <code>k</code> مرة:<br />
أ) اختيار <code>a</code> عشوائيًا من النطاق <code>‎[2, n-2]‎</code>.<br />
ب) إن كان القاسم المشترك الأكبر للعددين لا يساوي واحد <code>gcd(a, n)  ≠ 1</code>، نعيد قيمة خاطئة<br />
جـ) إن تحققت العلاقة ‎<code>an-1 &nequiv; 1 (mod n)</code>‎، نعيد قيمة خاطئة
# نعيد قيمة صحيحة (من المحتمل أن العدد المعطى عدد أوليّ).

تعرض الأمثلة التالية طريقة تنفيذ الخوارزمية في عدد من لغات البرمجة:

* C++‎:

<source lang="c++">#include <bits/stdc++.h> 
using namespace std; 

/* دالة تكرارية تستخدم لحساب
(a^n)%p
 O(logy)‎ بتعقيد زمني قدره */
int power(int a, unsigned int n, int p) 
{ 
	int res = 1;	 // تهيئة النتيجة
	a = a % p; // a تحديث قيمة

	while (n > 0) 
	{ 
		// a إن كان العدد المعطى فرديًا نضرب النتيجة بالعدد
		if (n & 1) 
			res = (res*a) % p; 
	
		// يجب أن يتحول العدد المعطى إلى عدد زوجي عند هذه النقطة
		n = n>>1; // n = n/2 
		a = (a*a) % p; 
	} 
	return res; 
} 

/* دالة تعاودية لحساب القاسم المشترك الأكبر لعددين */
int gcd(int a, int b) 
{ 
	if(a < b) 
		return gcd(b, a); 
	else if(a%b == 0) 
		return b; 
	else return gcd(b, a%b); 
} 

// إن كان العدد المعطى أوليًا، فإنّ الدالة تعيد قيمة صحيحة دائمًا
// أما إن كان العدد المعطى مركبًا، فإن الدالة تعيد قيمة خاطئة مع احتمالية عالية
// k تؤدي زيادة قيمة
// إلى زيادة احتمالية الحصول على نتيجة صحيحة
bool isPrime(unsigned int n, int k) 
{ 
if (n <= 1 || n == 4) return false; 
if (n <= 3) return true; 

// تنفيذ الحلقة التكرارية
while (k>0) 
{ 
	//  [2..n-2] اختيار رقم عشوائي من النطاق
	// تضمن العبارات الشرطية أعلاه أنّ قيمة العدد المعطى أكبر من 4
	int a = 2 + rand()%(n-4); 

	// التحقق من أنّ العددين أوليين فيما بينهما
	if (gcd(n, a) != 1) 
		return false; 
	
	// مبرهنة فيرمات الصغيرة
	if (power(a, n-1, n) != 1) 
		return false; 
	
	k--; 
	} 
	
	return true; 
} 

// اختبار الدوال السابقة 
int main() 
{ 
	int k = 3; 
	isPrime(11, k)? cout << " true\n": cout << " false\n"; 
	isPrime(15, k)? cout << " true\n": cout << " false\n"; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python3">

</source>
import random
def power(a, n, p):
    res = 1
    a = a % p

    while (n > 0):
        if (n & 1):
            res = (res*a) % p

        n = n >> 1
        a = (a * a) % p
    
    return res


def isPrime(n, k):
    if (n <= 1 or n == 4):
        return False
    if (n <= 3):
        return True
    
    while (k > 0):
        a = 2 + random.randint(1,100) % (n - 4)

        if (power(a, n-1, n) != 1):
            return False
        
        k-=1

    return True

k = 3
res = isPrime(11, k) if " true\n" else "false\n"
print(res)

res = isPrime(15, k) if " true\n" else "false\n"
print(res)


<source lang="java">
* جافا:

```java
import java.io.*; 
import java.math.*; 

class GFG { 
	
	/* دالة تكرارية تستخدم لحساب
	(a^n)%p
 	O(logy)‎ بتعقيد زمني قدره */
	static int power(int a,int n, int p) 
	{ 
		// تهيئة النتيجة 
		int res = 1; 
		
		// a تحديث قيمة 
		a = a % p; 
	
		while (n > 0) 
		{ 
			// a إن كان العدد المعطى فرديًا نضرب النتيجة بالعدد 
			if ((n & 1) == 1) 
				res = (res * a) % p; 
	
			//  يجب أن يتحول العدد المعطى إلى عدد زوجي عند هذه النقطة 
			n = n >> 1; // n = n/2 
			a = (a * a) % p; 
		} 
		return res; 
	} 
	
	// إن كان العدد المعطى أوليًا، فإنّ الدالة تعيد قيمة صحيحة دائمًا
	// أما إن كان العدد المعطى مركبًا، فإن الدالة تعيد قيمة خاطئة مع احتمالية عالية
	// k تؤدي زيادة قيمة
	// إلى زيادة احتمالية الحصول على نتيجة صحيحة
	static boolean isPrime(int n, int k) 
	{ 
	if (n <= 1 || n == 4) return false; 
	if (n <= 3) return true; 
	
	// تنفيذ الحلقة التكرارية 
	while (k > 0) 
	{ 
		//  [2..n-2] اختيار رقم عشوائي من النطاق
		//  تضمن العبارات الشرطية أعلاه أنّ قيمة العدد المعطى أكبر من 4 
		int a = 2 + (int)(Math.random() % (n - 4)); 
	
		// مبرهنة فيرمات الصغيرة 
		if (power(a, n - 1, n) != 1) 
			return false; 
	
		k--; 
		} 
	
		return true; 
	} 
	
	// اختبار الدوال السابقة 
	public static void main(String args[]) 
	{ 
		int k = 3; 
		if(isPrime(11, k)) 
			System.out.println(" true"); 
		else
			System.out.println(" false"); 
		if(isPrime(15, k)) 
			System.out.println(" true"); 
		else
			System.out.println(" false"); 
			
	} 
} </source>
تعطي الشيفرات السابقة المخرجات التالية:

<source lang="text">true
false</source>
=== التعقيد الزمني ===

يبلغ التعقيد الزمني لطريقة فيرمات المقدار <code>O(k Log n)‎</code>، مع ملاحظة أنّ التعقيد الزمني لدالة القوة يبلغ <code>O(Log n)‎</code>

'''ملاحظة''':

قد تعطي هذه الطريقة نتائجة خاطئة حتى عند زيادة عدد الدورات (قيمة <code>k</code> أعلى)، إذ توجد بعض الأعداد المركبة والتي تمتلك الخاصية التالية لكل <code>a < n</code> وهي أنّ القاسم المشترك الأكبر للعددين <code>a</code> و <code>n</code> يساوي 1، وأنّ ‎<code>a^(n-1) ≡ 1 (mod n)</code>‎. تسمى هذه الأعداد بأعداد كارمايكل Carmichael.

يستخدم اختبار فيرمات لأولية الأعداد غالبًا عند الحاجة إلى طريقة سريعة لتصفية الأعداد، فمثلًا تستخدم هذه الطريقة في طور إنشاء المفتاح في خوارزمية مفتاح RSA العمومي للتشفير.

== طريقة ميلر-رابين ==

طريقة ميلر-رابين Miller-Rabin هي طريقة اعتمادية مثل طريقة فيرمات، ولكنّها مفضّلة عليها عمومًا.

# تنصّ مبرهنة فيرمات على أنّه إن كان العدد <code>n</code> عددًا أوليًّا فلكل <code>a</code> إذ ‎<code>1 < a < n-1</code>‎ فإنّ: <code>‎a^n-1 % n = 1‎</code>.
# تضمن الحالات الأساسية أن يكون العدد المعطى <code>n</code> عددًا فرديًا، ولما كان <code>n</code> فرديًا فإنّ <code>n-1</code> سيكون زوجيًا حتمًا، ويمكن كتابة الأرقام الزوجية بالصيغة <code>d * 2s</code> إذ <code>d</code> عدد فردي و <code>s > 0</code>.
# تحتم النقطتان أعلاه أن يكون حاصل العملية <code>a^d*2r % 2</code> هو <code>1</code> لكل رقم عشوائي في النطاق <code>‎[2, n-2]‎</code>.
# حسب موضوعة إقليدس Euclid’s Lemma فإن كان <code>x^2 % n = 1</code> أو <code>‎(x2 – 1) % n = 0</code> ولكي يكون <code>n</code> عددًا أوليًّا، يجب أن يقسم المقدار <code>(x-1)</code> أو المقدار <code>(x+1)</code>،وهذا يعني تحقق العلاقة <code>x % n = 1</code> أو <code>x % n = -1</code>.
# يمكن استنتاج ما يلي بالاستعانة بالنقطتين 2 و 3:

<blockquote>ليكون العدد <code>n</code> عددًا أوليًا يجب تحقق أحد الشرطين التاليين:<br />
<code>a^d % n = 1</code><br />
أو:<br />
<code>a^d*2i % n = -1</code><br />
لبعض قيم <code>i</code> عندما تكون <code>‎0 <= i <= r-1‎</code>
</blockquote>
=== خطوات الخوارزمية ===

تعيد الخوارزمية قيمة خاطئة إن كان العدد المعطى عددًا مركّبًا وتعيد قيمة صحيحة إن كان هناك احتمال أن يكون العدد أوليًا. تستخدم الخوارزمية معاملًا (<code>k</code>) يحدّد مستوى الدقة في هذه الخوارزمية، إذ كلما زادت قيمة <code>k</code> زادت دقة الخوارزمية.

تضمّ هذه الخوارزمية دالتين هما:

# bool isPrime(int n, int k)

تعطي هذه الدالة نتيجة منطقية، وتؤدي العمليات التالية:

# تعالج الحالة الأساسية والتي يكون فيها العدد المعطى أقل من 3.
# إن كان العدد المعطى موجبًا، تعيد الدالة قيمة خاطئة.
# العثور على عد فردي <code>d</code> يمكن استخدامه لكتابة العدد <code>n-1</code> بالصيغة <code>d*2r</code>. لاحظ أنّه لما كان العدد <code>n</code> فرديًا فإنّ العدد <code>n-1</code> سيكون زوجيًا ويجب أن تكون قيمة <code>r</code> أكبر من الصفر.
# تؤدي الدالة العملية التالية <code>k</code> مرة:<br />
if (millerTest(n, d) == false)<br />
 return false
# إعادة قيمة صحيحة.

# bool millerTest(int n, int d)

تستدعى هذه الدالة <code>k</code> مرة، وتعيد قيمة خاطئة إن كان العدد <code>n</code> عددًا مركّبًا، وتعيد قيمة خاطئة إن كان هناك احتمال في أن يكون العدد <code>n</code> عددًا أوليًّا. العدد <code>d</code> هو عدد فردي يحقق العلاقة <code>d*2r = n-1</code> لبعض قيم <code>r</code> التي تكون أكبر من واحد أو مساوية له.

تعطي هذه الدالة نتيجة منطقية، وتؤدي العمليات التالية:

<ol style="list-style-type: decimal;">
<li><p>اختيار رقم عشوائي <code>a</code> من النطاق <code>‎[2, n-2]‎</code>.</p></li>
<li><p>حساب نتيجة العملية: <code>x = pow(a, d) % n</code></p></li>
<li><p>إن كانت <code>x == 1</code> أو <code>x == n-1</code>، تعيد الدالة قيمة صحيحة.</p></li>
<li><p>تنفيذ الحلقة التكرارية (تنفّذ <code>r-1</code> مرة في الغالب) بشرط أن لا تصبح قيمة <code>d</code> مساوية للعدد <code>n-1</code>:</p>
<p>a) x = (x*x) % n.<br />
b) If (x == 1) return false.<br />
c) If (x == n-1) return true. </p></li></ol>

يوضّح المثال التالي طريقة سير عمل الخوارزمية:

المدخلات: n = 13, k = 2.

1) حساب قيمة <code>d</code> و <code>r</code> بشرط تحقيق العلاقة <code>d*2r = n-1</code><br />
 d = 3, r = 2. <br />
2) استدعاء الدالة <code>millerTest</code> وتكرار الاستدعاء <code>k</code> مرة.

'''الدورة الأولى''':

1) اختيار رقم عشوائي <code>a</code> من النطاق <code>‎[2, n-2]‎</code>. لنفترض أن <code>a = 4</code>.

2) حساب نتيجة المعادلة <code>x = pow(a, d)‎ % n</code>

<code>x = 43 % 13 = 12</code>

3) لما كان <code>x = (n-1)‎</code>، تعيد الدالة قيمة صحيحة.

'''الدورة الثانية''':

1) اختيار رقم عشوائي <code>a</code> من النطاق <code>‎[2, n-2]‎</code>. لنفترض أن <code>a = 5</code>.

2) حساب نتيجة المعادلة <code>x = pow(a, d) % n</code>.

<code>x = 53 % 13 = 8</code>

3) <code>x</code> لا تساوي 1 أو 12.

4) تنفيذ ما يلي <code>(r-1)</code> مرة = مرة واحدة.<br />
 <br />
 a) x = (x * x) % 13 = (8 * 8) % 13 = 12<br />
 b) لما كان <code>‎x = (n-1)‎</code> تعيد الدالة قيمة صحيحة.

لما كانت الدورتان تعيدان قيمة صحيحة، فسنعيد قيمة صحيحة.

=== تنفيذ الخوارزمية ===

تعرض الأمثلة التالية طريقة تنفيذ الخوارزمية في عدد من لغات البرمجة:

* C++‎:

<source lang="c++">#include <bits/stdc++.h> 
using namespace std; 

// دالة مساعدة لرفع الرقم المعطى إلى قوة معينة ثم حساب باقي القسمة على عدد ثالث

//(x^y) % p 
int power(int x, unsigned int y, int p) 
{ 
	int res = 1;	 // تهيئة النتيجة
	x = x % p; // p تحديث قيمة هذا المتغير إن كان أكبر من قيمة
				// أو مساويًا له
	while (y > 0) 
	{ 
		// x إن كان العدد فرديًا نضرب النتيجة بالعدد
		if (y & 1) 
			res = (res*x) % p; 

		// y يجب أن يكون العدد
		// زوجيًا الآن
		y = y>>1; // y = y/2 
		x = (x*x) % p; 
	} 
	return res; 
} 

bool miillerTest(int d, int n) 
{ 
	// اختيار عدد عشوائي من النطاق `‎[2, n-2]‎`
	// التأكد من أن العدد المعطى أكبر من 4
	int a = 2 + rand() % (n - 4); 

	//  a^d % n حساب ناتج العملية 
	int x = power(a, d, n); 

	if (x == 1 || x == n-1) 
	return true; 

	// x الاستمرار في حساب مربع العدد
	// بشرط عدم تحقق أحد الشروط التالية:
	// (i) d لم يصل إلى القيمة n-1 
	// (ii) (x^2) % n لا تساوي 1
	// (iii) (x^2) % n لا تساوي n-1 
	while (d != n-1) 
	{ 
		x = (x * x) % n; 
		d *= 2; 

		if (x == 1)	 return false; 
		if (x == n-1) return true; 
	} 

	return false; 
} 


bool isPrime(int n, int k) 
{ 
	// الحالات الأساسية
	if (n <= 1 || n == 4) return false; 
	if (n <= 3) return true; 

	// r حساب قيمة
	// n = 2^d * r + 1
	// لبعض قيم r بشرط r >= 1 
	int d = n - 1; 
	while (d % 2 == 0) 
		d /= 2; 

	// تنفيذ الحلقة التكرارية
	for (int i = 0; i < k; i++) 
		if (!miillerTest(d, n)) 
			return false; 

	return true; 
} 

// اختبار الدوال السابقة
int main() 
{ 
	int k = 4; // عدد الدورات

	cout << "All primes smaller than 100: \n"; 
	for (int n = 1; n < 100; n++) 
	if (isPrime(n, k)) 
		cout << n << " "; 

	return 0; 
} 
</source>
* بايثون:

<source lang="python">import random 

# دالة مساعدة لرفع الرقم المعطى إلى قوة معينة ثم حساب باقي القسمة على عدد ثالث 
# It returns (x^y) % p 
def power(x, y, p): 
	
	# تهيئة النتيجة 
	res = 1 
	
	# p تحديث قيمة هذا المتغير إن كان أكبر من قيمة
	# أو مساويًا له
	x = x % p
	while (y > 0): 
		
		# x إن كان العدد فرديًا نضرب النتيجة بالعدد
		if (y & 1): 
			res = (res * x) % p

		# y يجب أن يكون العدد
		# زوجيًا الآن 
		y = y>>1 # y = y/2 
		x = (x * x) % p
	
	return res; 

def miillerTest(d, n): 
	
	# اختيار عدد عشوائي من النطاق `‎[2, n-2]‎` 
	# التأكد من أن العدد المعطى أكبر من 4 
	a = 2 + random.randint(1, n - 4)

	# a^d % n حساب ناتج العملية
	x = power(a, d, n)

	if (x == 1 or x == n - 1): 
		return True

	# x الاستمرار في حساب مربع العدد
	# بشرط عدم تحقق أحد الشروط التالية:
	# (i) d لم يصل إلى القيمة n-1 
	# (ii) (x^2) % n لا تساوي 1
	# (iii) (x^2) % n لا تساوي n-1
	while (d != n - 1): 
		x = (x * x) % n
		d *= 2

		if (x == 1): 
			return False; 
		if (x == n - 1): 
			return True

	return False

def isPrime( n, k): 
	
	# الحالات الأساسية 
	if (n <= 1 or n == 4): 
		return False
	if (n <= 3): 
		return True

	# r حساب قيمة
	# n = 2^d * r + 1
	# لبعض قيم r بشرط r >= 1 
	d = n - 1
	while (d % 2 == 0): 
		d //= 2

	# تنفيذ الحلقة التكرارية
	for i in range(k): 
		if (miillerTest(d, n) == False): 
			return False

	return True 

# اختبار الدوال السابقة 

# عدد الدورات
k = 4

print("All primes smaller than 100: ")
for n in range(1,100): 
	if (isPrime(n, k)): 
		print(n , end=" ")
</source>
* جافا:

<source lang="java">import java.io.*; 
import java.math.*; 

class GFG { 

	// دالة مساعدة لرفع الرقم المعطى 
	// إلى قوة معينة ثم حساب باقي القسمة على عدد ثالث 
	static int power(int x, int y, int p) { 
		
		int res = 1; // تهيئة النتيجة
		
		// p تحديث قيمة هذا المتغير إن كان أكبر من قيمة 
		// أو مساويًا له 
		x = x % p; 

		while (y > 0) { 
			
			// x إن كان العدد فرديًا نضرب النتيجة بالعدد 
			if ((y & 1) == 1) 
				res = (res * x) % p; 
		
			// y يجب أن يكون العدد
			// زوجيًا الآن 
			y = y >> 1; // y = y/2 
			x = (x * x) % p; 
		} 
		
		return res; 
	} 
	
	static boolean miillerTest(int d, int n) { 
		
		// اختيار عدد عشوائي من النطاق `‎[2, n-2]‎` 
		// التأكد من أن العدد المعطى أكبر من 4 
		int a = 2 + (int)(Math.random() % (n - 4)); 
	
		// حساب ناتج العملية a^d % n 
		int x = power(a, d, n); 
	
		if (x == 1 || x == n - 1) 
			return true; 
	
		// x الاستمرار في حساب مربع العدد
	// بشرط عدم تحقق أحد الشروط التالية:
		// (i) d لم يصل إلى القيمة n-1 
		// (ii) (x^2) % n لا تساوي 1
		// (iii) (x^2) % n لا تساوي n-1 
		while (d != n - 1) { 
			x = (x * x) % n; 
			d *= 2; 
		
			if (x == 1) 
				return false; 
			if (x == n - 1) 
				return true; 
		} 
	
		return false; 
	} 
	
	static boolean isPrime(int n, int k) { 
		
		// الحالات الأساسية 
		if (n <= 1 || n == 4) 
			return false; 
		if (n <= 3) 
			return true; 
	
		// r حساب قيمة
		// n = 2^d * r + 1 
		// بشرط r >= 1 
		int d = n - 1; 
		
		while (d % 2 == 0) 
			d /= 2; 
	
		// تنفيذ الحلقة التكرارية 
		for (int i = 0; i < k; i++) 
			if (!miillerTest(d, n)) 
				return false; 
	
		return true; 
	} 
	
	// اختبار الدوال السابقة
	public static void main(String args[]) { 
		
		int k = 4; // عدد الدورات 
	
		System.out.println("All primes smaller "
								+ "than 100: "); 
								
		for (int n = 1; n < 100; n++) 
			if (isPrime(n, k)) 
				System.out.print(n + " "); 
	} 
}</source>
تعطي الشيفرات السابقة المخرجات التالية:

<source lang="text">Output:
All primes smaller than 100: 
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 
61 67 71 73 79 83 89 97 </source>
== غربال إراتوسثينس ==

غربال إراتوسثينس Eratosthenes sieve من أكثر الطرق فعالية في إيجاد جميع الأعداد الأولية التي تكون أصغر من <code>n</code> والذي يكون أصغر من 10 ملايين تقريبًا.

تتبع خوارزمية غربال إراتوسثينس الخطوات التالية لإيجاد الأعداد الأولية:

# إنشاء قائمة بالأعداد الزوجية المتعاقبة والتي تبدأ من <code>2</code> وتنتهي بالعدد <code>n</code>.
# في البداية نفترض أنّ <code>p = 2</code>، وهو أول الأعداد الأولية.
# نبدأ العدّ من <code>p^2</code> صعودًا، ونعلّم جميع الأرقام التي تكون أكبر من <code>p^2</code> أو تساويه في القائمة. هذه الأرقام هي ‎<code>p(p+1), p(p+2), p(p+3)...</code>‎ الخ.
# العثور على أول رقم غير معلَّم ويكون أكبر من <code>p</code> في القائمة، فإن لم يُعثر على مثل هذا الرقم، تتوقف الخوارزمية عن العمل، وإلاّ نجعل قيمة <code>p</code> مساوية لهذا العدد (وهو العدد الأولي التالي) ثم نعود إلى الخطوة الثالثة.

عند انتهاء عمل الخوارزمية تكون جميع الأعداد غير المعلَّمة في القائمة أعدادًا أولية.

'''مثال توضيحي''':

لنفترض أنّ <code>n = 50</code>. سنطبع جميع الأعداد التي تكون أصغر من <code>50</code> أو تساويها.



إنشاء قائمة بالأعداد من <code>2</code> إلى <code>50</code>.



نبدأ بتعليم جميع الأعداد التي تقبل القسمة على <code>2</code> والتي تكون أكبر من مربّع <code>2</code> أو مساوية له.



ننتقل بعدها إلى العدد غير المعلّم التالي وهو <code>3</code> ونعلّم جميع الأعداد التي تكون من مضاعفات <code>3</code> وهي في الوقت نفسه أكبر من مربّع <code>3</code> أو مساوية له.



ننتقل بعد ذلك إلى العدد غير المعلّم التالي، وهو <code>5</code>، ونعلّم جميع الأعداد التي تكون من مضاعفات <code>5</code> وهي في الوقت نفسه أكبر من مربّع <code>5</code> أو مساوية له.



تستمر العملية على هذا المنوال إلى حين الحصول على النتيجة النهائية:



الأعداد الأولية في القائمة هي الأعداد التي بقيت غير معلَّمة حتى نهاية عمل الخوارزمية.

=== تنفيذ الخوارزمية ===

تعرض الأمثلة التالية طريقة تنفيذ الخوارزمية في عدد من لغات البرمجة.

تستخدم الأمثلة التالية مصفوفة منطقية <code>arr[]‎</code> حجمها <code>n</code> لتعليم مضاعفات الأعداد الأولية.

* C++‎:

<source lang="c++">#include <bits/stdc++.h> 
using namespace std; 

void SieveOfEratosthenes(int n) 
{ 
	// إنشاء المصفوفة المنطقية وتهيئة جميع عناصرها لتكون قيمًا صحيحة
	// تكون قيمة العنصر في المصفوفة خاطئة إن كان العدد غير أوليّ
	
	bool prime[n+1]; 
	memset(prime, true, sizeof(prime)); 

	for (int p=2; p*p<=n; p++) 
	{ 
		// إن لم تتغير حالة العدد فهذا يعني أنّه عدد أولي
		if (prime[p] == true) 
		{ 
			// p تحديث جميع مضاعفات العدد
			// والتي تكون أكبر من مربعه أو تساويه
			// p جميع الأعداد التي تكون أصغر من العدد 
			// والتي تكون أصغر من مربعه معلّمة أصلًا
			for (int i=p*p; i<=n; i += p) 
				prime[i] = false; 
		} 
	} 

	// طباعة جميع الأعداد الأولية
	for (int p=2; p<=n; p++) 
	if (prime[p]) 
		cout << p << " "; 
} 

// اختبار الدالة السابقة
int main() 
{ 
	int n = 30; 
	cout << "Following are the prime numbers smaller "
		<< " than or equal to " << n << endl; 
	SieveOfEratosthenes(n); 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">def SieveOfEratosthenes(n): 
	
	# إنشاء المصفوفة المنطقية وتهيئة جميع عناصرها لتكون قيمًا صحيحة
	# تكون قيمة العنصر في المصفوفة خاطئة إن كان العدد غير أوليّ 
	prime = [True for i in range(n+1)] 
	p = 2
	while (p * p <= n): 
		
		# إن لم تتغير حالة العدد فهذا يعني أنّه عدد أولي
		if (prime[p] == True): 
			
			# p تحديث جميع مضاعفات العدد 
			for i in range(p * p, n+1, p): 
				prime[i] = False
		p += 1
	
	# طباعة الأعداد الأولية 
	for p in range(2, n): 
		if prime[p]: 
			print p, 

# اختبار الدالة السابقة
if __name__=='__main__': 
	n = 30
	print "Following are the prime numbers smaller", 
	print "than or equal to", n 
	SieveOfEratosthenes(n) 
</source>
* جافا:

<source lang="java">class SieveOfEratosthenes 
{ 
	void sieveOfEratosthenes(int n) 
	{ 
		// إنشاء المصفوفة المنطقية وتهيئة جميع عناصرها لتكون قيمًا صحيحة
	// تكون قيمة العنصر في المصفوفة خاطئة إن كان العدد غير أوليّ
		boolean prime[] = new boolean[n+1]; 
		for(int i=0;i<n;i++) 
			prime[i] = true; 
		
		for(int p = 2; p*p <=n; p++) 
		{ 
			// إن لم تتغير حالة العدد فهذا يعني أنّه عدد أولي 
			if(prime[p] == true) 
			{ 
				// p تحديث جميع مضاعفات العدد  
				for(int i = p*p; i <= n; i += p) 
					prime[i] = false; 
			} 
		} 
		
		// طباعة الأعداد الأولية 
		for(int i = 2; i <= n; i++) 
		{ 
			if(prime[i] == true) 
				System.out.print(i + " "); 
		} 
	} 
	
	// اختبار الدالة السابقة
	public static void main(String args[]) 
	{ 
		int n = 30; 
		System.out.print("Following are the prime numbers "); 
		System.out.println("smaller than or equal to " + n); 
		SieveOfEratosthenes g = new SieveOfEratosthenes(); 
		g.sieveOfEratosthenes(n); 
	} 
} </source>
تعطي الشيفرات السابقة المخرجات التالية:

<source lang="text">Following are the prime numbers below 30
2 3 5 7 11 13 17 19 23 29</source>
=== التعقيد الزمني ===

يبلغ التعقيد الزمني لخوارزمية غربال إراتوسثينس المقدار <code>O(n*log(log(n)))‎</code>.

== الغربال المجزأ ==

تعاني خوارزمية غربال إراتوسثينس من بعض المشاكل عندما تصبح قيمة <code>n</code> كبيرة:

# قد لا تتسع الذاكرة لمصفوفة حجمها <code>Θ(n)‎</code>.
# لا تخزّن هذه الخوارزمية البيانات في الذاكرة الخبيئة Cache عندما تكون قيمة <code>n</code> كبيرة، إذ تتنقل الخوارزمية عبر عناصر المصفوفة دون وجود أي موقعية للإشارة locality of reference.

تقوم خوارزمية الغربال المجزأ على فكرة تقسيم النطاق ‎<code>[0..n-1]</code>‎ إلى أجزاء متعددة وحساب الأعداد الأولية في كل جزء على حدة. تستخدم الخوارزمية في بداية عملها خوارزمية الغربال البسيطة للعثور على الأعداد الأولية التي تكون أصغر من ‎<code>√(n)</code>‎.

يمكن تقسيم طريقة عمل الخوارزمية إلى الخطوات التالية:

# تستخدم خوارزمية الغربال البسيطة في العثور على جميع الأعداد الأولية التي تكون أصغر من الجذر التربيعي للعدد المعطى أو مساوية له، وتخزين هذه الأعداد الأولية في مصفوفة (لتكن <code>prime[]‎</code>).
# سنحتاج إلى جميع الأعداد الأولية في النطاق ‎<code>[0..n-1]</code>‎؛ لذا سنقسّم هذا النطاق إلى أجزاء متعددة بشرط أن لا يتجاوز حجم كل جزء المقدار <code>‎√n</code>.
# تنفيذ الخطوات التالية على كل جزء <code>[low..high]</code>:<br />
أ) إنشاء مصفوفة <code>mark[high-low+1]‎</code>. في هذه الحالة سنحتاج فقط إلى المساحة <code>O(x)‎</code> إذ تمثل <code>x</code> عدد العناصر في النطاق الحالي.<br />
ب) المرور على جميع الأعداد الأولية التي عُثر عليها في الخطوة الأولى، وتعليم مضاعفات كل عدد أولي في النطاق <code>[low..hight]</code>. 

تحتاج خوارزمية الغربال البسيطة إلى المساحة <code>O(n)‎</code> والتي قد تكون غير ملائمة عندما تكون قيمة <code>n</code> كبيرة، أما خوارزمية الغربال المجزّا فتحتاج إلى المساحة <code>O(√n)‎</code> وتجرى عملية المعالجة على نطاقات أصغر (موقعية الإشارات).

تعرض الأمثلة التالية طريقة تنفيذ الخوارزمية في عدد من لغات البرمجة:

* C++‎:

<source lang="c++">#include <bits/stdc++.h> 
using namespace std; 

// تعثر هذه الدالة على جميع الأعداد الأولية التي تكون أصغر من الحد المعطى
// prime[] باستخدام خوارزمية إراتسوثينس البسيطة، وتخزن النتيجة في المتّجه

void simpleSieve(int limit, vector<int> &prime) 
{ 
	// إنشاء مصفوفة منطقية وتهيئة القيم فيها لتكون جميعها صحيحة.
	// تتحول قيمة العنصر في هذه المصفوفة إلى قيمة خاطئة إذا لم يكن العدد الحالي أوليًا
	// وتتحول إلى قيمة صحيحة إن حصل العكس
	bool mark[limit+1]; 
	memset(mark, true, sizeof(mark)); 

	for (int p=2; p*p<limit; p++) 
	{ 
		//p إن لم تتغير قيمة المتغير
		// فهذا يعني أنّ العدد أوليّ
		if (mark[p] == true) 
		{ 
			// p تحديث جميع مضاعفات العدد
			for (int i=p*2; i<limit; i+=p) 
				mark[i] = false; 
		} 
	} 
	
	// prime طباعة جميع الأعداد الأولية وتخزينها في المصفوفة
	for (int p=2; p<limit; p++) 
	{ 
		if (mark[p] == true) 
		{ 
			prime.push_back(p); 
			cout << p << " "; 
		} 
	} 
} 

// تطبع الدالة جميع الأعداد الأولية التي تكون أصغر من العدد المعطى
void segmentedSieve(int n) 
{ 
	// حساب جميع الأعداد الأولية التي تكون أصغر من الجذر التربيعي للعدد المعطى
	// أو مساوية له وذلك باستخدام خوارزمية الغربال البسيطة
	int limit = floor(sqrt(n))+1; 
	vector<int> prime; 
	simpleSieve(limit, prime); 

	// [0..n-1] تقسيم النطاق
	// إلى أجزاء مختلفة
	// حجم القطعة في هذا المثال يساوي الجذر التربيعي للعدد المعطى
	int low = limit; 
	int high = 2*limit; 

	// [0..n-1] تنفيذ الحلقة التكرارية التالية ما دامت جميع القطع في النطاق
	// لم تعالج بعد.
	// تعالج قطعة واحدة في كل مرة
	while (low < n) 
	{ 
		if (high >= n) 
		high = n; 
		
		// تعليم الأعداد الأولية في النطاق الحالي.
		// mark[i] تصبح القيمة في
		// 'i-low'قيمة خاطئة في النهاية إن كان المقدار
		// عددًا غير أوليّ، وتكون قيمة صحيحة فيما عدا ذلك
		bool mark[limit+1]; 
		memset(mark, true, sizeof(mark)); 

		// استخدام الأعداد الأولية التي عُثر عليها باستخدام الدالة السابقة
		// في العثور على الأعداد الأولية في النطاق الحالي
		for (int i = 0; i < prime.size(); i++) 
		{ 
			// [low..high] إيجاد أصغر عدد في النطاق
			// prime[i] والذي يكون من مضاعفات العدد 
			// على سبيل المثال إن كان الحد الأدنى هو 31
			// prime[i] وكانت 3 هي قيمة
			// فسنبدأ بالعدد 33
			int loLim = floor(low/prime[i]) * prime[i]; 
			if (loLim < low) 
				loLim += prime[i]; 

			/* تعليم مضاعفات العدد الأولي في النطاق:
			j - low يجري تعليم العدد
			j مقابل العدد
			[low, high] بمعنى أن كل عدد في النطاق
			[0, high-low] سيرتبط بالنطاق 
			لهذا إن كان النطاق ‎[50, 100]‎ فإن تعليم العدد 50
			يعني تعليم العدد 0، والعدد 51 يعني تعليم العدد 1 وهكذا
			بهذه الطريقة سيحتاج النطاق إلى حجز نصف المساحة في الذاكرة فقط */
			for (int j=loLim; j<high; j+=prime[i]) 
				mark[j-low] = false; 
		} 

		// الأعداد التي لم تعلم بقيمة خاطئة هي أعداد أولية
		for (int i = low; i<high; i++) 
			if (mark[i - low] == true) 
				cout << i << " "; 

		// تحديث القيمة الدنيا والعظمى للنطاق من أجل الدورة التالية
		low = low + limit; 
		high = high + limit; 
	} 
} 

// اختبار الدوال السابقة
int main() 
{ 
	int n = 100; 
	cout << "Primes smaller than " << n << ":n"; 
	segmentedSieve(n); 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">import math 
prime = [] 

# تعثر هذه الدالة على جميع الأعداد الأولية التي تكون أصغر من الحد المعطى
# prime[] باستخدام خوارزمية إراتسوثينس البسيطة، وتخزن النتيجة في المتّجه

def simpleSieve(limit): 
	
	# إنشاء مصفوفة منطقية وتهيئة القيم فيها لتكون جميعها صحيحة.
	# تتحول قيمة العنصر في هذه المصفوفة إلى قيمة خاطئة إذا لم يكن العدد الحالي أوليًا
	# وتتحول إلى قيمة صحيحة إن حصل العكس
	mark = [True for i in range(limit + 1)] 
	p = 2
	while (p * p <= limit): 
		
		# p إن لم تتغير قيمة المتغير
		# فهذا يعني أنّ العدد أوليّ 
		if (mark[p] == True): 
			
			# p تحديث جميع مضاعفات العدد 
			for i in range(p * p, limit + 1, p): 
				mark[i] = False
		p += 1
		
	# prime طباعة جميع الأعداد الأولية وتخزينها في المصفوفة 
	for p in range(2, limit): 
		if mark[p]: 
			prime.append(p) 
			print(p,end = " ") 
			
# تطبع الدالة جميع الأعداد الأولية التي تكون أصغر من العدد المعطى 
def segmentedSieve(n): 
	
	# حساب جميع الأعداد الأولية التي تكون أصغر من الجذر التربيعي للعدد المعطى
	# أو مساوية له وذلك باستخدام خوارزمية الغربال البسيطة 
	limit = int(math.floor(math.sqrt(n)) + 1) 
	simpleSieve(limit) 
	
	# [0..n-1] تقسيم النطاق
	# إلى أجزاء مختلفة
	# حجم القطعة في هذا المثال يساوي الجذر التربيعي للعدد المعطى 
	low = limit 
	high = limit * 2
	
	# [0..n-1] تنفيذ الحلقة التكرارية التالية ما دامت جميع القطع في النطاق
	# لم تعالج بعد.
	# تعالج قطعة واحدة في كل مرة 
	while low < n: 
		if high >= n: 
			high = n 
			
		# تعليم الأعداد الأولية في النطاق الحالي.
		# mark[i] تصبح القيمة في
		# 'i-low'قيمة خاطئة في النهاية إن كان المقدار
		# عددًا غير أوليّ، وتكون قيمة صحيحة فيما عدا ذلك 
		mark = [True for i in range(limit + 1)] 
		
		# استخدام الأعداد الأولية التي عُثر عليها باستخدام الدالة السابقة
		# في العثور على الأعداد الأولية في النطاق الحالي 
		for i in range(len(prime)): 
			
			# [low..high] إيجاد أصغر عدد في النطاق
			# prime[i] والذي يكون من مضاعفات العدد 
			# على سبيل المثال إن كان الحد الأدنى هو 31
			# prime[i] وكانت 3 هي قيمة
			# فسنبدأ بالعدد 33. 
			loLim = int(math.floor(low / prime[i]) *
										prime[i]) 
			if loLim < low: 
				loLim += prime[i] 
				
			# تعليم مضاعفات العدد الأولي في النطاق:
			# j - low يجري تعليم العدد
			# j مقابل العدد
			# [low, high] بمعنى أن كل عدد في النطاق
			# [0, high-low] سيرتبط بالنطاق 
			# لهذا إن كان النطاق ‎[50, 100]‎ فإن تعليم العدد 50
			# يعني تعليم العدد 0، والعدد 51 يعني تعليم العدد 1 وهكذا
			# بهذه الطريقة سيحتاج النطاق إلى حجز نصف المساحة في الذاكرة فقط
			for j in range(loLim, high, prime[i]): 
				mark[j - low] = False
				
		# الأعداد التي لم تعلم بقيمة خاطئة هي أعداد أولية 
		for i in range(low, high): 
			if mark[i - low]: 
				print(i, end = " ") 
				
		# تحديث القيمة الدنيا والعظمى للنطاق من أجل الدورة التالية 
		low = low + limit 
		high = high + limit 

# اختبار الدوال السابقة 
n = 100
print("Primes smaller than", n, ":") 
segmentedSieve(100) 
</source>
* جافا:

<source lang="java">import java.util.Vector; 
import static java.lang.Math.sqrt; 
import static java.lang.Math.floor; 

class Test 
{ 
	// تعثر هذه الدالة على جميع الأعداد الأولية التي تكون أصغر من الحد المعطى
	// prime[] باستخدام خوارزمية إراتسوثينس البسيطة، وتخزن النتيجة في المتّجه
	static void simpleSieve(int limit, Vector<Integer> prime) 
	{ 
		// إنشاء مصفوفة منطقية وتهيئة القيم فيها لتكون جميعها صحيحة.
		// تتحول قيمة العنصر في هذه المصفوفة إلى قيمة خاطئة إذا لم يكن العدد الحالي أوليًا
		// وتتحول إلى قيمة صحيحة إن حصل العكس 
		boolean mark[] = new boolean[limit+1]; 
		
		for (int i = 0; i < mark.length; i++) 
			mark[i] = true; 
	
		for (int p=2; p*p<limit; p++) 
		{ 
			//p إن لم تتغير قيمة المتغير
			// فهذا يعني أنّ العدد أوليّ
			if (mark[p] == true) 
			{ 
				// p تحديث جميع مضاعفات العدد
				for (int i=p*2; i<limit; i+=p) 
					mark[i] = false; 
			} 
		} 
	
		// prime طباعة جميع الأعداد الأولية وتخزينها في  
		for (int p=2; p<limit; p++) 
		{ 
			if (mark[p] == true) 
			{ 
				prime.add(p); 
				System.out.print(p + " "); 
			} 
		} 
	} 
	
	// تطبع الدالة جميع الأعداد الأولية التي تكون أصغر من العدد المعطى 
	static void segmentedSieve(int n) 
	{ 
		// حساب جميع الأعداد الأولية التي تكون أصغر من الجذر التربيعي للعدد المعطى
		// أو مساوية له وذلك باستخدام خوارزمية الغربال البسيطة 
		int limit = (int) (floor(sqrt(n))+1); 
		Vector<Integer> prime = new Vector<>(); 
		simpleSieve(limit, prime); 
	
		// [0..n-1] تقسيم النطاق
		// إلى أجزاء مختلفة
		// حجم القطعة في هذا المثال يساوي الجذر التربيعي للعدد المعطى 
		int low = limit; 
		int high = 2*limit; 
	
		// [0..n-1] تنفيذ الحلقة التكرارية التالية ما دامت جميع القطع في النطاق 
		// لم تعالج بعد.
		// تعالج قطعة واحدة في كل مرة
		while (low < n) 
		{ 
			if (high >= n) 
				high = n; 

			// تعليم الأعداد الأولية في النطاق الحالي.
			// mark[i] تصبح القيمة في
			// 'i-low'قيمة خاطئة في النهاية إن كان المقدار
			// عددًا غير أوليّ، وتكون قيمة صحيحة فيما عدا ذلك 
			boolean mark[] = new boolean[limit+1]; 
			
			for (int i = 0; i < mark.length; i++) 
				mark[i] = true; 
	
			// استخدام الأعداد الأولية التي عُثر عليها باستخدام الدالة السابقة
			// في العثور على الأعداد الأولية في النطاق الحالي
			for (int i = 0; i < prime.size(); i++) 
			{ 
				// [low..high] إيجاد أصغر عدد في النطاق
				// prime[i] والذي يكون من مضاعفات العدد 
				// على سبيل المثال إن كان الحد الأدنى هو 31
				// prime[i] وكانت 3 هي قيمة
				// فسنبدأ بالعدد 33 
				int loLim = (int) (floor(low/prime.get(i)) * prime.get(i)); 
				if (loLim < low) 
					loLim += prime.get(i); 
	
				/* تعليم مضاعفات العدد الأولي في النطاق:
				j - low يجري تعليم العدد
				j مقابل العدد
				[low, high] بمعنى أن كل عدد في النطاق
				[0, high-low] سيرتبط بالنطاق 
				لهذا إن كان النطاق ‎[50, 100]‎ فإن تعليم العدد 50
				يعني تعليم العدد 0، والعدد 51 يعني تعليم العدد 1 وهكذا
				بهذه الطريقة سيحتاج النطاق إلى حجز نصف المساحة في الذاكرة فقط */
				for (int j=loLim; j<high; j+=prime.get(i)) 
					mark[j-low] = false; 
			} 
	
			// الأعداد التي لم تعلم بقيمة خاطئة هي أعداد أولية 
			for (int i = low; i<high; i++) 
				if (mark[i - low] == true) 
					System.out.print(i + " "); 
	
			// تحديث القيمة الدنيا والعظمى للنطاق من أجل الدورة التالية 
			low = low + limit; 
			high = high + limit; 
		} 
	} 
	
	// اختبار الدوال السابقة 
	public static void main(String args[]) 
	{ 
		int n = 100; 
		System.out.println("Primes smaller than " + n + ":"); 
		segmentedSieve(n); 
	} 
} 
</source>
تعطي الشيفرات السابقة المخرجات التالية:

<source lang="text">Primes smaller than 100:
2 3 5 7 11 13 17 19 23 29 31 37 41
43 47 53 59 61 67 71 73 79 83 89 97  </source>
=== التعقيد الزمني ===

التعقيد الزمني لهذه الخوارزمية مماثل للتعقيد الزمني لخوارزمية غربال إراتوسثينس، ولكنّ خوارزمية الغربال المجزأ تتفوق عى الأخيرة عند التعامل مع قيم <code>n</code> الكبيرة.

== مصادر ==

* صفحة [https://www.geeksforgeeks.org/prime-numbers/ Prime Numbers] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/primality-test-set-1-introduction-and-school-method/ Primality Test | Set 1 (Introduction and School Method)‎] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/primality-test-set-2-fermet-method/ Primality Test | Set 2 (Fermat Method)‎] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/primality-test-set-3-miller-rabin/ Primality Test | Set 3 (Miller–Rabin)‎] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/sieve-of-eratosthenes/ Sieve of Eratosthenes] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/segmented-sieve/ Segmented Sieve] في توثيق الخوارزميات في موقع GeeksforGeeks.

[[تصنيف: الخوارزميات]]