هل تستطيع معرفة عدد الخانات برقم معين

حل السؤال الأول:

توجد أكثر من طريقه لمعرفة عدد خانات الرقم سأعرض إثنان منها هنا.

1 - الحصول على عدد الخانات بإستخدام الـ bit shift:

هذه الطريقه تصلح فقط مع أنظمة الأعداد التى يمكن تمثيل أكبر رقم يأخذ خانه واحده بعدد معين من البتات التى تكون جميع قيمها بواحد فمثلا النظام الثمانى اكبر رقم فيه هو 7 و يمثل ثنائيا بالرقم 111 أى 3 بت، النظام السداسي عشرى أكبر رقم فيه هو F و يمثل ثنائيا بالرقم 1111 أى 4 بت، النظام الثنائى لا يحتاج اى مجهود حيث اكبر رقم به هو 1 و يمثل 1 بت.

النظام العشرى لا يمكن الحصول على عدد خاناته بإستخدام هذه الطريقه و السبب فى ذلك هو ان اكبر رقم به هو 9 و يمثل ثنائيا بالرقم 1001 و كما ترى يحتوى ليست جميع البتات بواحد.

متطلبات هذه الطريقه:

1 - الرقم لابد و أن يكون موجب حيث ان الأرقام السالبه لها ترميز مختلف.

2 - الرقم لابد و أن يكون ترميزه Little Endian.

سنعتبر اننا نتعامل مع النوع int32 (هو signed int داخل بيئة 32bit).

سنأخذ النظام السداسى عشرى كتطبيق هنا، الخطوات كالتالي:

1 - على اعتبار ان موقع أول بت من اليسار هو 32 و أول بت من اليمين هو 1، قم بالحصول على موقع اول بت من اليسار بقيمة 1.

2 - الرقم الناتج من النقطه 1 هو عدد البتات الفعليه التى تمثل الرقم، قم بقسم الرقم الناتج من النقطه واحد على 4 (و هو عدد البيات التى تمثل خانه واحده بالنظام السداسى العشرى).

3 - قم بالحصول على باقى القسمه للرقم الناتج من النقطه 1 مع الرقم 4 (و هو عدد البيات التى تمثل خانه واحده بالنظام السداسى العشرى) إذا كان الناتج أكبر من صفر قم بإضافة 1 إلى الرقم الناتج من 2.

4 - الرقم الناتج من 3 هو عدد الخانات المطلوبه

الخطوات السابقه يمكن تطبيقها على النظام الثنائى و السداسى عشرى بكل بساطه فقط بإستبدالك الرقم 4 بالخطوه الثانيه و الثالثه بأى من الرقمين 3 و 1 للنظامين الثمانى و الثنائى على التوالي.

الكود التالي هو تطبيق على الخطوات السابقه للأنظمه السابق ذكرها:

typedef signed int  int32;



#define DEC  0

#define HEX  1

#define OCT  2

#define BIN  3



int32 digitCount2(int32 value, int32 base)

{

    if (base == DEC) return -1;



    value *= value < 0? -1: 1;



    static const int32 size[] = {0, 4, 3, 1};





    int32 bit_loc = sizeof(int32) * CHAR_BIT;



    for (; bit_loc >= 0; bit_loc--)

        if (value & (1 << (bit_loc - 1))) break;



    return (bit_loc / size[base]) + (bit_loc % size[base] > 0? 1: 0);

}

الداله Main لإختبار الداله السابقه:

#include <iostream>

using namespace std;



typedef signed int  int32;



#define DEC  0

#define HEX  1

#define OCT  2

#define BIN  3



const char* system_name[] = { "decimal", "hexadecimal", "octal", "binary" };



int32 digitCount2(int32 value, int32 base);



int main()

{

    char input = 0;



    do 

    {

        int32 value = 0;

        cout << "Enter Number: ";

        cin  >> value;

        cout << "Select output number system\n";

        cout << "   1) Hexadecimal   2) Octal   3) Binary   E) Exit\n";

CHOICE:

        cout << "\nEnter your choice: ";

        cin  >> input;



        if (input == 'E') break;



        if(input < '1' || input > '3')

        {

            cout << "Invalid Choice.\n";

            goto CHOICE;

        }



        input -= '0';



        cout << "\nNumber of Placeholder needed to hold " << value

             << " in " << system_name[input] << " system is "

             << digitCount2(value, input) << endl;

EXIT:

        cout << "Do yo want to continue (Y\\N)? ";

        cin  >> input;



        if(input != 'Y' && input != 'N')

        {

            cout << "Invalid Choice.\n";

            goto EXIT;

        }

    }

    while (input != 'N');

}

