Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige Überarbeitung Vorherige Überarbeitung
Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:zahlensysteme [2023-05-27 12:01] – [Subraktion] scagf_informatik:zahlensysteme [2025-06-24 06:59] (aktuell) – [Lösungen] sca
Zeile 1: Zeile 1:
 ====== Zahlensysteme ====== ====== Zahlensysteme ======
  
-Dossier: {{ :gf_informatik:gfif_zahlensysteme_dossier.pdf |}}+**{{ :gf_informatik:gfif_zahlensysteme_dossier.pdf |Dossier Zahlensysteme}}**
  
 ++++ Lernziele| ++++ Lernziele|
Zeile 25: Zeile 25:
    * binär multiplizieren    * binär multiplizieren
    * direkt Umrechnen binär <-> hexadezimal    * direkt Umrechnen binär <-> hexadezimal
 +   * umrechnen: hexadezimal <-> dezimal
  
 **Code:** **Code:**
Zeile 62: Zeile 63:
 Dementsprechend gilt also $-42_{10} = 1101\,0110$, *falls* wir $8-$Bit Zahlen inkl. negative Zahlen betrachten. Ohne diese Information würde man die Zahl wohl als die positive Zahl $214_{10}$ interpretieren. Man muss also immer ganz klar sagen, *wie man eine jeweilige Zahl zu interpretieren hat!* Dementsprechend gilt also $-42_{10} = 1101\,0110$, *falls* wir $8-$Bit Zahlen inkl. negative Zahlen betrachten. Ohne diese Information würde man die Zahl wohl als die positive Zahl $214_{10}$ interpretieren. Man muss also immer ganz klar sagen, *wie man eine jeweilige Zahl zu interpretieren hat!*
  
-=== Subraktion ===+=== Subtraktion ===
  
-Beispiel: Wir wollen in $8$-Bit die folgende Subtraktion durchführen: +**Beispiel 1:** Wir wollen in $8$-Bit die folgende Subtraktion durchführen: 
-$$0110\,1001 - 0001\,1101$$+$$0110\,1001 - 0001\,1101 = ?$$
 Bei der Subtraktion wird die erste Zahl Minuend, die Zweite Subtrahend genannt. Bei der Subtraktion wird die erste Zahl Minuend, die Zweite Subtrahend genannt.
  
Zeile 73: Zeile 74:
 $$0110\,1001 - 0001\,1101 = 0100\,1100$$ $$0110\,1001 - 0001\,1101 = 0100\,1100$$
  
 +**Beispiel 2:** Wir wollen berechnen: $$1\,1011 - 101 = ?$$
 +Beachte, dass hier *keine* Angaben bzgl. Anzahl Bits gemacht werden. Wir fassen deshalb beide Zahlen ($1\,1011$ und $101$) als *positive* Zahlen, auch wenn die Bits ganz links eine $1$ sind. Deshalb müssen wir die beiden Zahlen so erweitern, dass:
  
-=== Beispiel binäre Subtraktion ===+   1. beide gleich lang sind 
 +   1. beide links (mind.) eine $0$ haben
  
-Wir wollen berechnen 1101001 - 11101, wobei beide Zahlen als positive Zahlen aufzufassen sind. +Also notieren also beide Zahlen als $6-$Bit Zahlen: 
-Bei der Subtraktion wird die erste Zahl Minuend, die Zweite Subtrahend genannt.+$$01\,1011 - 00\,0101 = ?$$ 
 +Jetzt können wir vorgehen wie in Beispiel 1:
  
