Lab3

Forelesning

Torstein vil vite hvor mange som har kommet på forelesning, og ønsker at noen skal telle det for han. Du har fått denne oppgaven og tenker å skrive et program som kan hjelpe deg å telle. Programmet ditt skal be brukeren om å oppgi hvor mange som nettopp kom inn døren, og så skal programmet legge dette til en total som skrives ut. Programmet skal fortsette å be om tall helt til brukeren skriver 0. Du kan anta at brukeren alltid skriver inn et heltall.

I filen lecture.py, skriv kode som gjør følgende:

• Lag en variabel num_of_students og sett den til 0.
• Lag en variabel just_arrived og sett den til 1. Dette tallet vil overskrives i løkken uansett, men må begynne som et tall større enn 0
• Lag en while-løkke som kjører så lenge just_arrived ikke er lik 0.
• Inne i løkken:
  • Be brukeren om hvor mange som nettopp kom inn døren og lagre dette i variabelen just_arrived.
  • Legg just_arrived til num_of_students.
  • Print hvor mange studenter som er kommet til nå.

Eksempelkjøring:

Hvor mange kom inn døren? 2
Det har kommet 2 studenter på forelesning.
Hvor mange kom inn døren? 3
Det har kommet 5 studenter på forelesning.
Hvor mange kom inn døren? -1
Det har kommet 4 studenter på forelesning.
Hvor mange kom inn døren? 0
Det har kommet 4 studenter på forelesning.

Oppdelt linjestykke

Del A: Finn endepunkter for et enkelt segment

Et endimensionalt linjestykke langs x-aksen begynner i et punkt x_lo og slutter i et punkt x_hi. I filen split_line.py lag en funksjon get_endpoints(). Denne funksjonen tar inn 4 parametere: i, n, x_lo og x_hi. Parametrene x_lo og x_hi er flyttall og definerer linjestykket som nevnt ovenfor. Parametrene i og n er begge heltall. Funksjonen get_endpoints() skal returnere start- og sluttpunktet for segmentet med indeks i når vi deler hele linjen i n like store deler. For eksempel: get_endpoints(1, 4, 50.0, 150.0) skal returnere 75.0, 100.0, og get_endpoints(3, 4, 50.0, 150.0) skal returnere 125.0, 150.0 (se figuren nedenfor).

def foo(bar):
    a = 2 * bar
    b = 3 * bar
    return a, b

x, y = foo(5)

print(x) # 10
print(y) # 15

Del B: Lag et interaktivt program

I samme fil (split_line.py) utvid koden slik at programmet:

• Ber brukeren oppgi koordinaten x_lo.
• Ber brukeren oppgi koordinaten x_hi.
• Ber brukeren skrive inn tallet n; antall stykker linjestykket skal deles opp i.
• Skriver ut n linjer, der hver linje består av to tall som representerer et linjestykke (bruk hjelpefunksjonen fra del A).

Eksempelkøringer skal se sånn ut:

x_lo =  1.0  
x_hi =  7.0
n =  3
1.0 3.0
3.0 5.0
5.0 7.0

x_lo =  0.0  
x_hi =  1.0
n =  4
0.0 0.25
0.25 0.5
0.5 0.75
0.75 1.0

Fargetog

I denne oppgaven skal vi lage en funksjon som tegner et tog med fargede vogner på et uib_inf100_graphics.simple canvas.

PS: Vi er klar over at resultatet ikke egentlig ligner på et tog, men det er gøyere å kalle det et tog enn en rekke med fargede rektangler.

Kun oppgaven under Del A er obligatorisk, men vi anbefaler at du prøver resten også

Forberedelser: Repeter hvordan du går gjennom alle elementene i en samling med strenger: For-løkker over range

Del A: Tegn et tog med fargede vogner

Vi begynner med den enkleste versjonen av denne oppgaven. I filen color_train.py, lag en funksjon color_train_A(). Denne funksjonen tar inn 4 parametere: canvas, x, y, colors. Funksjonen skal tegne fargede ruter (eller vogner) med en fast størrelse på 15 x 10px (bredde x høyde) etter hverdandre på canvaset. Rekken av vogner skal starte på \((x, y)\) og gå fra venstre til høyre. Fargene er gitt i listen colors.

For eksempel, hvis rekken av farger er ["white", "black", "white"] så skal første vognen (fra venstre) være hvit, andre vognen skal være svart og tredje vognen svart.

Merk: Du skal ikke kalle på display-funksjonen i samme fil som du skriver funksjonene. For å teste koden, opprett en separat fil color_train_test.py i samme mappe som color_train.py og kopier inn koden du finner under (i Testing-boksen):

from uib_inf100_graphics.simple import canvas, display
from color_train import color_train_A#, color_train_B, color_train_C

colors1 = ['violet', 'indigo', 'blue', 'green', 'yellow', 'orange', 'red']
colors2 = ['black', 'white', 'black', 'white', 'black', 'white']
colors3 = ['#800080', '#8B008B', '#9400D3', 
           '#9932CC', '#8A2BE2', '#9370DB', 
           '#7B68EE', '#6A5ACD', '#483D8B', 
           '#0000FF', '#0000CD', '#00008B', 
           '#000080', '#191970', '#00008B']

color_train_A(canvas, 10, 10, colors1)
color_train_A(canvas, 10, 20, colors2)
color_train_A(canvas, 10, 40, colors3)

display(canvas)

Når du kjører color_train_test.py, skal det tegnes 3 tog på skjermen som vist under:

Del B: Tegn et fargetog med oppgitt høyde og bredde

I denne delen skal vi utvide funksjonen color_train_A() til å ta inn to ekstra parametere: width og height. Disse to parametrene skal bestemme bredden og høyden på toget.

