اختبار الرقم الكبير .. هل هو أولي؟

الرقم هو عدد أولي إذا كان p عدد أولي و بالتالي يكفيك ان تقوم بالتحقق من طبيعة العدد p فإن كان اولي فإن ناتج المعادله هو عدد أولي.

و الله ولي التوفيق

السلام عليكم

مرحباً أخى مصطفى وأخى محمد مجدداً

اقتباس

الرقم 1-11^2 هو عدد أولي إذا كان p عدد أولي و بالتالي يكفيك ان تقوم بالتحقق من طبيعة العدد p فإن كان اولي فإن ناتج المعادله هو عدد أولي.

بالنسبة لإيجاد الأعداد الأولية فيوفر فريق GIMPS برامج من خلال موقعهم لمن يريد المشاركة فى إنتاج الأرقام الأولية , وأيضاً الهدف التالى للفريق هو إيجاد رقم أولى يصل عدد منازلة إلى مائة مليون منزلة 100,000,000 وهذا رقم ضخم جداً يفوق أكبر عدد تم التوصل إليه بمراحل كثيرة .

دمتم بخير

اقتباس

الرقم هو عدد أولي إذا كان p عدد أولي و بالتالي يكفيك ان تقوم بالتحقق من طبيعة العدد p فإن كان اولي فإن ناتج المعادله هو عدد أولي.

اقتباس

ليس دائماً فأنا أيضاً كنت أظن أن تلك المعادلة "معادلة ميرسن" تنتج أعداد أولية دائماً ولكن إتضح غير ذلك فهناك أرقام أولية عند وضعها فى تلك المعادلة لا يكون الناتج عدد أولى مثال على ذلك لو وضعنا للمعادلة أس 11 وهو عدد أولى فناتج المعادلة هو 2047 وهو عدد غير أولى لأنه يقبل القسمة على 89 و 23 لأنه مكون من حاصل ضربهما .

بالنسبة لإيجاد الأعداد الأولية فيوفر فريق GIMPS برامج من خلال موقعهم لمن يريد المشاركة فى إنتاج الأرقام الأولية , وأيضاً الهدف التالى للفريق هو إيجاد رقم أولى يصل عدد منازلة إلى مائة مليون منزلة 100,000,000 وهذا رقم ضخم جداً يفوق أكبر عدد تم التوصل إليه بمراحل كثيرة .

اكتشافكم الرائع سابق لعصره .... :wink:

تحياتي لك أخي محمد وأخي أحمد ... بارك الله فيكم ..

طبعاً لا يوجد حتى الآن أي متتالية رياضية أو معادلة تنتج أرقاماً أولية فقط ...

ولكن هناك متتاليات تكون بعض حدودها أرقاماً أولية ... مثل متتالية فيبوناتشي ومتتاية ميرسن التي بين يدينا ...

متتالية فيبوناتشي Vibonacci

lمتتالية لوكاس lucas

ويمكنكم الاطلاع على المزيد من المتتاليات من ويكيبيديا :

راجع منتصف الصفحة Prime number classes

ونحن هدفنا هو ايجاد رقم أولي ضمن النوع ميرسن الذي ينتج عن المتتالية

2 -1^p

تحياتي لكما وأرجو ان يكون الموضوع قد اتضح بشكل كامل .. لكما ...

لا أظن أنه سيمضي أكثر من شهر على كون المسألة محلولة على يد الأخ محمد علاء الدين ....

أنتظر رأيكم بالخوارزمية السابقة ,,, وشكراً جزيلا للمتابعة ...

والسلام عليكم

السلام عليكم

مصطفى 36a2 كتب:

طبعاً لا يوجد حتى الآن أي متتالية رياضية أو معادلة تنتج أرقاماً أولية فقط ...

ولكن هناك متتاليات تكون بعض حدودها أرقاماً أولية ... مثل متتالية فيبوناتشي ومتتاية ميرسن التي بين يدينا ...

متتالية فيبوناتشي Vibonacci

lمتتالية لوكاس lucas

ويمكنكم الاطلاع على المزيد من المتتاليات من ويكيبيديا :

راجع منتصف الصفحة Prime number classes

ونحن هدفنا هو ايجاد رقم أولي ضمن النوع ميرسن الذي ينتج عن المتتالية

2 -1^p

مصطفى 36a2 كتب:

تحياتي لكما وأرجو ان يكون الموضوع قد اتضح بشكل كامل .. لكما ...

تحياتى لك وأرجو أن يكون الموضوع قد إتضح بشكل كامل لديك .

وفى بداية حديثى عن موضوع الأعداد الأولية الكبيرة من فريق GIMPS قلت أنهم يوفرون برامج لهذا الغرض , هذه البرامج لا تعمل منفردة بل تعمل معاً كجهاز واحد لتوزيع وقت معالجة الأرقام وطريقة الإتصال بينهما وبين السرفر هى شبكة الإنترنت .

مصطفى 36a2 كتب:

ويمكننا على هذا الأساس أن نستعيض عن قابلية القسمة بالطرح عدد من المرات وعندما نصل إلى رقم منازله هي نفس منازل المقسوم عليه وهو أصغر من المقسوم عليه ولا يساوي الصفر

نقول أن العدد لا يقبل القسمة على المقسوم عليه ...

أنتظر رأيكم بالخوارزمية السابقة ,,, وشكراً جزيلا للمتابعة ...

ننتظر منك تحويل الخوارزمية لكود , وضع فى إعتبارك عامل الوقت كما أسلفت الذكر سلفاً .

دمتم بخير

معك حق أخي أحمد ... ما شاء الله عليك .. تفكير استراتيجي رائع .. :thumb_up: :clapping:

اقتباس

وماذا بعد عزيزي هل توصلت لشيئ جديد يفيدنا فى موضوعنا

لا أظن أنه سيفيدنا شيء غير ما نعرفه ... فالموضوع محدود جداً .. والله أعلم ..

كما قلت .. الوقت عامل حاسم في الحل ... وطبعا لا بد ان نمر على أهم خطوة في اي برنامج وهي (تحسين الكود )

ان شاء الله يكون الكود جاهزاً في يوم الجمعة كحد أقصى ..بإذن الله ..

وباختصار كل ما علينا حالياً هو تعريف عملية الطرح .. للأرقام الكبيرة

والسلام عليكم

بسم الله الرحمن الرحيم

السلام عليكم ورحمة الله وبركاته ..

نتابع في موضوعنا ... حيث أن هدفنا الحالي هو تعريف عملية الطرح لعدد غير محدود المنازل ..

وسوف ندرس الحالة بالنسبة لمصفوفة .. حيث أصبح من السهل تحويل برنامج يستخدم المصفوفات إلى برنامج يستخدم الملفات الخارجية ... والحمد لله ..

أما بعد ...

تتلخص الفكرة كما يلي ..

نعرف طرح منزلة واحدة في كل مرة .. ثم نقوم بعمل حلقة تشمل جميع منازل الرقم

والتابع المستعمل سيكون من هذا الشكل :

//a الرقم الأول 
//الرقم الثاني b
//الناتج c
//الاستلاف من المرتبة التالية z
function
{
	a-=z;//أولا نطرح من الرقم الاستلاف وهو واحد أو صفر
	if(a>=b){c=a-b;z=0;}//إذا كان الأول أكبر من الثاني فالطرح عادي دون استلاف 
	else {c=10+a-b;z=1;}//إذا كان الرقم الأول أصغر من الثاني نستلف من المرتبة التالية 
}

هكذا يمكننا تعريف الطرح بالنسبة لرقم واحد

وبعمل حلقة على كل عناصر المصفوفة نكون قد عرفنا عملية الطرح بسكل كامل ..

وبقي لنا أن نعرف عملية القسمة بشكل كامل ...

