המשלים 2s ב-C נוצר מהמשלים 1s ב-C. כפי שאנו יודעים כי משלים 1s של מספר בינארי נוצר על ידי הפיכת סיביות 1 ל-0 ו-0 ל-1; משלים 2s של מספר בינארי נוצר על ידי הוספת אחד למשלים 1s של מספר בינארי.

בקיצור, אפשר לומר שהמשלים של 2 ב-C מוגדר כסכום של המשלים של האחד ב-C ו-1.

באיור שלמעלה, המספר הבינארי שווה ל-00010100, וההשלמה של האחד שלו מחושבת על ידי הפיכת הביט 1 ל-0 ו-0 ל-1 להיפך. לכן, המשלים של אחד הופך ל-11101011. לאחר חישוב ההשלמה של אחד, אנו מחשבים את ההשלמה של השניים על ידי הוספת 1 להשלמה של האחד, והתוצאה שלו היא 11101100.

בואו ניצור תוכנית של 2s משלים.

 #include int main() { int n; // variable declaration printf('Enter the number of bits do you want to enter :'); scanf('%d',&n); char binary[n+1]; // binary array declaration; char onescomplement[n+1]; // onescomplement array declaration char twoscomplement[n+1]; // twoscomplement array declaration int carry=1; // variable initialization printf('
Enter the binary number : '); scanf('%s', binary); printf('%s', binary); printf('
The ones complement of the binary number is :&apos;); // Finding onescomplement in C for(int i=0;i<n;i++) { if(binary[i]="=&apos;0&apos;)" onescomplement[i]="1" ; else } onescomplement[n]="" printf('%s',onescomplement); printf('
the twos complement of a binary number is : '); finding twoscomplement in c for(int i="n-1;">=0; i--) { if(onescomplement[i] == &apos;1&apos; &amp;&amp; carry == 1) { twoscomplement[i] = &apos;0&apos;; } else if(onescomplement[i] == &apos;0&apos; &amp;&amp; carry == 1) { twoscomplement[i] = &apos;1&apos;; carry = 0; } else { twoscomplement[i] = onescomplement[i]; } } twoscomplement[n]=&apos;&apos;; printf(&apos;%s&apos;,twoscomplement); return 0; } </n;i++)>

תְפוּקָה

ניתוח התוכנית לעיל,