2 - الحصول على عدد الخانات بإستخدام اللوغارتم

يمكنك الحصول على عدد الخانات رقم ما بأى نظام تريد بإستخدام اللوغارتم، و لمن هم لا يعرفون اللوغارتم إليكم شرح مبسط للأمر:

اللوغارتم هو وسيله للحصول على عدد مرات تواجد مضاعفات رقم داخل أخر فى نظام عددى معين و الصيغه العامه له هى كالتالي: و تقرأ أو ما هو الرقم الذى إذا تم إستخدامه كأس للرقم x يعطينا y، الداله log تعيد رقم عشرى و ليس صحيح، أيضا الداله log الموجوده بـ cmath تتعامل مع النظام العشرى و هو الوضع الإفتراضى و لتحويلها للنظام السداسى العشرى سنقوم بقسمة الرقم الناتج منها على للتحويل لنظام الثمانى قم بإستبدال الرقم 16 بالرقم 8.

كما نعلم فإن عدد مرات تواجد مضاعفات الرقم 10 داخل الرقم 1000 هى 3 و هذا هو الرقم الذي ستعيده لنا الداله log بالمكتبه القياسيه - أو أى مكتبه أخرى - و كما نعلم ان الرقم 10 بالنظام العشرى يعنى خانتين و ليس واحده و بالتالي عندما تعيد لنا الداله log الرقم 3 سنعرف انه توجد خانه واحده اضافيه لرقم أخر (فى حالتنا هذه 1)، مثلا الرقم 7 تمريرها للداله log ستعيد لنا رقم كسرى أقل من الصفر و ذلك لأن الرقم 7 أقل من 10، الرقم صفر بالنسبه لنا يعنى انه يوجد رقم اقل من 10 و هذا يعنى تواجد خانه واحده فقط.

الخلاصه: بعد تنفيذ الداله log لأى نظام عددى قم دائما بزيادة 1 للحصول على عدد الخانات.

الكود بإستخدام اللوغارتم:

#include <cmath>

using namespace std;



typedef signed int  int32;



#define DEC  0

#define HEX  1

#define OCT  2

#define BIN  3



int32 digitCount(int32 value, int32 base)

{

    static const double base_value[] = {10.0, 16.0, 8.0, 2.0};



    if (base > BIN) return -1;



    if (value == 0) return 1;



    value *= value < 0? -1: 1;



    return (int32)(log10((double)value) / log10(base_value[base]) + 1);

}

الداله Main للداله السابقه:

قم بتعديل السطر:

cout << "   1) Hexadecimal   2) Octal   3) Binary   E) Exit\n";

إلى التالي:

cout << "   0) Decimal   1) Hexadecimal   2) Octal   3) Binary   E) Exit\n";

قم بتعديل السطر التالي:

if(input < '1' || input > '3')

إلى التالي:

if(input < '0' || input > '3')

حل السؤال الثاني:

سنبدأ بالنظام العشرى كمثال، الأعداد الموجوده بالنظام العشرى تبدأ من 0 كأقل عدد و تنتهي عند 9 كأكبر عدد يمكن تخزينه داخل خانه واحده، لذا عندما أسئلك اي العددين أكبر بشكل إفتراضى ستجيب العدد 9 و ذلك لأنه يستطيع تمثيل كميات أكبر من العدد 0، و لكن برمجيا كيف يمكننا تحديد أى الرمزين أكبر؟

كل الـ code pages المعروفه تحدد رقم معين للرموز من 0 إلى إلى 9 فعندما تستخدم الحرف 0 داخل نص فعليا يتم حفظه برقم يمثله و فى حالتنا هذه هو 48 و الحرف 9 يمثله الرقم 57 لذا عندما نريد المقارنه بين الحرفين 0 و 9 بكتابة الكود التالي:

if ('0' > '9')

   cout << " 0 > 9 !!!";

else

   cout << " 9 > 0 !!!";

فإن ذلك الكود يصبح كالتالي:

if (48 > 57)

   cout << " 0 > 9 !!!";

else

   cout << " 9 > 0 !!!";

لذا السؤال الذى يطرح نفسه كيف نستطيع المقارنه بين رقمين مثل "1234-" و "362" و كيف يمكننا تحديد أيهما أكبر و أيهما أقل؟

إذا أفترضنا ان هاذين النصين يمثلوا أرقام حقيقيه و طلبت منك أن تجيبنى انت على هذا السؤال فأعتقد انك ستقول الرقم 1234- أقل من الرقم 362، نعم كلامك صحيح و لكن ما يهمنى هو ليس إجابة السؤال و لكن كيف توصلت لها.

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

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