والفكرة كما شُرحت سابقاً هي عملية الطرح حتى نصل إلى رقم لا يقبل الطرح ...

وهنا يجب أن نزيح الرقم (نضربه بعشرة )عدداً من المرات حتى يبلغ نفس عدد منازل الرقم الكبير .. كما مر سابقاً ..

والله ولي التوفيق

والسلام عليكم

السلام عليكم

فى إنتظار البرنامج للخوارزمية عزيزى مصطفى

دمت بود , ووفقك الله لما يحبه ويرضاه

بسم الله الرحمن الرحيم

أعتذر على توقف الموضوع لفترة إلا أنني تعرفت على شيء يسمّى الهندسة العكسية قلب مفهومي عن البرمجة رأساً على عقب وسأبين السبب خلال الموضوع

أولاً ... كود يقوم بعملية طرح مصفوفتين

#include<iostream.h>
#include<string.h>
#include<iomanip.h>
int C_size=10;
void mine(char&a,char&b,char&c,char&z)//a-b=c and z is to take from the next digit
{//هنا تجد خوارزمية طرح عددين كاملة متكاملة خالية من الأخطاء بإذن الله 
//أرجو تجريبها وتنقيحها لأننا سنعتمد عليها كلّياً في عملية الطرح
	a-=48;b-=48;
	a-=z;
	if(a>=b){c=a-b;z=0;}
	else  {c=10+a-b;z=1;}
	a+=48;b+=48;c+=48;
}
void change_to_char(char W[])//هنا نقوم بتحويل الحرف 1 إلى الرقم 1 
{
	for(int i=0;W!='\0';i++)
		W-=48;
}
void minus(char C[],char A[],char B[])
{
	char take=0;
	for(int i=0;i<C_size&&B!='\0'&&A!='\0';i++)
		mine(A,B,C,take);
	if(B==0)//هذه هي الحالة النظامية أن ينتهي الرقم الثاني قبل الأول لأنّه أصغر والجواب موجب
		for(char x='0';A!=0;i++)
			mine(A,x,C,take);//c=a-0
/*	else if(A=='\0')//لن نتعامل مع هذه الحالة حيث الجواب سالب والعملية هنا تعطي متمم العدد 
		for(char x='0';i<C_size;i++)
			mine(x,B,C,take);
*/}
void revers(char W[],int size)
{
	char buffer=0;
	for(int i=0;i<size/2;i++)
	{
		buffer=W;
		W=W[size-i-1];
		W[size-i-1]=buffer;
	}
}
void out(char C[])
{
	for(int i=C_size-1;i>=0;i--)
		cout<<C;
}
void init(char W[],int size)
{
	for(int i=0;i<size;i++)
		W='0';
}
int max(int a,int b)
{return (a>b?a:b);}
int min(int a,int b)
{return (a<b?a:b);}
void main()
{
	char* A_=new char[1000];
	char* B_=new char[1000];
	cin>>A_;
	cout<<setw(strlen(A_))<<setfill(' ')<<'-'<<endl;
	cin>>B_;
	cout<<setw(max(strlen(A_),strlen(B_)))<<setfill('_')<<'='<<endl;
	char* A=new char[strlen(A_)];init(A,sizeof(A));
	char* B=new char[strlen(B_)];init(B,sizeof(B));
	strcpy(A,A_);
	strcpy(B,B_);
	delete A_;
	delete B_;
	//كل العمليات السابقة غير مهمة وهي فقط من أجل جعل المصفوفة ممتلئة بالكامل لتفادي الأخطاء
	revers(A,strlen(A));
	revers(B,strlen(B));
	C_size=max(strlen(A),strlen(B));//طول الناتج هو طول أكبر عدد بين المطروحين وفي حالتنا سيكون الأول أكبر دائما
	char *C=new char[];
	init(C,C_size);//init : initial لتمهيد المصفوفة بالأصفار
	minus(C,A,B);//C=A-B
	out(C);//إظهار العدد
	cin>>A[0];//فقط لإيقاف العرض .. لم أرد أن أضمن المزيد من المكاتب
}

والآن أصبح بإمكاننا طرح مصفوفتين ويمكننا تعميم الحالة من أجل طرح عددين في ملفين

ثانياً أردت أن أنوه إلى عدة امور :

أمر الهندسة العكسية : في الحقيقة منذ بداية تعلمي البرمجة وأنا أحب أن افتح ملف الexe بواسطة النوتباد لأرى كيف يتم التطبيق ... وكما يفترض لم أفهم شيئاً

ولكن عندما رأيت طريقة تتبع البرنامج في الهندسة العكسية فهمت كل شيء وإليكم ما استفدته من هذه التجربة ..

لغة التجميع هي الأصل فهي تتعامل مباشرة مع المعالج والمسجلات وتقوم بالعمليات المعقدة بطرق في قمة البساطة .. هذا ولم نذكر السرعة الفائقة لذلك..

وبما ان عملياتنا التي نريد القيام بها لا تتعدى العمليات الرياضية فإن البرمجة بأي لغة عالية المستوى لن تسبب إلى الكثيييييييييير من الانتظار لحين الحصول على النتائج (أنا مُصرّ على أنه يمكننا على أجهزتنا البسيطة الامكانيات مواجهة التحدي ولكن نحتاج إلى الطريقة السليمة والخوارزمية الصحيحة )

أعطيكم مثالاً على إنجاز أسرع البرامج التي عملتها حتى الآن :

Program's Report:
The Number Is 
2^3000000
Number of Digits :
903090
Calculate Time:
14441.8 Seconds

كان ذلك باستخدام المصفوفات فقط وفي المسافة من 3ملايين إلى 4 ملايين أي ثلث المسافة السابقة تخيلوا ماذا كان الوقت المستغرق(حيث استخدمنا طريقة النقل والاستيراد من والى الملفات )

Program's Report:
The Number Is 
2^4000000
Number of Digits :
1204120
Calculate Time:
154149 Seconds

استغرق 46 ساعة ... وقت هائل ... ولكن بالنظر إلى الخوارزمية المتبعة لا يجب أن يستغرق كل ذلك الوقت ... ما يؤدي إلى الجزم بأن طريقة عمل البرنامج والنابعة من لغة البرمجة التي استخدمناها أدت إلى الكثير من التعقيدات ... :wacko:

لذلك أقول لكم ببساطة ... إن كل ما سنقوم به لن يتجاوز كتابة الخوارزمية الصحيحة ... واختبارها على لغاتنا البطيئة ... وعند التأكد التام من صحتها فلن يكون أمامنا عند المواجهة الحقيقة مع التطبيق سوى أن نلجأ إلى العمليات الأساسية للمعالج

وإلى لغة التجميع ....... تحية قوية إلى مبرمجي الأسمبلي ...

التنويه الثاني : وجدت أنه من المناسب كتابة الخوارزمية البسيطة التالية والتي تبين تكافؤ التعامل مع المصفوفة والتعامل مع الملف .. وهذا برأيي في قمة الأهمية حيث يمكن تعميم كل حالات المصفوفات الزائلة والمحدودة إلى حالات الملفات الدائمة واللامحدودة(إلا إذا كنا نعتبر أن ملف txt بحجم 60 غيغا ((ملف محدود)))

والخوارزمية كما يلي :

