عرض مصدر Algorithms/divisibility

<noinclude>{{DISPLAYTITLE:قابلية القسمة}}</noinclude>
يستخدم المعامل <code>%</code> في التحقق من قابلية قسمة عدد معين على عدد آخر وذلك بالحصول على النتيجة <code>0</code>، ولكن عندما يصبح الرقم المعنيّ كبيرًا يصير من الصعب استخدام هذا المعامل للتحقق من قابلية القسمة، ولهذا نلجأ إلى بعض الخوارزميات التي تسهّل هذه العملية.
{{Course|course=cs}}
__TOC__
== قابلية القسمة على 3 ==

يكون العدد قابلًا للقسمة على <code>3</code> إذا كان مجموع أرقامه قابلًا للقسمة على <code>3</code>.

فعلى سبيل المثال العدد <code>n = 1332</code>.

مجموع الأرقام = ‎<code>1 + 3 + 3 + 2</code>‎ = <code>9</code>‎

ولمّا كان مجموع الأرقام قابلًا للقسمة على <code>3</code> فإنّ الرقم <code>1332</code> يقبل القسمة على <code>3</code>.

يمكن برهنة ما سبق بكتابة العدد <code>1332</code> بالصيغة التالية:

<source lang="text">1332 = 1*1000 + 3*1000 + 3*10 + 2</source>
يستند البرهان على ما يلي:

باقي قسمة العدد ‎<code>10^i</code>‎ على <code>3</code> هو <code>1</code>، وهذا يعني أنّ باقي قسمة أيّ قوّة للعدد <code>10</code> هو <code>1</code>.

لذا يمكن كتابة باقي القسمة للمعادلة <code>‎1*1000 + 3*100 + 3*10 + 2‎</code> بالصيغة التالية:

<source lang="text">1*1 + 3*1 + 3*1 + 2 = 9</source>
يمثّل التعبير السابق مجموع الأرقام في العدد المعنيّ، ولمّا كان المجموع <code>9</code> قابلًا للقسمة على <code>3</code> فإنّ العدد <code>1332</code> يقبل القسم على <code>3</code>.

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