• ראשית, נזין את מספר הביטים, והוא נשמר ב-' נ 'משתנה.
• לאחר הזנת מספר הביטים, אנו מכריזים על מערך תווים, כלומר, char binary[n+1], שמחזיק את המספר הבינארי. ה ' נ ' הוא מספר הביטים שהזנו בשלב הקודם; זה בעצם מגדיר את גודל המערך.
• אנו מכריזים על שני מערכים נוספים, כלומר, משלים אחד[n+1] , ו twoscomplement[n+1]. ה משלים אחד[n+1] מערך מחזיק את המשלים של מספר בינארי בעוד ה- שני משלים[n+1] מערך מחזיק את ההשלמה של השניים של מספר בינארי.
• אתחל את לשאת משתנה והקצו ערך 1 למשתנה זה.
• לאחר הצהרות, נזין את המספר הבינארי.
• כעת, אנו פשוט מחשבים את המשלים של האחד של מספר בינארי. לשם כך, אנו יוצרים א לוּלָאָה שחוזר על פני המערך הבינארי, for(int i=0;i. ב-for loop, התנאי נבדק אם הביט הוא 1 או 0. אם הביט הוא 1 אז onescomplement[i]=0 אַחֵר onescomplement[i]=1 . בדרך זו נוצר השלמה של מספר בינארי של האדם.
• לאחר חישוב ההשלמה של אחד, אנו יוצרים את המשלים 2s של מספר בינארי. לשם כך, אנו יוצרים א לוּלָאָה החוזרת מהאלמנט האחרון לאלמנט ההתחלתי. ב-for loop, יש לנו שלושה תנאים:
  • אם הבייס של onescomplement[i] הוא 1 והערך של carry הוא 1 אז נשים 0 ב- twocomplement[i].
  • אם הסיביות של השלמה ones[i] היא 0 והערך של carry הוא 1 אז נשים 1 ב- twoscomplement[i] ו-0 ב-carry.
  • אם שני התנאים שלעיל שקריים, אז ה-onescomplement[i] שווה ל-twoscomplement[i].

מספרים שלמים חתומים מיוצגים לעתים קרובות ב-C באמצעות ה- סימון משלים של שני . משתמש באותו ייצוג בינארי מציע מנגנון לבטא את שניהם חִיוּבִי ו מספרים שלמים שליליים . ה החלק המשמעותי ביותר (MSB) משמש בתור חתיכת סימן ב ייצוג משלים של שני , איפה 0 מציין א מספר שלם חיובי , ו 1 מציין א מספר שלילי .

מתחיל עם א מספרים שליליים ערך מוחלט בצורה בינארית, אתה יכול לקחת את משלים של אחד (שלילה פיסית) של הערך הזה כדי לקבל את השלמה של שניים ייצוג של מספר שלם שלילי . אתה מוסיף 1 אל ה ערך כתוצאה לרכוש את הייצוג של ה השלמה של שניים .

ה קידוד המשלים של שני ב-C יכול לייצג מספרים שלמים חתומים ויכול לבצע פעולות אריתמטיות מהירות. יתרון אחד של העסקת המשלים של שניים הוא היכולת לעשות חיבור ו חִסוּר באמצעות אותן פעולות בינאריות כמו עבור מספרים ללא סימנים.

ה מספרים בינאריים מתווספים יחד כמו מספרים שלמים ללא סימנים כאשר מוסיפים משלים של שניים. ביצוע ממיקומו של ה החלק הקריטי העיקרי פשוט מתעלמים ממנו. בשל עובדה זו, טיפול מספרים חתומים שונה אינו הכרחי, וההוספה הופכת לפשוטה.

שקול להוסיף -5 ו -3 משתמש ב השלמה של 8 סיביות שתיים ייצוג, למשל:

מספר בינארי עבור -5 הוא 11111011.

מספר בינארי עבור -3 הוא 11111101 .

ביצוע התוספת:

 11111011 (-5) + 11111101 (-3) ------------- 111110100 (-8) 

התשובה היא 111110100 , אשר ב השלמה של שניים שווה ל -8 .

בדומה לחיבור, ניתן לבצע חיסור על ידי טיפול ב- האופרנד השני משלים של שני כאילו היה תוספת. במילים אחרות, אתה מוסיף את ההשלמה של השניים של מספר שלילי לאופרנד הראשון כדי להסיר אותו.

למשל, מתי -3 מופחת -5 :

בבינארי, -5 מיוצג על ידי 11111011 ו -(-3) על ידי 00000011 (השלמה של שניים של -3 )

ביצוע החיסור

 11111011 (-5) + 00000011 (+3) ------------- 11111110 (-8) 

התוצאה היא 11111110 , אשר בהשלמה של שניים שווה ל -8 .

סיכום:

ב-C, ה 2s משלים הוא ייצוג בינארי של מספר שלילי שנוצר על ידי הוספת אחד ל- 1s משלים . מערכות מחשב משתמשות ברעיון זה לעתים קרובות כדי לייצג מספרים חתומים ולבצע ביעילות פעולות אריתמטיות.

כדי לקבל את 2s משלים של מספר שלם בינארי, תחילה יש לקבוע את 1s משלים של המספר על ידי הפיכת הביטים. לאחר מכן, הייצוג של ה 2s משלים מתקבל על ידי הוספת אחד אל ה 1s משלים . ה החלק המשמעותי ביותר (MSB) יתפקד כסיבית סימן על ידי ביטוי אם מספר הוא חִיוּבִי אוֹ שלילי .

החישוב של ה 2s משלים עבור מספר שלם בינארי נתון מוצג בתוכנית C המצורפת. המשתמש מתבקש להזין את שני מספר בינארי ומספר הביטים. לאחר מכן, התוכנית עושה את ההליכים הנדרשים כדי לרכוש את המשלים 1s, ולאחר מכן את 2s משלים . לאחר מכן מוצגים הממצאים.

במדעי המחשב ובתכנות, זה חיוני להבין את 2s משלים ייצוג שכן הוא מאפשר לטפל בערכים שליליים המבוטאים בבינארי בצורה יעילה. זה עושה חיבור, חיסור , ו פעולות לוגיות פשוט יותר בשניהם חִיוּבִי ו מספרים שליליים . ההיקף של מספרים שלמים מיוצגים הוא סימטרי בערך אֶפֶס בשל 2s משלים ייצוג, מה שהופך אותו מתאים לפעולות מספריות שונות.

מתכנתים עשויים לבצע פעולות אריתמטיות, לעבוד עם נתונים בינאריים ולתכנן אלגוריתמים באמצעות מספרים שלמים עם סימנים ב-C ובשפות תכנות אחרות על ידי הבנת הרעיון של 2s משלים וניצול נכון שלו.