//بداية يجب تضمين مكتبة 
#include<fstream.h>
//للتعامل مع الملفات
//أولا التمهيد 
//(سنتعامل مع أسوأ الحالات)تعريف المصفوفة 
const unsigned long Size; 
char Array[Size];
//تعريف الملف
fstream file("filename",ios::in|ios::out);
//رقم ثانياً الوصول إلى العنصر 
//i في المصفوفة
Array
//الوصول للعنصر في الملف للقراءة
file.seekg(i);
buffer=file.get();
//هو متحول مؤقت للتعامل مع العناصر buffer
//الوصول للعنصر للكتابة
file.seekp(i);
file.put(buffer);
////////////////////////////////
//والآن إذا أردنا أن نقرأ عنصر ونجري عملية ثم نكتب العنصر الجديد مكان العنصر السابق 
//في مصفوفة
Array=function(Array);
//في الملف
file.seekg(i);
buffer=file.get();
function(&buffer);
file.seekp(i);
file.put(buffer);
/////////////////
//مع تحياتي 
//mostafa 36a2

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

نلتقي بإذن الله والسلام عليكم ورحمة الله وبركاته

ملحوظة: إجراء العمليات الحسابيه على مصفوفه رقمية بمساحة 1 بايت للعنصر أبطء كثيرا من اجراء العمليات الحسابيه على مصفوفه رقميه بمساحة 2 بايت للعنصر و بالمثل مع الأنواع الصحيحه الإفتراضيه ذات المساحه الأكبر، فما بالك بأن المصفوفه هى مصفوفه حروف و يتم تحويلها وقت التشغيل لمصفوفه ارقام بالإضافه إلى ان كل عنصر بدلا من ان يمثل الأرقام فى المدى 0 إلى 255 أصبح يمثل الأرقام من 0 إلى 9.

* فى كتاب The Art of Computer Programming الجزء الثاني الفصل الرابع المقطع الثالث (The Classical Algorithms): فى هذا الجزء يتم شرح algorithms لتطبيق عملية الجمع و الطرح و الضرب و القسمه و باقي القسمه و التى إن قمت بتضمينهم و دققت جيدا فيما تفعل و اخترت إساليب مختصره ستجد ان عملية قسمة محتويات مصفوفه بمساحة 8192 بت على اخر بنفس المساحه (جميع البتات مستخدمه) سيأخذ وقت أقل من 5 ثوان و يزداد الوقت بجعل مساحة المقسوم عليه أقل ليصل الوقت اقصاه 15 ثانيه عندما يكون عدد البتات المستهكله 64 بت و فى حالة 32 بت فتوجد عملية مختصره تقوم بحساب الناتج فى ثانتين - أو أقل - و يمكنك الإطلاع عليها فى موضوع الحصول على رقم 2 مرفوع للأس 30 مليون - غير متذكر قيمة الرقم بالتحديد.

الوقت السابق يحده عدد المعالجات المستخدمه و حجم الذاكره فكلما كان حجم الذاكره المتاحه أكبر يمكن إعادة تضمين العمليات بشكل يتيح لها ان تكون اسرع بكثر، أيضا إذا تم تفعيل Vector Extensions مثل SSE سيتساعد كثيرا فى تسريع العمليه اكثر و اكثر.

قمت بكتابة نسخه للقسمه و تم جعل المعالج يعمل بأقصي طاقته و ايضا تم تفعيل SSE2 حينها عملية القسمه التى استهلكت 10 ثواني لم تكمل 3.

خلاصة السابق: حساب الجذر التربيعي الصحيح او عملية الضرب او المقارنه لا يستهلكوا وقت على الإطلاق، ما يستهلك الوقت هو تنفيذ عملية القسمه لذا ضع كل جهودك بها فكلما كانت اسرع كلما انتهي التنفيذ اسرع.

اقتباس

ولكن بالنظر إلى الخوارزمية المتبعة لا يجب أن يستغرق كل ذلك الوقت ... ما يؤدي إلى الجزم بأن طريقة عمل البرنامج والنابعة من لغة البرمجة التي استخدمناها أدت إلى الكثير من التعقيدات

على عكس ما تعتقد الخوارزميه ليست المشكله و لكن طريقة تطبيقها هو المشكله فيمكن كتابة خوارزميه واحده بأكثر من طريقه و ستجد ان احدهم افضل من الأخرى فى جانب و كذلك الأول أفضل من الاخرى فى جانب أخر.

المترجم سيقوم بإنتاج كود افضل كثيرا مما ستكتبه بنفسك، إلا بالطبع لو كنت خبير بلغة الأسمبلي حينها يمكن مقارنة الكود الناتج بالكود الخاص بك و حينها الكافه الراجحه ستكون للمترجم فى الأغلب للكثير من الأسباب ان الكود الناتج من المترجم يعتمد على الكثير من العوامل مثل اسلوب تعريف المتغيرات فتعريف متغير بـ const يختلف عن متغير عادى فالأول يتيح تطبيق تحسينات عليه بشكل كبير ام الأخر فالتحسينات التى تتم عليه اقل من السابق، أيضا موقع الـ struct لإى الذاكره هام فلابد من وضع الـ alignment فى الحسبان و غيره و غيره.

و الله ولي التوفيق

والله يا أستاذي محمد ... الموضوع يحتاج لأمثالك خصوصاً عند الدخول في هذه الأمور ...

على كل حال أنا أتابع العمل على قدر مستواي ... أحتاج يومين آخرين حتى اكتمال الكود تماماً ... (طبعاً مع البطء النسبي في التنفيذ)

ولكن هل بإمكانك أستاذي أن تعلمنا بعض الأمور الجديدة التي تفيدنا في هذا الموضوع ...

أشكرك على وقتك الذي تصرفه علينا ...

جزاك الله خيراً ...

والسلام عليكم

كود للقسمة وباقي القسمة باستخدام المصفوفات :

أرجو الاختبار والتطوير:

#include<iostream.h>
#include<string.h>
#include<iomanip.h>
#include<sometime.h>
////////////////////////////////
#define Show(size,num)	{cout<<"A = ";Out_Array(A,size,num);cout<<endl;cout<<"B = ";Out_Array(B,size,num);cout<<endl;cout<<"C = ";Out_Array(C,size,num);cout<<endl;cout<<endl;}
#define endll cout<<endl;
void Out_Array(char *x,int size=10,int num=0)
{
	for(int i=0;i<size;i++)cout<<char(x+num);}