تعرض الأمثلة التالية طريقة تنفيذ الخوارزمية في عدد من [https://academy.hsoub.com/programming/general/%D9%84%D8%BA%D8%A7%D8%AA-%D8%A7%D9%84%D8%A8%D8%B1%D9%85%D8%AC%D8%A9/ لغات البرمجة]:

* C++‎:

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

int check(string str) 
{ 
	// حساب مجموع الأرقام
	int n = str.length(); 
	int digitSum = 0; 
	for (int i=0; i<n; i++) 
		digitSum += (str[i]-'0'); 

	// التحقق من كون مجموع الأرقام قابلًا للقسمة على 3
	return (digitSum % 3 == 0); 
} 

// اختبار الشيفرة السابقة 
int main() 
{ 
	string str = "1332"; 
	check(str)? cout << "Yes" : cout << "No "; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">def check(num) : 
	
	# حساب مجموع الأرقام
	digitSum = 0
	while num > 0 : 
		rem = num % 10
		digitSum = digitSum + rem 
		num = num / 10
		
	# التحقق من كون مجموع الأرقام قابلًا للقسمة على 3
	return (digitSum % 3 == 0) 
	
# اختبار الشيفرة السابقة
num = 1332
if(check(num)) : 
	print "Yes"
else : 
	print "No"
	</source>
* جافا:

<source lang="java">class IsDivisible 
{ 
	static boolean check(String str) 
	{ 
		// حساب مجموع الأرقام
		int n = str.length(); 
		int digitSum = 0; 
		for (int i=0; i<n; i++) 
			digitSum += (str.charAt(i)-'0'); 
	
		// التحقق من كون مجموع الأرقام قابلًا للقسمة على 3 
		return (digitSum % 3 == 0); 
	} 

	// اختبار الشيفرة السابقة
	public static void main (String[] args) 
	{ 
		String str = "1332"; 
		if(check(str)) 
			System.out.println("Yes"); 
		else
			System.out.println("No"); 
	} 
} 
</source>
== قابلية القسمة على 4 ==

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

يمتلك العدد <code>928160</code> على سبيل المثال الدورات: <code>928160</code> و <code>092816</code> و <code>609281</code> و <code>160928</code> و <code>816092</code> و <code>281609</code>.

يمكن تشكيل الأزواج التالية من العدد الأصلي <code>928160</code>:

<code>(9,2)</code> و <code>(2,8)</code> و <code>(8,1)</code> و <code>(1,6)</code> و <code>(6,0)</code> و <code>(0,9)</code>.

يمكن ملاحظة أنّ الأعداد ثنائية الأرقام والتي تنشأ من هذه الأزواج (أي <code>92</code> و <code>28</code> و <code>81</code> و <code>16</code> و <code>60</code>، و <code>09</code>) موجود في نهاية بعض الدورات؛ وبهذا يمكن التحقق من قابلية قسمة هذه الأزواج للحول على عدد الدورات المطلوبة للعدد.

'''ملاحظة:''': يمكن التحقق من قابلية القسمة للأعداد المفردة بطريقة مباشرة.

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

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

* C++‎:

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

// تحسب هذه الدالة جميع التدويرات التي تقبل القسمة على 4
int countRotations(string n) 
{ 
	int len = n.length(); 

	// لعدد أحادي المرتبة
	if (len == 1) 
	{ 
		int oneDigit = n.at(0)-'0'; 
		if (oneDigit%4 == 0) 
			return 1; 
		return 0; 
	}

	// عدد ثنائي المراتب على الأقل (مع الأخذ بجميع الأزواج)  
	int twoDigit, count = 0; 
	for (int i=0; i<(len-1); i++)
	{
		twoDigit = (n.at(i)-'0')*10 + (n.at(i+1)-'0'); 
		if (twoDigit%4 == 0) 
			count++; 
	} 

	// العدد الذي يتكون من الرقمين الأخير والأول
	twoDigit = (n.at(len-1)-'0')*10 + (n.at(0)-'0'); 
	if (twoDigit%4 == 0) 
		count++; 

	return count; 
} 

// اختبار الشيفرة السابقة
int main() 
{ 
	string n = "4834"; 
	cout << "Rotations: " << countRotations(n) << endl; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">
#تحسب هذه الدالة جميع التدويرات التي تقبل القسمة على 4 
def countRotations(n) : 

	l = len(n) 

	# لعدد أحادي المرتبة 
	if (l == 1) : 
		oneDigit = (int)(n[0]) 
		
		if (oneDigit % 4 == 0) : 
			return 1
		return 0
	
	
	# عدد ثنائي المراتب على الأقل (مع الأخذ بجميع الأزواج)
	count = 0
	for i in range(0, l - 1) : 
		twoDigit = (int)(n[i]) * 10 + (int)(n[i + 1]) 
		
		if (twoDigit % 4 == 0) : 
			count = count + 1
			
	# العدد الذي يتكون من الرقمين الأخير والأول 
	twoDigit = (int)(n[l - 1]) * 10 + (int)(n[0]) 
	if (twoDigit % 4 == 0) : 
		count = count + 1

	return count 

# اختبار الشيفرة السابقة
n = "4834"
print("Rotations: " , 
	countRotations(n)) </source>
* جافا:

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

class GFG { 
	
	// تحسب هذه الدالة جميع التدويرات التي تقبل القسمة على 4 
	static int countRotations(String n) 
	{ 
		int len = n.length(); 
	
		// لعدد أحادي المرتبة 
		if (len == 1) 
		{ 
		int oneDigit = n.charAt(0)-'0'; 

		if (oneDigit % 4 == 0) 
			return 1; 

		return 0; 
		} 
	
		// عدد ثنائي المراتب على الأقل (مع الأخذ بجميع الأزواج)
		int twoDigit, count = 0; 
		for (int i = 0; i < (len-1); i++) 
		{ 
		twoDigit = (n.charAt(i)-'0') * 10 + 
					(n.charAt(i+1)-'0'); 

		if (twoDigit%4 == 0) 
			count++; 
		} 
	
		// العدد الذي يتكون من الرقمين الأخير والأول  
		twoDigit = (n.charAt(len-1)-'0') * 10 + 
				(n.charAt(0)-'0'); 

		if (twoDigit%4 == 0) 
			count++; 
	
		return count; 
	} 
	
	// اختبار الشيفرة السابقة
	public static void main(String args[]) 
	{ 
		String n = "4834"; 
		System.out.println("Rotations: " + 
						countRotations(n)); 
	} 
} </source>
== قابلية القسمة على 5 ==

يكون العدد قابلاً للقسمة على <code>5</code> إذا كان آخر رقم فيه هو <code>0</code> أو <code>5</code>.

يمكن برهنة ما سبق بواسطة الملاحظة التالية:

إن باقي قسمة <code>‎10^i‎</code> على <code>5</code> يساوي <code>0</code> إذا كانت <code>i >= 1</code>. يلاحظ أنّ باقي قسمة الأعداد <code>10</code> و <code>100</code> و <code>1000</code> و... الخ على <code>5</code> هو <code>0</code>.

ولهذا فإنّ باقي قسمة <code>‎"5*1000 + 3*100 + 3*10 + 5"‎</code> على <code>5</code> مكافئ لباقي قسمة: ‎<code>0 + 0 + 0 + 5 = 5</code>‎، ولما كانت <code>5</code> تقبل القسمة على <code>5</code> فإن العدد <code>5335</code> يقبل القسمة على <code>5</code>.

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

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

* C++‎:

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

// تتحقق الدالة من كون العدد المعطى قابلاً للقسمة على 5
// تفترض الدالة أنّ طول السلسلة النصية هو 1 على الأقل
bool isDivisibleBy5(string str) 
{ 
	int n = str.length(); 

	return ( ((str[n-1]-'0') == 0) || 
			((str[n-1]-'0') == 5)); 
} 

// اختبار الشيفرة السابقة
int main() 
{ 
	string str = "76955"; 
	isDivisibleBy5(str)? cout << "Yes" : 
						cout << "No "; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">
# تتحقق الدالة من كون العدد المعطى قابلاً للقسمة على 5
# تفترض الدالة أنّ طول السلسلة النصية هو 1 على الأقل 
def isDivisibleBy5(st) : 
	return ((st[-1] == '0') or (st[-1] == '5'))

# اختبار الشيفرة السابقة
st = "76955"
if isDivisibleBy5(st) : 
	print("Yes")
else : 
	print("No")
	</source>
* جافا:

<source lang="java">class IsDivisible 
{ 
	// يتحقق التابع من كون العدد المعطى قابلاً للقسمة على 5
	// يفترض التابع أنّ طول السلسلة النصية هو 1 على الأقل 
	static boolean isDivisibleBy5(String str) 
	{ 
		int n = str.length(); 
	
		return ( ((str.charAt(n-1)-'0') == 0) || 
				((str.charAt(n-1)-'0') == 5)); 
	} 
	
	// اختبار الشيفرة السابقة
	public static void main (String[] args) 
	{ 
		String str = "76955"; 
		if(isDivisibleBy5(str)) 
			System.out.println("Yes"); 
		else
			System.out.println("No"); 
	} 
} 
</source>
== قابلية القسمة على 6 ==

يقبل العدد القسمة على <code>6</code> إذا كان يقبل القسمة على <code>2</code> و <code>3</code>، وهذا يعني أنّه يجب أن يحقق الشرطين التاليين:

# يقبل العدد القسمة على <code>2</code> إذا كان آخر رقم فيه قابلًا للقسمة على <code>2</code>.
# يقبل العدد القسمة على <code>3</code> إذا كان مجموع أرقامه قابلاً للقسمة على <code>3</code>.

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

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

* C++‎:

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

// تتحقق الدالة من قابلية قسمة العدد المعطى -كسلسلة نصية- على 6
bool check(string str) 
{ 
	int n = str.length(); 

	// يعيد هذا الشرط قيمة خاطئة إن لم يكن العدد قابلًا للقسمة على 2
	if ((str[n-1]-'0')%2 != 0) 
	return false; 

	// الوصول إلى هنا يعني أنّ العدد قابل للقسمة على 2
	// التحقق من قابلية القسمة على 3

	// حساب مجموع الأرقام
	int digitSum = 0; 
	for (int i=0; i<n; i++) 
		digitSum += (str[i]-'0'); 

	// التحقق من أن مجموع الأرقام قابل للقسمة على 3
	return (digitSum % 3 == 0); 
} 

// اختبار الدالة السابقة
int main() 
{ 
	string str = "1332"; 
	check(str)? cout << "Yes" : cout << "No "; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python"># تتحقق الدالة من قابلية قسمة العدد المعطى -كسلسلة نصية- على 6 
def check(st) : 
	n = len(st) 
	
	
	# يعيد هذا الشرط قيمة خاطئة إن لم يكن العدد قابلًا للقسمة على 2
	if (((int)(st[n-1])%2) != 0) : 
		return False

	# الوصول إلى هنا يعني أنّ العدد قابل للقسمة على 2
	# التحقق من قابلية القسمة على 3

	# حساب مجموع الأرقام
	digitSum = 0
	for i in range(0, n) : 
		digitSum = digitSum + (int)(st[i]) 

	# التحقق من أن مجموع الأرقام قابل للقسمة على 3
	return (digitSum % 3 == 0) 


# اختبار الشيفرة السابقة 
st = "1332"
if(check(st)) : 
	print("Yes") 
else : 
	print("No ") 
	</source>
* جافا:

<source lang="java">class IsDivisible 
{ 
	// تتحقق الدالة من قابلية قسمة العدد المعطى -كسلسلة نصية- على 6
	static boolean check(String str) 
	{ 
		int n = str.length(); 
	
		//  يعيد هذا الشرط قيمة خاطئة إن لم يكن العدد قابلًا للقسمة على 2 
		if ((str.charAt(n-1) -'0')%2 != 0) 
		return false; 
	
		// الوصول إلى هنا يعني أنّ العدد قابل للقسمة على 2
		// التحقق من قابلية القسمة على 3
		
		// حساب مجموع الأرقام
		int digitSum = 0; 
		for (int i=0; i<n; i++) 
			digitSum += (str.charAt(i)-'0'); 
	
		// التحقق من أن مجموع الأرقام قابل للقسمة على 3
		return (digitSum % 3 == 0); 
	} 
	
	// اختبار الدالة السابقة
	public static void main (String[] args) 
	{ 
		String str = "1332"; 
		if(check(str)) 
			System.out.println("Yes"); 
		else
			System.out.println("No"); 
	} 
} 
</source>
== قابلية القسمة على 7 ==

يمكن التحقق من قابلية قسمة عدد معين على <code>7</code> باستخدام طريقة تعاودية، وتعتمد هذه الطريقة على أنّ العدد الذي يكون بالصيغة <code>10a + b</code> قابلًا للقسمة على <code>7</code> إذا وفقط إذا كانت ناتج العملية <code>a - 2b</code> قابلاً للقسمة على <code>7</code>. وبمعنى آخر، نطرح ضعف الرقم الأخير من الرقم الناتج من بقية الأرقام، ونستمر في ذلك إلى حين الحصول على رقم يقبل القسمة على <code>7</code>.

فمثلًا: العدد 371: 

<source lang="text">37 – (2 × 1) = 37 – 2 = 35
3 – (2 × 5) = 3 – 10 = –7</source>
لمّا كان العدد <code>7–</code> يقبل القسمة على <code>7</code> فإنّ العدد <code>371</code> يقبل القسمة على <code>7</code>.

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

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

* C++‎:

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

int isDivisibleBy7( int num ) 
{ 
	// نحول العدد السالب إلى موجب
	if( num < 0 ) 
		return isDivisibleBy7( -num ); 

	// الحالات الأساسية
	if( num == 0 || num == 7 ) 
		return 1; 
	if( num < 10 ) 
		return 0; 

	// تستدعي الدالة نفسها 
	return isDivisibleBy7( num / 10 - 2 * 
			( num - num / 10 * 10 ) ); 
} 

// اختبار الشيفرة السابقة
int main() 
{ 
	int num = 616; 
	if( isDivisibleBy7(num ) ) 
		cout << "Divisible" ; 
	else
		cout << "Not Divisible" ; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">
def isDivisibleBy7(num) : 
	
	#  نحول العدد السالب إلى موجب
	if num < 0 : 
		return isDivisibleBy7( -num ) 

	# الحالات الأساسية
	if( num == 0 or num == 7 ) : 
		return True
	
	if( num < 10 ) : 
		return False
		
	# تستدعي الدالة نفسها
	return isDivisibleBy7( num / 10 - 2 * ( num - num / 10 * 10 ) ) 
	
# اختبار الشيفرة السابقة
num = 616
if(isDivisibleBy7(num)) : 
	print "Divisible"
else : 
	print "Not Divisible"
</source>
* جافا:

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

class GFG 
{ 
	static boolean isDivisibleBy7(int num) 
	{ 
		// تحويل العدد السالب إلى موجب
		if( num < 0 ) 
			return isDivisibleBy7( -num ); 

		// الحالات الأساسية
		if( num == 0 || num == 7 ) 
			return true; 
		if( num < 10 ) 
			return false; 

		// تستدعي الدالة نفسها
		return isDivisibleBy7( num / 10 - 2 * ( num - num / 10 * 10 ) ); 
	} 
	
	// اختبار الشيفرة السابقة
	public static void main (String[] args) 
	{ 
		int num = 616; 
		if(isDivisibleBy7(num)) 
			System.out.println("Divisible"); 
		else
			System.out.println("Not Divisible"); 
	} 
} </source>
تعطي الشيفرات السابقة المخرجات التالية: 

<source lang="text">Divisible</source>
== قابلية القسمة على 8 ==

يقبل العدد القسمة على <code>8</code> إن كان العدد المتشكِّل من الأرقام الثلاثة الأخيرة فيه قابلًا للقسمة على <code>8</code>.

'''مثال:''' الرقم <code>76952</code>.

العدد المتشكِّل من الأرقام الثلاثة الأخيرة هو <code>952</code>، ولمّا كان هذا العدد قابلًا للقسمة على <code>8</code> فإنّ العدد <code>76952</code> يقبل القسمة على <code>8</code>.

يمكن كتابة العدد <code>76942</code> بالصيغة:

<source lang="text">76942 = 7*10000 + 6*1000 + 9*100 + 5*10 + 2</source>
يمكن إثبات ذلك بالاستفادة من الملاحظة التالية:

يكون باقي قسمة العدد ‎<code>10^i</code>‎ على <code>8</code> مساويًا للصفر إن كانت <code>i >= 3</code>. أي أنّ باقي قسمة الأعداد <code>1000</code> و <code>10000</code> و... الخ على <code>8</code> هو <code>0</code>.

ولهذا فإنّ باقي قسمة المقدار ‎<code>"7*10000 + 6*1000 + 9*100 + 5*10 + 2"</code>‎ على <code>8</code> يكون مكافئًا لباقي المقدار ‎‎<code>0 + 0 + 9*100 + 5*10 + 2 = 952</code>‎.

وهكذا يمكن القول أنّ العدد الأصلي قابل للقسمة على <code>8</code> إن كانت <code>952</code> تقبل القسمة على <code>8</code>.

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

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

* C++‎:

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

bool check(string str) 
{ 
	int n = str.length(); 

	// سلسلة نصية فارغة
	if (n == 0) 
		return false; 

	// إن كان العدد أحادي المرتبة
	if (n == 1) 
		return ((str[0]-'0')%8 == 0); 

	// إن كان العدد ثنائي المرتبة
	if (n == 2) 
		return (((str[n-2]-'0')*10 + (str[n-1]-'0'))%8 == 0); 

	// إن كان العدد المكوّن من الأرقام الثلاثة الأخيرة يقبل القسمة على 8
	int last = str[n-1] - '0'; 
	int second_last = str[n-2] - '0'; 
	int third_last = str[n-3] - '0'; 

	return ((third_last*100 + second_last*10 + last) % 8 == 0); 
} 

// اختبار الشيفرة السابقة
int main() 
{ 
	string str = "76952"; 
	check(str)? cout << "Yes" : cout << "No "; 
	return 0; 
} 
</source>
* بايثون:

<source lang="python">def check(st) : 
	n = len(st) 
	
	# سلسلة نصية فارغة
	if (n == 0) : 
		return False

	# إن كان العدد أحادي المرتبة
	if (n == 1) : 
		return ((int)(st[0]) % 8 == 0) 

	# إن كان العدد ثنائي المرتبة
	if (n == 2) : 
		return ((int)(st[n - 2]) * 10 +
		((int)(str[n - 1]) % 8 == 0)) 

	# إن كان العدد المكوّن من الأرقام الثلاثة الأخيرة يقبل القسمة على 8 
	last = (int)(st[n - 1]) 
	second_last = (int)(st[n - 2]) 
	third_last = (int)(st[n - 3]) 

	return ((third_last*100 + second_last*10 +
							last) % 8 == 0) 


# اختبار الشيفرة السابقة
st = "76952"

if(check(st)) : 
	print("Yes") 
else : 
	print("No ") 
	</source>
* جافا:

<source lang="java">class IsDivisible 
{ 
	static boolean check(String str) 
	{ 
		int n = str.length(); 
	
		// سلسلة نصية فارغة 
		if (n == 0) 
			return false; 
	
		// إن كان العدد أحادي المرتبة
		if (n == 1) 
			return ((str.charAt(0)-'0')%8 == 0); 
	
		// إن كان العدد ثنائي المرتبة
		if (n == 2) 
			return (((str.charAt(n-2)-'0')*10 + (str.charAt(n-1)-'0'))%8 == 0); 
	
		// إن كان العدد المكوّن من الأرقام الثلاثة الأخيرة يقبل القسمة على 8 
		int last = str.charAt(n-1) - '0'; 
		int second_last = str.charAt(n-2) - '0'; 
		int third_last = str.charAt(n-3) - '0'; 
	
		return ((third_last*100 + second_last*10 + last) % 8 == 0); 
	} 
	
	// اختبار الشيفرة السابقة
	public static void main (String[] args) 
	{ 
		String str = "76952"; 
		if(check(str)) 
			System.out.println("Yes"); 
		else
			System.out.println("No"); 
	} 
} 
</source>
== قابلية القسمة على 9 ==

يكون العدد قابلًا للقسمة على <code>9</code> إذا كان مجموع أرقامه قابلًا للقسمة على <code>9</code>.

تتبع هذه الخوارزمية نفس الخطوات التي تتبعها خوارزمية قابلية القسمة على <code>3</code>، باستثناء أنّ الخطوة الأخيرة تتحقق من قابلية قسمة حاصل جمع الأرقام على <code>9</code> عوضًا عن <code>3</code>.

== مصادر ==

* صفحة [https://www.geeksforgeeks.org/check-large-number-divisible-3-not/ Check if a large number is divisible by 3 or not] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/check-large-number-divisible-4-not/ Check if a large number is divisible by 4 or not] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/check-large-number-divisible-6-not/ Check if a large number is divisible by 6 or not] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/divisibility-by-7/ Check divisibility by 7] في توثيق الخوارزميات في موقع GeeksforGeeks.
* صفحة [https://www.geeksforgeeks.org/count-rotations-divisible-8/ Count rotations divisible by 8] في توثيق الخوارزميات في موقع GeeksforGeeks.