قد يدور الحوار التالي بينى و بين أحدكم:

"ماذا عن الصفر، فالنفترض وجود مثل هاذين الرقمين "3654" و "0125"، كما ترى كلاهما موجب و كلاهما له نفس عدد الخانات فكيف سنعرف أيهم أكبر و أيهم أصغر؟"

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

"و لكن ماذا يحدث إن كان عدد الخانات الموجوده بالرقمين بعد تجاهل الأصفار متساويه كما فى الرقمين "567" و "561"، ماذا سنفعل حينها؟"

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

"لماذا من اليسار لليمين؟ و هل لك ان تفصل الخطوات على المثال السابق؟"

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

مثلا فى مثالك الرقم "567" حروفه تأخذ القيم التاليه 55 54 53 و الرقم "561" حروفه تأخذ الأرقام التاليه 49 54 53 عندما نقارن خانة المئات سنجد انهم متساويين (53 = 53) و عندما ننتقل لخانة العشرات سنجد انهم ايضا متساويين (54 = 54) لذا سنذهب لخانة الأحاد و سنجد أن الرقم الذى يمثل الحرف 7 أكبر من الرقم الذى يمثل الحرف 1 (49 < 55) و بالتالي الرقم "567" أكبر من الرقم "561".

التحليل النظرى أنتهى لذا لنطبق مثال عملي على النوع signed int، من الملف limits.h نعلم أن أكبر و أقل قيمة لهذا النوع هى كالتالي:

#define INT_MIN -2147483648#define INT_MAX  2147483647

أنظر للكود التالي و من ثم تابع معي: (الكود التالي يتعامل على اساس ان النص المدخل يحتوى فقط على رموز الأعداد من 0 و حتى 9 و قد يتتواجد الإشاره السالبه فى اقصي اليسار مره واحده فقط)