///////////////////////////////
void change_to_chars(char W[])
{
	for(int i=0;W!='\0';i++)
		W-=48;
}
void change_to_numbers(char W[],int Wsize)
{
	for(int i=0;i<Wsize;i++)
		W+=48;
}
int max(int a,int b){return (a>b?a:b);}
int min(int a,int b){return (a<b?a:b);}
//////////////////////////////////////////////////
void init(char W[],int size,char a='0')
{
	for(int i=0;i<size;i++)
		W=a;
}
char* MakeSameSize(char *a,int old_size,int new_size)
{
	char *c=new char[new_size+1];
	c[new_size]=0;
		for(int i=0;i<new_size-old_size;i++)
			c='0';
		for(int j=0;i<new_size;i++,j++)
			c=a[j];
	return c;
}
bool compare(char*c,char*b,int size)
{
	for(int i=0;i<size;i++)
	{
	if(c>b){return 1;}
	else if(c<b){return 0;}
	}
		return 1;
}
///////////////////////////////////
void mine(char a,char b,char&c,char&z)
{	a-=z;
	if(a>=b){c=a-b;z=0;}
	else  {c=10+a-b;z=1;}
}
void minus(char *C,char *A,char *B,int size)
{
	char take=0;
	for(int i=size-1;i>=0;i--)
		mine(A,B,C,take);
}
////////////////////////////////////
int HowManyDigitsBig(char*c,char*b,int size)
{
	int itsBig=0;
	for(int i=0;i<size&&(c>b||(c==b&&i>0))&&b==0;i++)
		itsBig++;
	return itsBig;
}
int ShiftLeft(char *A,int size,int ShiftDigits)
{
	for(int i=0;i<size&&A==0;i++);
	for(;i<size;i++)
			A[i-ShiftDigits]=A;
	for(i=size-ShiftDigits;i<size;i++)
		A=0;
	return ShiftDigits;
}
int ShiftRight(char *A,int size,int ShiftDigits)
{
	for(int i=0;i<size&&A==0;i++);
	for(i=size-1;i>=ShiftDigits;i--)
		A=A[i-ShiftDigits];
	for(;i>=0;i--)
		A=0;
	return ShiftDigits;
}
int exp10(int B)
{
	int B10=1;
	for(int i=0;i<B;i++)
		B10*=10;
	return B10;
}
void SimpleSum(char&A,int a)
{
	if(A>=9)
	{A=0;
	SimpleSum((*(&A-1)),1);
	}
	else {A++;}
}
char* divide(char*A,char*B,char*C,int size)
{
	char*result=new char[size];
	init(result,size,0);
	for(int i=0;i<size;i++)C=A;
	int Biggy;
	int shifts=0;
	while(compare(C,B,size)||shifts!=0)
	{
		if((!compare(C,B,size))&&shifts!=0){ShiftRight(B,size,1);shifts--;}
	Biggy=HowManyDigitsBig(C,B,size);
	if(Biggy>1)
	{shifts+=ShiftLeft(B,size,(Biggy-1));}
	if((!compare(C,B,size))&&Biggy>1)ShiftRight(B,size,1);
	while(compare(C,B,size))
	{
		minus(C,C,B,size);//C-=B;
		if(Biggy>1||shifts>0)SimpleSum(result[size-shifts-1],1);
		else SimpleSum(result[size-1],1);
	}
	if(Biggy>1){shifts-=ShiftRight(B,size,1);}
	}
	return result; 
}
bool is_full_of(char a,char*A,int size)
{
	for(int i=0;i<size;i++)
	{if(A!=a){return 0;}}
		return 1;
}
bool is_zero(char*A,int size)
{
	return is_full_of('0',A,size);
}
bool is_zero(int size,char*A)
{
	return is_full_of(0,A,size);
}
void main()
{
	char* A_=new char[1000];
	char* B_=new char[1000];
	cin>>A_;
	cout<<setw(strlen(A_))<<setfill(' ')<<'/'<<endl;
	cin>>B_;
	cout<<setw(max(strlen(A_),strlen(B_)))<<setfill('_')<<'='<<endl;
	char* A=new char[strlen(A_)+1];init(A,strlen(A));
	char* B=new char[strlen(B_)+1];init(B,strlen(B));
	strcpy(A,A_);
	strcpy(B,B_);
	delete A_;
	delete B_;
	if(strlen(A)>strlen(B))
		B=MakeSameSize(B,strlen(B),strlen(A));
	else
		A=MakeSameSize(A,strlen(A),strlen(B));
	char *C=new char[strlen(B)+1];
	init(C,strlen(B)+1);
	C[strlen(B)]=0;
	int size=strlen(B);
	change_to_chars(A);
	change_to_chars(B);
	change_to_chars(C);
	char*result=divide(A,B,C,size);//C=A%B
	change_to_numbers(C,size);
	change_to_numbers(A,size);
	change_to_numbers(B,size);
	change_to_numbers(result,size);
	Out_Array(result,size);
	if(!is_zero(C,size))
	{cout<<" and ";//Modulus
	Out_Array(C,size);
	cout<<"/";
	Out_Array(B,size);}
	cin>>A[0];
}

أعتذر أولا على التأخير وثانيا على عدم الشرح ...

وأود أن أسأل أخيراً ... إن كان أستاذنا محمد يرى أن الموضوع بلا جدوى حتى نتوقف ...

والله ولي التوفيق ...

والسلام عليكم ورحمة الله وبركاته

السلام عليكم

اقتباس

وأود أن أسأل أخيراً ... إن كان أستاذنا محمد يرى أن الموضوع بلا جدوى حتى نتوقف ...

وكما قلت لك كنت قد كتبت كود لإيجاد قسمة الأعداد الكبيرة بفرض أنها موجودة فى ملفات ولكن لم أحفظه فى ملفاتى وضاع بعد تغيير نظام التشغيل , عموماُ بما أن الموضوع يهمك قمت بكتابتة مرة أخرى والطريقة التى يعتمد عليها الكود هى كما قلت سابقاً تعتمد فى الأساس على عملية الجمع حتى نتلاشى العقبات التى ستواجهنا إذا إستخدمنا الطريقة الإعتيادية للقسمة وتتمثل الطريقة بإختصار بجمع مضاعفات العدد المقسوم علية حتى نصل لأقل قيمة تحت العدد المقسوم مكونة من مضاعفات العدد المقسوم علية ونقوم بإضافة العدد المقسوم علية فإن ساوى العدد المقسوم يكون هذا العدد المقسوم يقبل القسمة على المقسوم علية وإن لم يكن فلا يقبل القسمة على المقسوم علية .

وهذا هو الكود بلغة php على إعتبارة بيذيدوكود , يمكن تجربتة من خلال سرفر محلى وهو يعتمد على دالة جمع عددين التى تم شرحها فى هذا الموضوع

<?php 
// قية الرقم المراد قسمتة 
$NUM="2055"; 
$START_NUM="0"; 
$NUM_temp="0"; 
// المقسوم عليه 
$div_num="5"; 
$div_num_temp=$div_num; 
/*  
 * بإختصار تقوم تلك الحلقة بمضاعفة الرقم المقسوم علية وحفظ القيمة قبل المضاعفة فإن كان قيمة الرقم المضاعف 
 * أكبر من قيمة الرقم المراد قسمتة يتم إعادة القيمة المخزنة قبل المضاعفة وزيادة قيمة الرقم المقسوم عليها والبدأ فى المضاعفة مرة أخرى وهكذا  
 * إلى أن تقل القيمة المضافة إلى أن تصل إلى ضعف العدد المقسوم علية أو زيادة العدد المقسوم نفسة 
 * وفى هذه الحالة إما أن يكون العدد مساوى للعدد المقسوم وبالتالى فهو يقبل القسمة على العدد المقسوم علية وإلا فهو لا يقبل القسمة 
 * */ 
while(true) 
{ 
	$GEL=GELthan(sum_Func($START_NUM,$div_num_temp),$NUM); 
	//echo "GELthan(sum_Func($START_NUM,$div_num_temp),$NUM)"."<br>"; 
	//echo sum_Func($START_NUM,$div_num_temp)."<br>"; 
	//echo $GEL; 
	if($GEL==0||$GEL==1) 
	{ 
		if(equal_Fun($div_num_temp,sum_Func($div_num,$div_num))) 
		{ 
			if(equal_Fun(sum_Func($START_NUM,$div_num),$NUM)==true || equal_Fun(sum_Func(sum_Func($START_NUM,$div_num),$div_num),$NUM)==true) 
			{ 
				echo "<h1>yes</h1>"; 
			} 
			else 
			{ 
				echo "<h1>No</h1>"; 
			} 
			break; 
		} 
		$START_NUM=sum_Func($START_NUM,$temp); 
		$div_num_temp=$div_num; 
	} 
	$temp=$div_num_temp; 
	$div_num_temp=sum_Func($div_num_temp,$div_num_temp); 
	//echo "<h1>$div_num_temp</h1>"; 
} 

// دالة إختبار تساوى رقمين 
function equal_Fun($var1,$var2) 
{ 
	// طول السلسة 
	$var1Len=strlen($var1); 
	$var2Len=strlen($var2); 
	// شرط تساوى السلسة 
	if($var1Len==$var2Len) 
	{ 
		// حلقة المرور على كل عناصر السلسة 
		for($i=0;$i<$var1Len;$i++) 
			if($var1[$i]!=$var2[$i]) return false; 
	} 
	else return false; 
	return true; 
	// فى حالة إختلاف طول السلسة يعود بالقيمة خطأ وفى حالة تساوى السلسلتين وتساوى قيمهم تعود بالقيمة الصحيحة  
} 