I color_train.py, skriv en funksjon color_train_B() som tar inn 6 parametere: canvas, x, y, width, height og colors. Som i A skal funksjonen tegne fargede rektangler etter hverandre, men nå skal den totale bredden på toget være width og høyden skal være height. Det betyr at du må regne ut bredden til hver enkelt vogn fra dette.

For å teste koden, i color_train_test.py (fra Del A) legg til disse funksjonskallene rett før display(canvas):

color_train_B(canvas, 50, 195, 300, 10, colors1)
color_train_B(canvas, 50, 150, 150, 30, colors2)
color_train_B(canvas, 50, 180, 50, 15, colors3)

Pass på at du flytter på kommentaren i toppen av test-filen slik at bare color_train_C er kommentert ut. Den må forbli kommentert ut fram til du gjør Del C.

Når du kjører color_train_test.py, skal det tegnes 3 nye tog på skjermen som vist under:

Del C: Tegn et fargetog bare med koordinater

I denne delen skal vi lage enda en ny funksjon color_train_C() som tar inn 6 parametere: canvas, x1, y1, x2, y2 og colors. Funksjonen skal gjøre det samme som i B, men tar nå utgangspunkt i to punkter: \((x_1, y_1)\) og \((x_2, y_2)\). Disse to punktene skal være øvre venstre hjørne og nedre høyre hjørne til det ferdige toget.

For å teste koden, i color_train_test.py (fra Del A) legg til disse funksjonskallene rett før display(canvas):

color_train_C(canvas, 200, 380, 350, 400, colors1)
color_train_C(canvas, 80, 360, 350, 380, colors2)
color_train_C(canvas, 80, 380, 200, 400, colors3)

Hint

Hvis du regner høyde og bredde fra punktene, kan du gjenbruke color_train_B() her.

Når du kjører color_train_test.py, skal det tegnes 3 nye tog på skjermen som vist under:

Mønster

I denne oppgaven skal vi lage en funksjon som tegner et repeterende motiv på et uib_inf100_graphics.simple canvas. Kun oppgaven under Del A er obligatorisk.

Når du leverer denne oppgaven på CodeGrade, vil et skjermbilde av programmet ditt automatisk lastes opp til galleriet, hvor du også kan se dine medstudenter sine besvarelser.

Del A: Tegn et repeterende motiv

I en fil draw_pattern.py, lag en funksjon draw_pattern(). Denne funksjonen tar inn 2 parametere: canvas og n. Parameteren n tilsier hvor mange ganger motivet skal gjentas. Motivet kan være så enkelt som en sirkel med radius 10px, men du må gjerne være mer oppfinnsom enn det. Avstanden mellom motivene bestemmer du selv. Det eneste kravet er at du bruker en løkke for å tegne motivene.

I samme fil, kall på draw_pattern med canvas og et tall som argument, og kall på display-funksjonen for å vise resultatet.

Under er en funksjon som tegner et trafikklys, om du ikke har noen ideer selv:

def draw_traffic_light(canvas, x, y):
    canvas.create_rectangle(x, y, x + 50, y + 150, fill='black')
    canvas.create_oval(x + 10, y + 10, x + 40, y + 40, fill='red')
    canvas.create_oval(x + 10, y + 60, x + 40, y + 90, fill='yellow')
    canvas.create_oval(x + 10, y + 110, x + 40, y + 140, fill='green')  

Hvis du legger draw_traffic_light() inn i koden din kan du kalle på den med koordinater som bestemmes for hver iterasjon. For eksempel kan du variere x og y slik for hver iterasjon:

$$ x = 10 + 50*i$$

og

$$ y = 10 + 10*i$$

Her antar vi at i er en variabel som øker med 1 for hver iterasjon. Da vil hvert trafikklys tegnes 50 piksler til høyre for det forrige og 10 piksler lenger ned.

Her er eksempler på hvordan resultatet kan se ut:

Del B: Tegn motivet over hele lerretet

Forberedelser: les om nøstede løkker

I denne delen skal du utvide funksjonen din slik at den tegner motivet over hele lerretet. Nå tilsier n hvor mange ganger du tegner i hver retning. Du kan gjøre dette ved å bruke nøstede løkker. Hvis du bruker løkker over range() kan du ha den ytterste løkken over y og innerste over x. Da tegner den innerste løkken motivet n ganger, og denne løkken blir gjennomført n ganger av den ytterste løkken.

Her er trafikklyset tegnet på denne måten:

Sparing

Du er uteksaminert fra UiB og har nå en flott jobb! Du flytter til London og bestemmer deg for at du vil begynne å spare for å kjøpe hus. Siden boligprisene er svært høye i London, innser du at du må spare i flere år før du har råd til å skaffe deg egenkapital. Vi skal finne ut hvor lang tid det vil ta deg å spare nok egenkapital gitt følgende forutsetninger:

• Egenkapital er 0,25 (25%) av total kostnad.
• Beløpet du har spart så langt er null.
• Anta at sparingene dine tjener en årlig rente \(r = 0.04\) (4%).

I filen saving.py skriv en funksjon som tar inn tre tall som input:

1. Årslønn.
2. Prosentandel av lønnen som skal spares.
3. Totalkostnaden for drømmeboligen.

Funnksjonen skal returnere hvor mange måneder det vil ta deg å spare opp nok egenkapital. Her kan du anta at det etter hver måned blir utbetalt \(r/12\) i renter av det som står på konto.

Her er kode du kan legge til på slutten av filen for å teste funksjonen din:

print("Tester saving... ", end="")
assert saving(500000, 20, 3000000) == 79
assert saving(900000, 10, 5000000) == 133
print("OK")