Basis

Basis#

Wisselende stelsels#

De volgende problemen hebben te maken met de weergave van grondtallen en het omzetten of het berekenen ervan.

Om te beginnen zal je worden gevraagd om van grondtal 10 naar andere grondtallen om te zetten en omgekeerd. Omdat bij grondtallen groter dan grondtal 10 nieuwe “cijfers” nodig zijn, beperken we ons tot grondtallen 2 tot en met 10.

Functie 1: num_to_base_b(n, b)#

Schrijf een Python functie num_to_base_b(n, b), die een (niet negatieve) integer n en een grondtal b (van 2 tot en met 10) accepteert en een string teruggeeft die het getal n in grondtal b voorstelt.

Je hoeft niet te controleren of b tussen 2 en 10 ligt, we zullen ervoor zorgen dat dit de enige waarden zijn die we testen.

Vergeet ook niet dat hier integerdeling (zonder cijfers achter de komma) nodig is. In Python wordt bij integerdeling altijd naar beneden afgerond en daar gebruik je // voor, bijvoorbeeld,

18 // 7 == 2

Hier zie je een aantal voorbeelden:

In [1]: num_to_base_b(3116, 9)
Out[1]: '4242'

In [2]: num_to_base_b(141474, 8)
Out[2]: '424242'

In [3]: num_to_base_b(42, 8)
Out[3]: '52'

In [4]: num_to_base_b(42, 5)
Out[4]: '132'

In [5]: num_to_base_b(42, 10)
Out[5]: '42'

In [6]: num_to_base_b(42, 2)
Out[6]: '101010'

In [7]: num_to_base_b(4, 2)
Out[7]: '100'

In [8]: num_to_base_b(4, 3)
Out[8]: '11'

In [9]: num_to_base_b(4, 4)
Out[9]: '10'

In [10]: num_to_base_b(0, 4)
Out[10]: ''                   # merk op dat als n 0 is we een lege string willen!!

In [11]: num_to_base_b(0, 2)
Out[11]: ''                   # merk op dat als n 0 is we een lege string willen!!

Hier zie je een aantal tests die je kan gebruiken:

assert num_to_base_b(0, 4) == ''
assert num_to_base_b(42, 5) == '132'

Je kan er natuurlijk meer bedenken!

# jouw oplossing

Functie 2: base_b_to_num(s, b)#

Daarom ga je een Python functie base_b_to_num(s, b) schrijven die een string s en een grondtal b accepteert, waarbij s een getal in grondtal b voorstelt en b een getal van 2 tot en met 10 is. De functie base_b_to_num moet een integer in grondtal 10 teruggeven die hetzelfde getal voorstelt als s.

Je hoeft niet te controleren of b tussen 2 en 10 ligt, we zullen ervoor zorgen dat dit de enige waarden zijn die we testen.

In [1]: base_b_to_num("5733", 9)
Out[1]: 4242

In [2]: base_b_to_num("1474462", 8)
Out[2]: 424242

In [3]: base_b_to_num("222", 4)
Out[3]: 42

In [4]: base_b_to_num("101010", 2)
Out[4]: 42

In [5]: base_b_to_num("101010", 3)
Out[5]: 273

In [6]: base_b_to_num("101010", 10)
Out[6]: 101010

In [7]: base_b_to_num("11", 2)
Out[7]: 3

In [8]: base_b_to_num("11", 3)
Out[8]: 4

In [9]: base_b_to_num("11", 10)
Out[9]: 11

In [10]: base_b_to_num("", 10)
Out[10]: 0                         # de lege string moet 0 opleveren

Tip

Jouw functie base_b_to_num moet 0 teruggeven als s een lege string is. Verder,

  • Zoals gewoonlijk zal het meest rechtse karakter van de string de “een“‘en kolom zijn,” het minst significante getal in grondtal b.

  • … maar dat betekent dat de waarde van het meest rechtse teken gewoon int(s[-1]) is!

Nogmaals, hier zijn de Python functies om strings en getallen in elkaar om te zetten:

  • str(x) geeft het getal (de integer) x terug als string

  • int(x) geeft de integerwaarde van de string s terug, Python zal een ValueError geven als s geen integer voorstelt

# jouw oplossing

Functie 3: base_to_base(b1, b2, s_in_b1)#

Nu kunnen we wat we geschreven hebben samenvoegen tot een functie base_to_base(b1, b2, s_in_b1) die drie argumenten accepteert, een grondtal b1, een grondtal b2 (beide met een waarde tussen 2 tot en met 10) en s_in_b1, wat een string is die een getal in grondtal b1 voorstelt.

De functie base_to_base moet een string teruggeven die dezelfde waarde in grondtal b2 vertegenwoordigt.

Hier zijn een aantal voorbeelden:

In [1]: base_to_base(2, 10, "11")   # 11 in grondtal 2 is 3 in grondtal 10...
Out[1]: '3'

In [2]: base_to_base(10, 2, "3")    # 3 in grondtal 10 is 11 in grondtal 2...
Out[2]: '11'

In [3]: base_to_base(3, 5, "11")    # 11 in grondtal 3 is 4 in grondtal 5...
Out[3]: '4'

In [4]: base_to_base(2, 3, "101010")
Out[4]: '1120'

In [5]: base_b_to_num("1120", 3)
Out[5]: 42

In [6]: base_to_base(2, 4, "101010")
Out[6]: '222'

In [7]: base_to_base(2, 10, "101010")
Out[7]: '42'

In [8]: base_to_base(5, 2, "4321")
Out[8]: '1001001010'

In [9]: base_to_base(2, 5, "1001001010")
Out[9]: '4321'

Tip

  • Gebruik eerst base_b_to_num om een gewoon, decimaal getal voor s_in_b1 te krijgen. Geef het een naam.

  • Gebruik dan de functie num_to_base_b om die waarde om te zetten naar het juiste grondtal!

# jouw oplossing

Functie 4: add(s, t)#

Dit is een korte opgave om de functies die je hebt geschreven te gebruiken!

Schrijf een functie add(s, t) die twee binaire strings s en t accepteert en hun som als resultaat teruggeeft terugstuurt, ook als binaire string.

We raden je aan dit te doen door de twee binaire strings om te zetten in twee getallen in grondtal 10, de twee getallen bij elkaar op te tellen en de resulterende som vervolgens weer om te zetten naar grondtal 2!

Hier zijn een aantal voorbeelden:

In [1]: add("11", "1")
Out[1]: '100'

In [2]: add("11", "100")
Out[2]: '111'

In [3]: add("110", "11")
Out[3]: '1001'

In [4]: add("11100", "11110")
Out[4]: '111010'

In [5]: add("10101", "10101")
Out[5]: '101010'

# jouw oplossing