/* دالة تعود بالقيمة 0 فى حالة تساوى السلسلتين وتعود بالقيمة 1 إذا كان المتغير الأول أكبر من الثانى وتعود بالقيمة -1  
إذا كانت قيمة المتغير الأول أضغر من قيمة المتغير الثانى */ 
function GELthan($var1,$var2){ 
	if(equal_Fun($var1,$var2)) return 0; 
	$var1Len=strlen($var1); 
	$var2Len=strlen($var2); 
	if($var1Len==$var2Len){ 
		for($i=0;$i<$var1Len;$i++) 
			if($var1[$i]>$var2[$i]) return 1; 
			else if($var1[$i]<$var2[$i]) return -1; 
	}else if($var1Len>$var2Len) 
		return 1; 
	else 
		return -1; 
} 

// دالة جمع رقمين وتم شرحها من قبل فى المشاركات السابقة 
function sum_Func($var1,$var2) 
{ 
	$var1_Len=strlen($var1); 
	$var2_Len=strlen($var2); 
	if($var1_Len<$var2_Len){ 
		$temp=$var1_Len; 
		$var1_Len=$var2_Len; 
		$var2_Len=$temp; 
		$temp2=$var1; 
		$var1=$var2; 
		$var2=$temp2; 
	} 
	//echo $var1_Len."<br>"; 
	//echo $var2_Len."<br>"; 
	$var1_Len2=$var1_Len; 
	$reValueX=""; 
	$caryVar=0; 
	for($i=$var2_Len-1;$i>=0;$i--) 
	{ 
		$var1_Len2--; 
		if(((int)$var1[$var1_Len2]+(int)$var2[$i]+$caryVar)<10){ 
			$reValueX.=((int)$var1[$var1_Len2]+(int)$var2[$i]+$caryVar); 
			$caryVar=0; 
		}else if(((int)$var1[$var1_Len2]+(int)$var2[$i]+$caryVar)==10){ 
			$reValueX.="0"; 
			$caryVar=1; 
		}else{ 
			$reValueX.=((int)$var1[$var1_Len2]+(int)$var2[$i]+$caryVar)%10; 
			$caryVar=1; 
		} 
	} 
	if($var1_Len==$var2_Len){ 
		if($caryVar==1) {$reValueX.="1";$var1_Len++;} 
	}else{ 
		while($var1_Len2!=0) 
		{ 
			$var1_Len2--; 
			if(((int)$var1[$var1_Len2]+$caryVar)<10){ 
				$reValueX.=(int)$var1[$var1_Len2]+$caryVar; 
				$caryVar=0; 
			}else if(((int)$var1[$var1_Len2]+$caryVar)==10){ 
				$reValueX.="0"; 
				$caryVar=1; 
			}else{ 

			} 
		} 
		if($caryVar==1) {$reValueX.="1";$var1_Len++;} 
	} 
	$reValue=""; 
	for($i=$var1_Len-1;$i>=0;$i--) 
		$reValue.=$reValueX[$i]; 
	return $reValue; 
} 

?>

طبعاً ستضع المقسوم فى المتغير NUM$ والمقسوم عليه فى المتغير div_temp$ , وكما فى البرنامج السابق لإيجاد الرقم الأولى بنفس الطريقة لكيفية التعمل مع الملفات

يرجى أخى مصطفى تحويل الكود للغة ++c حتى يستفيد منه أعضاء القسم .

دمتم بخير

P-index.php

ما شاء الله عليك أخي أحمد ... أنتظر منك أن تتعلم الC++ في الصيف وترتاح من الwamp وال apache

أظن أنني فهمت فكرتك .. ولكن هناك بعض الملاحظات فمثلاً الخوارزمية ستأخذا الكثير من الوقت حتى تصل إلى الناتج تخيل كم عملية مضاعفة سنقوم بها للوصول إلى ناتج قسمة 100000000000 على 1 .ولكن على أي حال سأبذل جهدي لترجمته للغتنا حتى يتسنى لباقي الاخوة فهمه ...

أما بالنسبة لفكرة البرنامج السابق .. والذي لم يتسنى لي شرحه في وقته ففكرته تتلخص بالطرح (على عكس فكرتك أخي ) ولكنني لم أتم فكرة الاختبار بل هو لإيجاد ناتج وباقي القسمة فقط

حيث نقوم بالطرح حتى نصل إلى الصفر إن كان يقبل القسمة أو إلى رقم أقل من المقسوم عليه وهو الباقي...

أما بالنسبة لتحويل الكود من مصفوفات إلى ملفات ... فالفكرة كنت قد شرحتها في كود سابق وإليك الإعادة :

//بداية يجب تضمين مكتبة 
#include<fstream.h>
//للتعامل مع الملفات
//أولا التمهيد 
//(سنتعامل مع أسوأ الحالات)تعريف المصفوفة 
const unsigned long Size; 
char Array[Size];
//تعريف الملف
fstream file("filename",ios::in|ios::out);
//رقم ثانياً الوصول إلى العنصر 
//i في المصفوفة
Array
//الوصول للعنصر في الملف للقراءة
file.seekg(i);
buffer=file.get();
//هو متحول مؤقت للتعامل مع العناصر buffer
//الوصول للعنصر للكتابة
file.seekp(i);
file.put(buffer);
////////////////////////////////
//والآن إذا أردنا أن نقرأ عنصر ونجري عملية ثم نكتب العنصر الجديد مكان العنصر السابق 
//في مصفوفة
Array=function(Array);
//في الملف
file.seekg(i);
buffer=file.get();
function(&buffer);
file.seekp(i);
file.put(buffer);
/////////////////
//مع تحياتي 
//mostafa 36a2

من هنا إلى حين الانتهاء من تحويله أستودعكم الله والسلام عليكم

السلام عليكم

اقتباس

ما شاء الله عليك أخي أحمد ... أنتظر منك أن تتعلم الC++ في الصيف وترتاح من الwamp وال apache

اقتباس

أظن أنني فهمت فكرتك .. ولكن هناك بعض الملاحظات فمثلاً الخوارزمية ستأخذا الكثير من الوقت حتى تصل إلى الناتج تخيل كم عملية مضاعفة سنقوم بها للوصول إلى ناتج قسمة 100000000000 على 1

اقتباس

أما بالنسبة لفكرة البرنامج السابق .. والذي لم يتسنى لي شرحه في وقته ففكرته تتلخص بالطرح (على عكس فكرتك أخي ) ولكنني لم أتم فكرة الاختبار بل هو لإيجاد ناتج وباقي القسمة فقط

دمت على خير

وعليكم السلام أخي أحمد ...

بالنسبة للطرح فقد كانت فكرتي هي التالية :

قبل القيام بعملية الطرح علينا إزاحة الرقم إلى أن يصبح بنفس عدد منازل الرقم الأول كما يلي:

أما إذا كان المقسوم عليه أكبر ... فالحل كما يلي :

وعلى هذا الأساس بُنيت خوارزمية الحل الذي قدمتُه :

#include<iostream.h>
#include<string.h>
#include<iomanip.h>
#include<sometime.h>
////////////////////////////////
#define Show(size,num)  {cout<<"A = ";Out_Array(A,size,num);cout<<endl;cout<<"B = ";Out_Array(B,size,num);cout<<endl;cout<<"C = ";Out_Array(C,size,num);cout<<endl;cout<<endl;}
#define endll cout<<endl;
void Out_Array(char *x,int size=10,int num=0)
{
        for(int i=0;i<size;i++)cout<<char(x+num);}
