מהו קוד בינארי? וכיצד להמיר ספרות מייצוג עשרוני לבינארי והפוך

מערכת מספרים היא דרך לייצוג מספרים באמצעות סמלים. מערכת המספרים הנפוצה ביותר היא השיטה העשרונית, המשתמשת בסמלים 0-9. מחשבים, לעומת זאת, משתמשים במערכת המספרים הבינארית, בה יש שני סמלים בלבד: 0 ו-1.

היחידה הבסיסית בייצוג הבינארי היא ספרה הנקראת "ביט", קיצור של "binary digit". לביט יכול להיות אחד משני ערכים: 0 או 1.

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

המרת מספרים עשרוניים למספרים בינאריים

• את הספרה 0 העשרונית נמיר לייצוג בינארי של 0.
• את הספרה 1 העשרונית נמיר ל-1.

נשתמש בשיטת החלוקה להמרת ייצוג מספר מעשרוני לבינארי.

בשיטת החלוקה בשביל להמיר נחלק את המספר העשרוני ב-2 ונרשום בצד את שארית החלוקה. נחזור על התהליך עד שתוצאת החלוקה היא 0. שאריות החלוקה בסדר הפוך הם הייצוג הבינארי.

לדוגמה, כדי להמיר 2 לבינארי:

2 / 2 = 1 R 0
1 / 2 = 0 R 1

• הייצוג הבינארי של 2 הוא 10

במילים:

1. חלוקה של 2 ב-2 שווה 1 עם שארית 0.
2. חלוקה של 1 ב-2 נותנת 0 עם שארית 1.

הייצוג הבינארי הוא שאריות החלוקה בסדר הפוך ולפיכך 10.

דוגמה נוספת המרת המספר 13 לבינארי:

13 / 2 = 6 R 1
6 / 2 = 3 R 0
3 / 2 = 1 R 1
1 / 2 = 0 R 1

• הייצוג הבינארי של 13 הוא 1101

המרת מספרים בינאריים למספרים עשרוניים

כדי להמיר מספר מייצוג בינארי לעשרוני נעקוב אחר השלבים הבאים:

1. מתחילים מימין: התחל מהספרה הימנית ביותר של המספר הבינארי.
2. מקצים חזקות של 2: הקצה חזקות עולות של 2 לכל ספרה מימין לשמאל. התחל עם 2^0 עבור הספרה הימנית ביותר והגדל את החזקה ב-1 ככל שאתה מתקדם שמאלה (2^1, 2^2, 2^3 וכן הלאה).
3. מכפילים וסוכמים: עבור כל ספרה, הכפל אותה בחזקה המתאימה של 2 והוסף את התוצאה לסכום מצטבר.
4. ממשיכים שמאלה: חזור על שלבים 2 ו-3 עבור כל ספרה ככל שאתה מתקדם מימין לשמאל.

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

לדוגמה, המרת המספר הבינארי 1101 לעשרוני.

1. התחל מימין עם הספרה 1.

2. הקצה חזקות של 2 מימין לשמאל: 2^0, 2^1, 2^2 ו-2^3.

3. הכפל וסכום:

   1 * 2^0 = 1
   0 * 2^1 = 0
   1 * 2^2 = 4
   1 * 2^3 = 8

4. הוסף את התוצאות: 1 + 0 + 4 + 8 = 13.

5. הסכום הכולל, 13, הוא הייצוג העשרוני של המספר הבינארי 1101

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

דוגמה נוספת: המרת המספר 11100 לייצוגו העשרוני.

0 * 2^0 = 0
0 * 2^1 = 0
1 * 2^2 = 4
1 * 2^3 = 8
1 * 2^4 = 16

0 + 0 + 4 + 8 + 16 = 28

שימושים בקוד בינארי

בנוסף למספרים, ניתן להשתמש בקוד בינארי לייצוג טקסט ונתונים אחרים. סכימות קידוד שונות, כמו ASCII ו-Unicode, מקצות קודים בינאריים ייחודיים לתווים וסמלים. לדוגמה, קוד ASCII עבור האות 'A' הוא 01000001 בבינארי.

קוד בינארי משמש גם לייצוג ולתפעול ערכים בוליאניים (נכון או שקר) ולביצוע פעולות לוגיות כמו AND, OR ו- NOT. עניין מהותי בתכנות מחשבים ועיצוב מעגלים דיגיטליים.

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

מעבדים של מחשבים CPU מבינים ומבצעים הוראות המיוצגות כקוד בינארי. הוראות קוד מכונה הן סדרה של 0 ו-1 שמורות למעבד אילו פעולות לבצע.

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