typedef signed char int8;typedef signed int  int32;bool isOverflow(const char* value){    // maximum and minimum number of int32    //                                      INT_MAX       INT_MIN    static const char* max_numbers[] = { "2147483647", "2147483648" };    // input string size    int32 str_len = strlen(value);    // is sign mark exist in input string    int32 signExist = (*value == '-');    // first non zero digit in input number    int32 non_zero_index = signExist;    // locate first non zero index    while(non_zero_index < str_len && value[non_zero_index] == 0) non_zero_index++;    // if non_zero_index equal length then all digits are zero    if (non_zero_index == str_len) return false;    // get number of digits that actually represent the number    int32 diff = str_len - non_zero_index;    // if difference less than 10 digits then no overflow will happened    if (diff < 10) return false;    // if difference greater than 10 digits then overflow will happened    if (diff > 10) return true;    // left digit in input and search strings    int8 left1 = 0, left2 = 0;    // if digits equal to 10 then loop over digits from left to right and compare    for (int32 i = 0; non_zero_index < str_len; non_zero_index++, i++)    {        // get input digit        left1 = value[non_zero_index];        // get match digit        left2 = max_numbers[signExist];        // if digits not equal then if left1 is greater overflow will occurred, false otherwise        if (left1 != left2) return left1 > left2;    }    // overflow won't happened    return false;}

فى البدايه تم تعريف المصفوفه max_numbers و التى تحتوى على نصين يمثلوا اكبر و أقل قيمه يمكن تخزينها داخل متغير من نوع int32 و كما تلاحظ لم أضع الإشاره و سأشرح لك لماذا بعد قليل، الخطوه التاليه هى الحصول على عدد الحروف داخل النص المدخل و حفظها داخل المتغير str_len بعدها يتم التحقق إذا ما كان النص المدخل أول حرف به هو الإشاره السالبه أم لا و يتم تخزين النتيجه داخل المتغير signExist، كما ترى نوع هذا المتغير هو int32 و ليس bool و السبب فى ذلك يرجع إلى انى احتاج القيمة 0 أو 1 لتعبر عن عدم وجود او وجود الإشاره و التى سأستفاد بها فيما بعد عند تمريرها للمصفوفه max_numbers لأعرف أى النصين سأقوم بالمقارنه معه فإن كانت الإشاره موجوده فستكون قيمة signExist بواحد و بالتالي الرقم المدخل سأقوم بمقارنته مع العنصر الثاني فى المصفوفه و الذى يقابل INT_MIN و إذا كانت الإشاره غير موجوده ستكون قيمة signExist بصفر و سأقارن مع العنصر الأول فى المصفوفه و الذى يقابل INT_MAX.

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

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

بعد ذلك إذا كان قيمة non_zero_index تساوى عدد الحروف فهذا يعنى ان النص يحتوى كله على اصفار و سيتم العوده بـ false و التى تعنى انه لن يتم حدوث overflow.

بعد ذلك اقوم بالحصول على عدد الحروف التى تمثل الرقم بدون الأصفار و الإشاره و اقوم بحفظ الناتج داخل المتغير diff.

الأن أقوم بالتحقق من قيمة diff حيث إذا كانت أقل من 10 خانات (و هو عدد الخانات التى يستغلها أى من الرقمين داخل المصفوفه) فهذا يعنى ان الرقم المدخل أقل من الرقم الموجود بالمصفوفه و سيتم العوده بـ false و إذا كان أكبر من 10 فهذا يعنى انه سيحدث overflow و سيتم العوده بـ true.

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

بعد ذلك تبدأ عملية الدوران للمقارنه بين الحرفين بالمصفوفه بنفس الموقع فإن كان الرقمين متساويين فسيتم إكمال الدوران للحرف التالي أما إن كانوا غير متساويين فسيتم الرجوع بـ true إذا كانت قيمة الحرف بالنص المدخل أكبر من الحرف الموجود بالنص الذى يتم المقارنه معه - النص الموجود بالمصفوفه - و سيتم العود بـ false غذا حدث العكس.

إذا انتهت حلقة الدوران فهذا يعنى ان النص المدخل يساوى اكبر رقم يمكن للنوع int32 ان يحفظه و هذا يعنى عدم حدوث overflow و بالتالي يتم العوده بـ false.

قد تتسائل و ماذا عن أختبار الـ overflow للنوع int32 مع النظام الثماني و السداسى عشرى و الثنائى؟

الفكره واحده فى جميع الحالات و التطبيق واحد و لكن مع النظام السداسى العشرى تحتاج للإحتياط حيث انه لديك الحروف A-F و ايضا الحروف من a-f و على اعتبار ان الداله ستتعامل مع النوع السداسى عشرى و الرقم المدخل يحتوى فقط على الرموز المقبوله لهذا النظام حينها يمكنك استخدام الرموز من a-f بدلا من الرموز A-F و ذلك حتى إذا قام المستخدم بإدخال الحروف الكبيره فستقوم دالتك بالتعامل مع الموقف بشكل سليم.

الداله التاليه تقوم بالتحقق من حدوث overflow للنوع int32 لكل الأنظمه العديده و لاحظ ان النظامين العشرى و الثماني هم فقط من يسمحوا بوجود إشاره سالبه فى اقصى اليسار، ايضا الداله تفترض على الأقل وجود حرف واحد بالنص:

typedef signed char int8;typedef signed int  int32;#define DEC  0#define HEX  1#define OCT  2#define BIN  3bool isOverflow(const char* value, int32 base){    // left-most digit for maximum and minimum number    static const char* max_numbers[4][2] =    {        //                 INT_MAX                           INT_MIN        {                       "2147483647",                       "2147483648" }, // decimal        {                         "7fffffff",                         "80000000" }, // hexadecimal        {                      "17777777777",                      "20000000000" }, // octal        { "01111111111111111111111111111111", "10000000000000000000000000000000" }  // binary    };    // size of strings in max_numbers array    static const int32 number_sizes[] = { 10, 8, 11, 32 };    // input string size    int32 str_len = strlen(value);    // is sign mark exist in input string    int32 signExist = ((base == DEC || base == OCT) && *value == '-');    // first non zero digit in input number    int32 non_zero_index = signExist;    // locate first non zero index    while(non_zero_index < str_len && value[non_zero_index] == 0) non_zero_index++;    // if non_zero_index equal length then all digits are zero    if (non_zero_index == str_len) return false;    // get number of digits that actually represent the number    int32 diff = str_len - non_zero_index;    // if difference less than 10 digits then no overflow will happened    if (diff < number_sizes[base]) return false;    // if difference greater than 10 digits then overflow will happened    if (diff > number_sizes[base]) return true;    // left digit in input and search strings    int8 left1 = 0, left2 = 0;    // if digits equal to 10 then loop over digits from left to right and compare    for (int32 i = 0; non_zero_index < str_len; non_zero_index++, i++)    {        // get input digit        left1 = value[non_zero_index];        // get match digit        left2 = max_numbers[signExist];        // if digits not equal then if left1 is greater overflow will occurred, false otherwise        if (left1 != left2) return left1 > left2;    }    // overflow won't happened    return false;}

قد تتسائل، الأن و قد عرفنا كيف نقوم من التحقق من حدوث overflow لرقم صحيح، ماذا عن الأرقام العشريه؟

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

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