///////////////////////////////
void change_to_chars(char W[])
{
        for(int i=0;W!='\0';i++)
                W-=48;
}
void change_to_numbers(char W[],int Wsize)
{
        for(int i=0;i<Wsize;i++)
                W+=48;
}
int max(int a,int b){return (a>b?a:b);}
int min(int a,int b){return (a<b?a:b);}
//////////////////////////////////////////////////
void init(char W[],int size,char a='0')
{
        for(int i=0;i<size;i++)
                W=a;
}
char* MakeSameSize(char *a,int old_size,int new_size)
{
        char *c=new char[new_size+1];
        c[new_size]=0;
                for(int i=0;i<new_size-old_size;i++)
                        c='0';
                for(int j=0;i<new_size;i++,j++)
                        c=a[j];
        return c;
}
bool compare(char*c,char*b,int size)
{
        for(int i=0;i<size;i++)
        {
        if(c>b){return 1;}
        else if(c<b){return 0;}
        }
                return 1;
}
///////////////////////////////////
void mine(char a,char b,char&c,char&z)
{   	a-=z;
        if(a>=b){c=a-b;z=0;}
        else  {c=10+a-b;z=1;}
}
void minus(char *C,char *A,char *B,int size)
{
        char take=0;
        for(int i=size-1;i>=0;i--)
                mine(A,B,C,take);
}
////////////////////////////////////
int HowManyDigitsBig(char*c,char*b,int size)
{
        int itsBig=0;
        for(int i=0;i<size&&(c>b||(c==b&&i>0))&&b==0;i++)
                itsBig++;
        return itsBig;
}
int ShiftLeft(char *A,int size,int ShiftDigits)
{
        for(int i=0;i<size&&A==0;i++);
        for(;i<size;i++)
                        A[i-ShiftDigits]=A;
        for(i=size-ShiftDigits;i<size;i++)
                A=0;
        return ShiftDigits;
}
int ShiftRight(char *A,int size,int ShiftDigits)
{
        for(int i=0;i<size&&A==0;i++);
        for(i=size-1;i>=ShiftDigits;i--)
                A=A[i-ShiftDigits];
        for(;i>=0;i--)
                A=0;
        return ShiftDigits;
}
int exp10(int B)
{
        int B10=1;
        for(int i=0;i<B;i++)
                B10*=10;
        return B10;
}
void SimpleSum(char&A,int a)
{
        if(A>=9)
        {A=0;
        SimpleSum((*(&A-1)),1);
        }
        else {A++;}
}
char* divide(char*A,char*B,char*C,int size)
{
        char*result=new char[size];
        init(result,size,0);
        for(int i=0;i<size;i++)C=A;
        int Biggy;
        int shifts=0;
        while(compare(C,B,size)||shifts!=0)
        {
                if((!compare(C,B,size))&&shifts!=0){ShiftRight(B,size,1);shifts--;}
        Biggy=HowManyDigitsBig(C,B,size);
        if(Biggy>1)
        {shifts+=ShiftLeft(B,size,(Biggy-1));}
        if((!compare(C,B,size))&&Biggy>1)ShiftRight(B,size,1);
        while(compare(C,B,size))
        {
                minus(C,C,B,size);//C-=B;
                if(Biggy>1||shifts>0)SimpleSum(result[size-shifts-1],1);
                else SimpleSum(result[size-1],1);
        }
        if(Biggy>1){shifts-=ShiftRight(B,size,1);}
        }
        return result; 
}
bool is_full_of(char a,char*A,int size)
{
        for(int i=0;i<size;i++)
        {if(A!=a){return 0;}}
                return 1;
}
bool is_zero(char*A,int size)
{
        return is_full_of('0',A,size);
}
bool is_zero(int size,char*A)
{
        return is_full_of(0,A,size);
}
void main()
{
        char* A_=new char[1000];
        char* B_=new char[1000];
        cin>>A_;
        cout<<setw(strlen(A_))<<setfill(' ')<<'/'<<endl;
        cin>>B_;
        cout<<setw(max(strlen(A_),strlen(B_)))<<setfill('_')<<'='<<endl;
        char* A=new char[strlen(A_)+1];init(A,strlen(A));
        char* B=new char[strlen(B_)+1];init(B,strlen(B));
        strcpy(A,A_);
        strcpy(B,B_);
        delete A_;
        delete B_;
        if(strlen(A)>strlen(B))
                B=MakeSameSize(B,strlen(B),strlen(A));
        else
                A=MakeSameSize(A,strlen(A),strlen(B));
        char *C=new char[strlen(B)+1];
        init(C,strlen(B)+1);
        C[strlen(B)]=0;
        int size=strlen(B);
        change_to_chars(A);
        change_to_chars(B);
        change_to_chars(C);
        char*result=divide(A,B,C,size);//C=A%B
        change_to_numbers(C,size);
        change_to_numbers(A,size);
        change_to_numbers(B,size);
        change_to_numbers(result,size);
        Out_Array(result,size);
        if(!is_zero(C,size))
        {cout<<" and ";//Modulus
        Out_Array(C,size);
        cout<<"/";
        Out_Array(B,size);}
        cin>>A[0];
}

أرجو منك أخي أن تمهلني إلى 21 الشهر الحالي ... حتى نخلص من وجع راس الامتحانات ... ونتفرغ لفعل ما نفعله كل ليلة ....(وماذا نفعل كل ليلة ؟؟ )

سنحاول السيطرة على العالم

السلام عليكم

رائع عزيزى مصطفى إسلوب تفكيرك مميز .

اقتباس

أرجو منك أخي أن تمهلني إلى 21 الشهر الحالي ... حتى نخلص من وجع راس الامتحانات ... ونتفرغ لفعل ما نفعله كل ليلة ....(وماذا نفعل كل ليلة ؟؟ )

سنحاول السيطرة على العالم

وفقك الله لما يحب ويرضى

السلام عليكم أخي أحمد وجميع المتابعين بالنسبة للكود الذي وضعه الأخ أحمد فقد كتبت كوداً مكافئا له تماماً لمن يريد فهم خوارزميته ... فهي جميلة ومبتكرة .. جزاه الله خيراً

الكود التالي يتعامل مع رقم مخزن بشكل عادي ( أي أنه ليس مصفوفة أو مخزن في ملف ) فالهدف هوشرح الخوارزمية القابلة للتعميم فوراً (وهي كذلك ) :

سأضع الكود وأشرح الخوارزمية إن شاء الله :

أولا الكود:

#include<iostream.h>
//This Program was written in php language By ahmed saoud31

#define echo cout<<
#define get cin>>
void main()
{
int NUM=2055;
	echo "\tenter Num\t";
	get NUM;
int START_NUM=0;
int NUM_temp=0;
int div_num=5;
	echo "\tenter div_Num\t";
	get div_num;
int div_num_temp=div_num;
for(int i=0;true;i++)
{echo i<<endl;
	bool GEL=(START_NUM+div_num_temp>=NUM);
	if(GEL)
	{
		if(div_num_temp==2*div_num)
		{
			if(START_NUM+div_num==NUM ||START_NUM+2*div_num==NUM)
			{
				echo "it's able to derive\t:)\n";
			}
			else
			{
				echo "it's Not able to derive :(\n";
			}
			break;
		}
		START_NUM+=NUM_temp;
		div_num_temp=div_num;
	}
	NUM_temp=div_num_temp;
	div_num_temp*=2;
}
}

فكرة الخوارزمية كما يلي ..

إذا كان العدد A يقبل القسمة على العدد B بدون باق فهذا يعني أن : B*n=A أي أنه يوجد عدد صحيح n إذا ضربناه بB سينتج A

يمكننا أن نجرب ضرب B بالأعداد 1و2و3و4 حتى نصل إلى الرقم المطلوب n والذي يحقق B*n=A