קוד להמרת מספר לייצוגו הבינארי

def intToBin(i, stack, isMinus = False):
   """
   Convert an integer to its binary representation.


   Args:
       i: The integer to convert.
       stack: The stack to use in the process.
       isMinus: Is the integer a minus.


   Returns:
       A binary representation of the input integer.
   """
  
   # Check if the integer is negative
   if i < 0:
       isMinus = True
       i = abs(i)
  
   # Base case
   if i == 0:
       # If the number is negative, push a "-" sign to the stack
       if isMinus:
           stack.push("-")
       # If the stack has only "-" sign, remove it
       if stack.size() == 1 and stack.peek() == "-":
           stack.pop()
       # If the stack is empty, push 0 to the stack
       if stack.is_empty():
           stack.push(0)
          
       # Pop all items from the stack and concatenate them
       # to form the binary representation
       ret = ""
       while not stack.is_empty():
           s = stack.pop()
           ret += str(s)
       return ret
  
   # Recursive case
   # Divide the integer by 2 to get the quotient and remainder
   quotient = i // 2
   remainder = i % 2
   # print(f"i = {i} | quotient = {quotient} | remainder = {remainder}")
   # Push the remainder to the stack
   stack.push(remainder)
   # print(f"stack = {stack.__str__()}")
   # Recursively call the function with the quotient
   return intToBin(quotient, stack, isMinus)

נבחן את הקוד על ידי שימוש ב-assert המשמש לדיבוג קוד ולאיתור שגיאות לוגיות בזמן הפיתוח:

# Test cases
stack = Stack()
assert intToBin(0, stack) == "0"
assert intToBin(1, stack) == "1"
assert intToBin(2, stack) == "10"
assert intToBin(3, stack) == "11"
assert intToBin(4, stack) == "100"
assert intToBin(5, stack) == "101"
assert intToBin(6, stack) == "110"
assert intToBin(7, stack) == "111"
assert intToBin(8, stack) == "1000"
assert intToBin(9, stack) == "1001"
assert intToBin(10, stack) == "1010"
assert intToBin(11, stack) == "1011"
assert intToBin(12, stack) == "1100"
assert intToBin(13, stack) == "1101"
assert intToBin(14, stack) == "1110"
assert intToBin(15, stack) == "1111"
assert intToBin(-1, stack) == "-1"
assert intToBin(-2, stack) == "-10"
assert intToBin(-3, stack) == "-11"
assert intToBin(-4, stack) == "-100"
assert intToBin(-5, stack) == "-101"
assert intToBin(-6, stack) == "-110"
assert intToBin(-7, stack) == "-111"
assert intToBin(-8, stack) == "-1000"
assert intToBin(-9, stack) == "-1001"
assert intToBin(-10, stack) == "-1010"
assert intToBin(-11, stack) == "-1011"
assert intToBin(-12, stack) == "-1100"
assert intToBin(-13, stack) == "-1101"
assert intToBin(-14, stack) == "-1110"
assert intToBin(-15, stack) == "-1111"
print("All tests passed")

• הפונקציה "intToBin" ממירה מספר לייצוגו הבינארי בעזרת stack. היא יודעת להתמודד עם מספרים חיוביים ושליליים.
• הפונקציה משתמשת ברקורסיה.
• במקרה הבסיס base case הפונקציה בודקת אם הקלט הוא 0. אם זה המצב והקלט הוא שלילי הפונקציה דוחפת "-" ל-stack. במידה וה-stack ריק היא דוחפת 0 ל-stack. לבסוף, הפונקציה מסירה את הפריטים מראש הערימה ועד לתחתיתה ומחברת אותם כדי לקבל את הקלט של הייצוג הבינארי.
• במקרה הרקורסיבי, הפונקציה מחלקת את הקלט ב-2 כדי לקבל את מנת החלוקה ושארית. היא דוחפת את השארית ל-stack ואז קוראת באופן רקורסיבי לפונקציה עבור מנת החלוקה. התהליך הרקורסיבי נמשך עד שהפונקציה מגיעה למקרה הבסיס.

מדריכים נוספים שעשויים לעניין אותך

כיצד עובדת רשת האינטרנט?

מה זה זיכרון heap ערימה וזיכרון stack מחסנית

מה זה REST API?

לכל המדריכים בסדרת כישורי מחשב באתר רשתטק

אהבתם? לא אהבתם? דרגו!

0 הצבעות, ממוצע 0 מתוך 5 כוכבים