-   1. Befülle mit 0, so dass beide gleich lang: 1101001 - 0011101 +   1. 2-er Komplement (Invertieren, $+1$): $11\,1011$ 
-   1. Füge links ein zusäzliches Bit hinzu, damit wir auch negative Zahlen haben können: 01101001 - 00011101 +   1. Addieren: $$01\,1011 + 11\,1011 = 101\,0110$$ 
-   1. Finde 2er-Komplement von Subtrahend (Invertieren, +1): 11100011 +   1. Zusätzliches 7. Bit ignorieren. Da keine feste Bitzahl angegeben wurde, kann man auch noch die Nullen links ignorieren. Resultat ist also: $$1\,1011 - 101 = 1\,0110$$ 
-   1. Addiere Minuend mit 2er-Komplement von Subtrahend: 01101001 + 11100011 = ... + 
-   1. Entferne Bit ganz links, da dieses nur für die Berechnung verwendet wurde: 1001100+$$01\,1011 - 00\,0101 = ?$$
  
  
Zeile 94: Zeile 99:
  
 ===== Lösungen ===== ===== Lösungen =====
- 
-<nodisp 1> 
  
 ++++Binary to Decimal| ++++Binary to Decimal|
  
-Verschiedene Versionen:+Nehmen wir `b = '100101'` als Beispiel. Jede Ziffer in diesem String steht an einer bestimmten Position: 
 +``` 
 +Ziffer:   100101 
 +Position: 012345 
 +``` 
 +Um die Binärzahl in eine Dezimalzahl umzurechnen, müssen wir potenzieren: 
 +$$1 \cdot 2^\color{red}{5} + 0 \cdot 2^\color{red}{4} + 0 \cdot 2^\color{red}{3} + 1 \cdot 2^\color{red}{2} + 0 \cdot 2^\color{red}{1} + 1 \cdot 2^\color{red}{0}$$ 
 + 
 +Zu jeder Ziffer gehört also die passende Potenz: 
 +``` 
 +Ziffer:   100101 
 +Position: 012345 
 +Potenz:   543210 
 +``` 
 +Die Schwierigkeit bei diesem Code ist, dass **Position und Exponent genau gegenteilig sind**: Die Position startet bei $0$ und zählt hoch, der Exponent startet bei $5$ und zählt herunter. 
 + 
 +Dieses Problem kann man unterschiedlich lösen. Zwei mögliche Ansätze sind: 
 + 
 +   1. Man macht **zwei separate Variablen**: Eine für die Position und eine für den Exponenten. 
 +   2. Man **dreht den Binärstring um**, also aus `'100101'` wird `'101001'`: Jetzt stimmen Position und Exponent überein. Allerdings haben  wir nie besprochen, wie man diese Umkrehrung einfach erreichen kann. 
 + 
 +Hier einige mögliche Lösungen für den ersten Ansatz: 
 <code python> <code python>