ولكن العملية السابقة تأخذ الكثييير من الوقت فلو أردنا تقسيم 1000000 على 1 فسنكرر العملية السابقة مليون مرة

لذلك كانت فكرة الأخ أحمد أن نفوم بضرب B ب1 ثم 2 ثم 4 ثم 8 ثم 16 ثم 32 و64و128و وهكذا ...ولنسمّ الرقم الذي نضرب به بQ

وهذا سيؤدي إلى تجاوز الرقم A في كثير من الأحيان لذلك عندما يتحقق الشرط Q*B>A سوف نعود لنصف Q ولنسمه C ثم نعود من جديد بالضرب بحيث نبدأ من C بدل الصفر كمايلي :

C+1)*B) ثم C+2)*B)ثم C+4)*B) ثم C+8)*B) وهكذا .. حتى نتجاوز الA ثم نكرر مرة أخرى ...

وسينتهي التكرار عندما يتحقق الشرط التالي :

إذا كان العدد لا يقبل القسمة فسيكون :

عدد M ما * B أصغر منA وأيضا العدد التالي للعدد M مضروبا بB أكبر من A وهذا يعني أنه لا يوجد عدد صحيح إذا ضربناه ب B سينتج A وبالتالي فA لا يقبل القسمة على B

وإذا كان العدد يقبل القسمة سيكون :

عدد ما M إذا ضربناه بB سيعطينا عدد مساويا لA أو أصغر من A بمقدار B أي أن M+1 ضرب B يساوي A فهو يقبل القسمة ...

لنقم بحل هذا المثال باستخدام هذه الخوارزمية :

هل يقبل 2555القسمة على 5 ؟

5*1

5*2=10

5*4=20

5*8=40

5*16=80

وهكذا

160

320

640

1280

2560والآن تجاوزنا الرقم لذلك سنعود لل 1280

سنبدأ الآن كما يلي :

1280+5

1280+10

1280+20

1280+40

1280+80

وهكذا

1280+160

1280+320

1280+640=1920

1280+1280 تجاوزنا الرقم لذلك سنعود إلى 1920

ونبدأ

1920+5

1920+10

1920+20

1920+40

1920+80

1920+160=2080

1920+320=2240

1920+640=2560

تجاوزنا الرقم وسنعود إلى 2240

ونبدأ

2240+5

2240+10

2240+20

2240+40

2240+80

2240+160=2400

2240+320=2560

تجاوزنا وسنعود ل2400

ونبدأ:

2400+5

2400+10

2400+20

2400+40

2400+80=2480

2400+160=2560 سنعود ل2480

2480+5

2480+10

2480+20=2500

2480+40=2520

2480+80=2560 نعود لل2520

2520+5=2525

2520+10=2530

2520+20=2540

2520+40=2560نعود2540

2540+5=2545

2540+10=2550

2540+20=2560نعود2550

2550+5=2555 وصلنا ............أخيراً

أظن أن الفكرة أصبحت واضحة...شكراً جزيلا للأخ أحمد

والسلام عليكم ورحمة الله وبركاته ...

<font size="3">

السلام عليكم

بارك الله فيك أخى مصطفى على هذا الشرح الجميل لإثراء الموضوع وتوضيح الفكرة , دائماً مميز .

ولا أعلم لماذا بعد تقييم المشاركات فى هذا الموضوع وإعادة تحميل الصفحة كأن شئ لم يكن , نرجو من السادة المشرفين توضيح ماهية التعامل فى هذا الموقع حتى نكون على بينة من أمرنا .

وفقك الله لما يحب ويرضى

السلام عليكم إخواني ...

السلام عليكم أخي أحمد سعود ...

جاء الصيف والعطلة ... وسنركز على تنفيذ هذا المشروع بإذن الله تعالى ...

كم من الوقت سنحتاج لإنجاز المشروع نهائيا ... ؟

بإذن الله تعالى .. خلال شهرين سيكون المشروع منتهيا ( وسيبقى علينا التحسينات )

ماذا أنجزنا سابقاً؟

لنبدأ بملخص من البداية ..

المشروع هو الوصول لأكبر رقم أولي ينتج عن المعادلة( P^2 -1 ) حيث P عدد أولي ...

الخطوات :

نوجد عدد أولي عادي 2,3,5,7,11,إلخ ...

نرفع 2 للقوة العدد الأولي الذي أوجدناه ....

نطرح منه واحد

نختبره هل هو أولي ... إن كان أولي فهو من نوع Mersenne الذي نريده .. وإلا سنتجاوزه ..

ببساطة يمكننا كتابة خوارزمية إيجاد جميع الأرقام الأولية بين الواحد وال4مليارات مثلا إن احتاج الأمر .. هذه الخطوة الأولى ..

لإيجاد 2 قوة العدد الأولي .. أنجزنا هذه الخطوة .. بعدة محاولات .. ثم نطرح منه واحد ..

نختبره هل هو أولي ... أنجزنا هذه الخطوة للمصفوفات وتعميمها للملفات عملية بسيطة ...

ماذا بقي؟؟

علينا جمع كل الأكواد السابقة .. والخوارزميات المتفرقة مع بعضها في برنامج واحد كامل متكامل...

ما هو عمل الكود النهائي (أو بصيغة أخرى : متى نقول أننا انتهينا ) :

نريد برنامج يبدأ من الرقم 2 فقط كأول عدد أولي وينتج لنا في ملفات خارجية جميع الأعداد الأولية

من نوع ميرسن حتى الوصول إلى الرقم 1- 43112609 ^2 وهو أكبر رقم مسجل حتى الآن

والآن : بإيجاد الرقم الأولي التالي للرقم الذي ذكرناه للتو ( وطبعا لن يكون هذا على الملأ ) سنكون قد أنجزنا إنجازا لم يستطع احد قفي العالم .. القيام به ...

ماذا سنتناول في التحسينات ؟

أولا :سنغير نظام العد الذي نعمل عليه للوصول إلى أكبر سرعة ( وذلك بعد أن نكون قد ضمنا صحة النتائج في النظام العشري (وهذ سبب الإصرار على استخدام العد العشري في البداية ))

ثانيا : سنحاول توفير أكبر قدر ممكن من الذاكرة ram لأن استخدام الملفات يبطئ العمل ..

ثالثا : بمساعدة الأساتذة المشرفين .. نريد البحث عن أسرع طرق التعامل مع بيانات الملفات لنتجاوز عقبات البطء التي تسببها ..

هذا كل شيء أردت قوله في بداية العطلة ... ولمن يهمه الأمر من يوجد رقم أولي من 100 مليون منزلة يحصل على 100ألف دولار

لا يهم وجود المتابعة أو عدمها ... فعندما سيتم إنجاز المشروع سيستفيد منه الكثير بإذن الله تعالى ...

والله ولي التوفيق

والسلام عليكم

السلام عليكم

ميزه لا أراها كثيراً وهى المواصلة لتحقيق الهدف وعدم الملل , فتحيه لك أخى مصطفى على هذا الحماس الرائع .

اقتباس

نريد برنامج يبدأ من الرقم 2 فقط كأول عدد أولي وينتج لنا في ملفات خارجية جميع الأعداد الأولية

من نوع ميرسن حتى الوصول إلى الرقم 1- 43112609 ^2 وهو أكبر رقم مسجل حتى الآن

دمت فى رعاية الله

جزاك الله خيرا أخي أحمد .. وجودك ورودوك محفز كبير لي على المواصلة ...

كما قلت لا نحتاج إلا رقم واحد ... ولا بأس في الاقتصار على ذلك

أنا لن أقيم أي عمل أو كود ... وكل منا له رأيه ... ونحن نتبادل الأفكار فقط

أسكرك جزيلا مرة أخرى ...

والسلام عليكم

السلام عليكم

اقتباس