-def binary_to_decimal_1(b): +def binary_to_decimal_1a(b): 
-    d = 0 # decimal nr +    """ 
-    i = 0 +    Löse mit zwei Variablen: 
-    while i < len(b): +    - Variable i (der for-Schleife) zählt alle Positionen durch 
-        d = d + int(b[len(b)-i-1]) * 2**i # len(b)-i-1 to go through b in reverse order +    - Variable exponent legt Exponenten fest und zählt herunter 
-        i = i + 1 +    """ 
-    return d+    dec = 0 # Dezimalzahl 
 +    exponent = len(b) - 1 # Exponent Startwert 
 +    for i in range(len(b)): # Schleife über Position 
 +        if b[i] == '1': 
 +            dec = dec + 2**exponent 
 +        exponent = exponent - 1 
 +    return dec
  
-def binary_to_decimal_2(b): +print(binary_to_decimal_1a('100101'))
-    d = 0 # decimal nr +
-    i = 0 +
-    while i < len(b): +
-        d = d + int(b[-i-1]) * 2**i # can also use negative indices to go through d in reverse order +
-        i = i + 1 +
-    return d+
  
-def binary_to_decimal_3(b): +def binary_to_decimal_1b(b): 
-    d = 0 # decimal nr +    """ 
-    i = len(b) - 1 +    Wie Varianbte 1a, nur gehen wir mit for-Schleife direkt die Elemente des Binärstrings durch (ohne Position)  
-    power = 1 +    """ 
-    while i >= 0: +    dec = 0 # Dezimalzahl 
-        d = d + int(b[i]) * power +    exponent = len(b) - 1 # Exponent Startwert 
-        power = power * 2 +    for nr in b: # Schleife über Position 
-        i = i - 1 +        if nr == '1': 
-    return d+            dec = dec + 2**exponent 
 +        exponent = exponent - 1 
 +    return dec 
 + 
 +print(binary_to_decimal_1b('100101')) 
 + 
 +def binary_to_decimal_1c(b): 
 +    """ 
 +    Wie Varianbte 1b, nur ohne if. Dafür wandeln wir die Elemente des Binärstrings in eine Zahl um. 
 +    """ 
 +    dec = 0 # Dezimalzahl 
 +    exponent = len(b) - 1 # Exponent Startwert 
 +    for nr in b: # Schleife über Position 
 +        dec = dec + int(nr) * 2**exponent 
 +        exponent = exponent - 1 
 +    return dec 
 + 
 +print(binary_to_decimal_1c('100101')) 
 + 
 +def binary_to_decimal_1d(b): 
 +    """ 
 +    Wie Varianbte 1a, nur wird exponent direkt aus i berechnet und muss dadurch nicht in jedem Schritt der Schleife um 1 reduziert werden.  
 +    """ 
 +    dec = 0 # Dezimalzahl 
 +    for i in range(len(b)): # Schleife über Position 
 +        exponent = len(b) - i - 1 # Berechnung Exponent 
 +        if b[i] == '1': 
 +            dec = dec + 2**exponent 
 +    return dec 
 + 
 +print(binary_to_decimal_1d('100101'))
 </code> </code>
 +
 ++++ ++++
  
Zeile 145: Zeile 201:
  
 <code python> <code python>
 +
 def binary_add(b1,b2): def binary_add(b1,b2):
 +    b1 = b1.replace(" ","") # remove all blanks
 +    b2 = b2.replace(" ","") # remove all blanks
     # make sure strings have same length     # make sure strings have same length
     while len(b1) < len(b2):     while len(b1) < len(b2):
Zeile 173: Zeile 232:
         summe = '1' + summe         summe = '1' + summe
     return summe     return summe
 + 
 def invert(b): def invert(b):
 +    b = b.replace(" ","") # remove all blanks
     inv = ""     inv = ""
     i = 0     i = 0
Zeile 184: Zeile 244:
         i = i + 1         i = i + 1
     return inv     return inv
 + 
 def complement(b): def complement(b):
 +    b = b.replace(" ","") # remove all blanks
     b = invert(b)     b = invert(b)
     b = binary_add(b,'1')     b = binary_add(b,'1')
     return b     return b
 + 
 def binary_sub(b1,b2): # calc b1-b2 def binary_sub(b1,b2): # calc b1-b2
 +    b1 = b1.replace(" ","") # remove all blanks
 +    b2 = b2.replace(" ","") # remove all blanks    
     # make sure strings have same length     # make sure strings have same length
     while len(b1) < len(b2):     while len(b1) < len(b2):
Zeile 196: Zeile 259:
     while len(b1) > len(b2):     while len(b1) > len(b2):
         b2 = '0' + b2         b2 = '0' + b2
-     +  
-    # add additinal zero at left (for negative numbers)+    # add additional zero at left (to distinguish between positive and negative numbers)
     b1 = '0' + b1     b1 = '0' + b1
     b2 = '0' + b2     b2 = '0' + b2
-    + 
     result = binary_add(b1,complement(b2))     result = binary_add(b1,complement(b2))
     result = result[1:] # remove first bit     result = result[1:] # remove first bit
          
-    while result[0] == '0': # remove all zeros at beginning (optional)+    while len(result) > 1 and result[0] == '0': # remove all zeros at beginning (optional)
         result = result[1:]         result = result[1:]
 +    return result
 +
 +def binary_mul(b1,b2):
 +    b1 = b1.replace(" ","") # remove all blanks
 +    b2 = b2.replace(" ","") # remove all blanks    
 +    result = ""
 +    
 +    i = len(b1) - 1
 +    while i >= 0:
 +        if b1[i] == '1':
 +            result = binary_add(result,b2)
 +        b2 = b2 + '0'
 +        i = i - 1
 +    
 +    while len(result) > 1 and result[0] == '0': # remove all zeros at beginning
 +        result = result[1:]
 +
     return result     return result
 </code> </code>
Zeile 211: Zeile 291:
 ++++ ++++
  
-</nodisp> 
  
  
Zeile 326: Zeile 405:
 </code> </code>
 ++++ ++++
 +
 +++++Function Testing|
 +
 +<code python>
 +### FUNCTION TESTING CODE
 +for i in range(1000):
 +    da = random.randint(0,165)
 +    db = random.randint(0,165)
 +    if db > da: da,db = db,da
 +    a = bin(da)[2:]
 +    b = bin(db)[2:]
 +    if not a == invert(invert(a)):
 +        print("ERROR Invert: ",a,invert(a))
 +    
 +    if not binary_add(a,b) == bin(int(a,2)+int(b,2))[2:]:
 +        print("ERROR Add: ",a,b)
 +    
 +    if not binary_sub(a,b) == bin(int(a,2)-int(b,2))[2:]:
 +        print("ERROR Sub: ",a,b)
 +</code>
 +++++
 +
 +++++Exercise Generator|
 +<code python>
 +### EXERCISE GENERATOR
 +for i in range(3):
 +    da = random.randint(128,256)
 +    db = random.randint(128,256)
 +    if db > da: da,db = db,da
 +    a = bin(da)[2:]
 +    b = bin(db)[2:]    
 +    print("Berechne schriftlich von Hand (Bemerkung & isPencil-Feld), trage Resultat ins Antwortfeld ein:\n" + a + " + " + b )
 +    print("LOESUNG: " + binary_add(a,b) + "\n")
 +
 +for i in range(3):
 +    da = random.randint(128,256)
 +    a = bin(da)[2:]
 +    print("Berechne schriftlich von Hand (Bemerkung & isPencil-Feld), trage Resultat ins Antwortfeld ein. 2-er Komplement in 8-Bit von:\n" + a)
 +    print("LOESUNG: " + binary_complement(a) + "\n")
 +
 +for i in range(3):
 +    da = random.randint(128,256)
 +    db = random.randint(128,256)
 +    if db > da: da,db = db,da
 +    a = bin(da)[2:]
 +    b = bin(db)[2:]    
 +    print("Berechne schriftlich von Hand (Bemerkung & isPencil-Feld), trage Resultat ins Antwortfeld ein. Lasse überflüssige Nullen auf linker Seite weg.\n" + a + " - " + b )
 +    print("LOESUNG: " + binary_sub(a,b) + "\n")
 +
 +for i in range(3):
 +    da = random.randint(1,15)
 +    db = random.randint(1,15)
 +    if db > da: da,db = db,da
 +    a = bin(da)[2:]
 +    b = bin(db)[2:]
 +    while len(a) < 4: a = '0' + a  
 +    while len(b) < 4: b = '0' + b  
 +    print("Berechne schriftlich von Hand (Bemerkung & isPencil-Feld), trage Resultat ins Antwortfeld ein.\n" + a + " * " + b )
 +    print("LOESUNG: " + bin(da*db)[2:] + "\n")
 +</code>
 +++++
 +
 +
 </nodisp> </nodisp>
  
  • gf_informatik/zahlensysteme.1685188900.txt.gz
  • Zuletzt geändert: 2023-05-27 12:01
  • von sca