أنا لن أقيم أي عمل أو كود ... وكل منا له رأيه ... ونحن نتبادل الأفكار فقط

فدائماُ المناقشات والحوارت تنتج أفكار وآراء جديدة .

اقتباس

الأساس هو المشاركة بالأفكار وإثراء المحتوى العربى وليس فرض فكر أو طريقة أو إظهار علم فكلنا نتعلم .

أخي العزيز أحمد ... أتوق عندما ننتهي من هذا المشروع بإذن الله تعالى ... أن يكون تربة خصبة ليتعلم منها كل الشباب العربي ...

اقتباس

وصدقت تلك المقولة " كلما إزددت علماً إزداد علمى مدى جهـلـى "

صدقت ... ويبدو أن العملية تصل إلى OVERFLOW حيث أنه لا نهاية للعلم ... للأسف

...

حديثنا اليوم بسيط جدا ... وهام جدا ... فهو يحدد تماما الخطوات التي علينا القيام بها ...

فهو هيكل البرنامج المطلوب منا عمله ... بلغة ++C

الفكرة بسيطة جداً لمن سهّلها الله عليه ... قمت بعمل هذه النسخة المصغرة عن البرنامج الذي نريد عمله

في هذا الكود تجد اننا نتعامل مع نوع بسيط unsigned int

أظن أن فهم الكود ليس صعباً

 #include<iostream.h>
bool ismersenne(unsigned int prime)
{
	prime++;
	unsigned int result=0;
	unsigned int a=0x1;
	for(unsigned int i=0;i<32;i++)
	{
		a=a<<1;
		if(a&prime)result ++;
	}
	return(result==1?1:0);
}
unsigned int mersenneprime(unsigned int prime)
{
	prime++;
	unsigned int result=0;
	unsigned int a=0x1;
	for(unsigned int i=0;i<32;i++)
	{
		a=a<<1;
		if(a&prime)return i+1;
	}
	return 00;
}
void main()
{
	const unsigned int size=250000;
	unsigned int primes[size]={0};
	unsigned Mersennes[20];
	unsigned int q=0;//mersenne index
	primes[0]=2;
	for(unsigned int i=2;primes[size-1]==0;i++)
	{
		for(unsigned int j=0;primes[j]!=0;j++)
		{
			if(i%primes[j]==0)
				break;
		}
		if(primes[j]==0)
		{
			primes[j]=i;cout<<	primes[j]<<'\r';
			if(ismersenne(primes[j]))
			{
				Mersennes[q]=primes[j];
				cout<<Mersennes[q]<<'\t'<<mersenneprime(primes[j])<<endl;
				q++;
			}
		}
	}
	cout<<endl;
}

الخوارزمية جديدة كليا فهي تعتمد إيجاد العدد الأولي ثم اختباره إذا كان ميرسن أولا عن طريق اختباره إن كان من قوى الرقم 2 ( بعد إضافة 1) ...

بينما الخوارزمية الثانية التي كنا نعتمد عليها تعتمد إيجاد قوى الرقم 2 ثم طرح واحد واختباره إن كان أولياً ...

ويمكننا ببساطة أن نجد أين الثغرة في الخوارزمية الرئيسية .. هو أن اختبار الرقم الأولي إن كان من قوى 2 ( بعد إضافة 1) أسهل بكثيييير من

اختبار أحد قوى الرقم 2 بعد طرح الرقم واحد إن كان أولياً... أليس كذلك ...

ولكن بالمقابل علينا دراسة أيهما أكثر جدوى أن نختبر قوى الرقم 2 جميعا أم أن نختبر الأعداد الأولية جميعا ...

ومما قد يساعدنا أثناء دراستنا للجدوى بأننا لاختبار الرقم (1- 2^prime) علينا إيجاد جميع الأعداد الأولية الأصغر من جذره ...

بينما لا ختبار الرقم إن كان من قوى الرقم 2 فيكفي أن نوجد باقي قسمته على 2 ثم 4 ثم 8 حتى يتبين لنا إن كان أحد قوى 2 أولا ...

والآن أخي أحمد كل ما علينا هو ... وضع كل الخبرة التي اكتسبناها في التعامل مع الأعداد الهائلة ... وإنشاء نوع جديد قادر على التعامل مع الأعداد الهائلة ...

الآن لدينا هدف واضح ... وسأفصل فيه بعض الشيء ...

هذا النوع الجديد والذي سأسميه s3oud .... أمزح لا تهم التسمية ... المهم المضمون ...

هذا النوع سيشمل العمليات التالية بشكل مستقل تماما عن البرنامج الذي يستخدمه :

أولا تخزين الرقم ( لا حل سوى الملفات أو أن نشتري حاسوب صغير mainframe ب3000دولار )

وهذا التخزين يمكن أن يكون بأي صيغة ولا يشترط فيه أن يكون مفهوما من قبل المستخدم ... (هناك فكرة سأذكرها لا حقا قد نتمكن من خلالها من الاستغناء عن الملفات )

ثانيا عملية الإظهار .. حيث يجب أن نظهر النتيجة طبعا في ملف خارجي ..

ثالثا العمليات الحسابية التالية :

باستخدام الخوارزمية الأولى : الزيادة الطبيعية ++ أو += وعملية باقي القسمة % فقط ..

باستخدام الخوارزمية الثانية : رفع 2 لقوة ,عملية الطرح البسيطة -- (لطرح واحد من القوة ) ,وعملية إيجاد جميع الأعداد الأولية الأقل من جذر العدد , وطبعاً عملية باقي القسمة %

أظن أنك ستعجب بالخوارزمية الأولى فهي أكثر تنظيما .. وأكثر هدوءا من الخوارزمية الثانية ... فمارأيك ؟؟

والكود السابق هو pseudo code لما ذكرته ...

هناك بعض التعليقات على آخر كود أرفقته أخي عن باقي القسمة ... كنت قد كتبتها منذ أكثر من أسبوعين ... ولكن الآن تمكنت من تقديمها ( فقط لأنني كنت أنسى ذلك في كل مرة)

أرجو ان تعقب عليها ....

ملاحظات على الكود.rar

السلام عليكم

بارك الله فيك أخى الكريم على متابعتك للموضوع بحماسة , وكلماتك الجميلة

اقتباس

ويمكننا ببساطة أن نجد أين الثغرة في الخوارزمية الرئيسية .. هو أن اختبار الرقم الأولي إن كان من قوى 2 ( بعد إضافة 1) أسهل بكثيييير من

اختبار أحد قوى الرقم 2 بعد طرح الرقم واحد إن كان أولياً... أليس كذلك ...

اقتباس

أظن أنك ستعجب بالخوارزمية الأولى فهي أكثر تنظيما .. وأكثر هدوءا من الخوارزمية الثانية ... فمارأيك ؟؟

وهل يمكن تطبيقه على الأعداد فى الملفات ؟

اقتباس

هناك بعض التعليقات على آخر كود أرفقته أخي عن باقي القسمة ... كنت قد كتبتها منذ أكثر من أسبوعين ... ولكن الآن تمكنت من تقديمها ( فقط لأنني كنت أنسى ذلك في كل مرة)

أرجو ان تعقب عليها ....

بالنسبة لموضوع إنتاج الأعداد الأولية فعدى فكرة سأطرحها لك ولكن لا أظن أننى فى هذه الأيام سأقوم بتطبيقها وهى كالتالى :

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

وتكمن هذه الفكرة فى توزيع العمل على جميع الأجهزة التى تقوم بتنزيل البرنامج والإتصال بشبة الإنترنت لتلقى البيانات من السرفر , والبيانات المطلوبة من السرفر هى أخر رقم تم إختبار قسمتة والبيانات المرسلة هى ناتج العملية التى قام بها البرنامج على جهاز العميل .

دمت فى رعاية الله