Detta dokument innehåller de övningar som hör till kursen 729G04 - Programmering och diskret matematik vid Linköpings universitet. Senaste uppdateringen gjord 2012–08–14 av Jody Foo. Ursprungligen författad av Annika Silvervarg.
De flesta övningar kräver att ni ger vissa funktioner specifika namn. Det är väldigt viktigt att ni gör detta. Rättningen av labbarna är delvis automatiserad. Att ge funktionerna fel namn kan resultera i komplettering.
Uppgifter markerade med en * (1.10 och 1.11) är överkursuppgifter och behöver inte lämnas in.
Skriv en funktion, bill() som beräknar notan på restaurangen och returnerar svaret. Den tar tre tal som argument. Det första anger hur många personer som ätit, det andra hur många rätter varje person har ätit och det tredje hur mycket varje person har druckit. En maträtt kostar i snitt 70 kr och en dryck kostar i snitt 30kr.
Ett exempel om 5 personer har ätit 2 rätter var och druckit 3 drycker var anropas funktionen på följande sätt:
>>> nota(5, 2, 3)
1150
Skriv en funktion split_bill() som beräknar hur stor del av en gemensam nota som varje person ska betala om man delar notan jämnt. Funktionen tar två argument hela beloppet som ska betalas samt antal personer som har ätit. Funktionen returnerar svaret och anropas på följande sätt:
>>> split_bill(777, 5)
155.4
Skriv sedan om funktionen så att den även lägger till 10% i dricks
>>> split_bill_include_tip(777, 5)
170.94
Skriv funktionen concatenate_strings som tar två strängar som argument och sedan returnerar strängarna som ett sammansatt ord.
>>> concatenate_strings("jätte","kul")
'jättekul'
Skriv funktionen space_exists() som tar en sträng som argument och undersöker om det finns något mellanslag i strängen. Om det finns ett mellanslag ska den returnera True annars False. Du ska inte använda någon villkorssats. Funktionen ska anropas på följande sätt.
>>> space_exists("Hej på dig!")
True
>>> space_exists("abrakadabra")
False
Skriv funktionen insert_element_first() som stoppar in ett element först i en lista. Funktionen tar två argument, en lista och ett element och returnerar den nya listan.
Funktionen ska anropas på följande sätt:
>>> insert_element_first(0, [1, 2, 3])
[0, 1, 2, 3]
>>> insert_element_first ('a', ['b', 'c', 'd'])
['a', 'b', 'c', 'd']
>>> insert_element_first ('Hejsan', [])
['Hejsan']
>>> insert_element_first ([1, 2, 3], ['a', 'b', 'c'])
[[1, 2, 3],'a', 'b', 'c']
Skriv funktionen insert_element_last() som stoppar in ett element sist i en lista. Funktionen tar två argument, en lista och ett element och returnerar den nya listan. Funktionen ska anropas på följande sätt:
>>> insert_element_last(0, [1, 2, 3])
[1, 2, 3, 0]
>>> insert_element_last('a', ['b', 'c', 'd'])
['b', 'c', 'd', 'a']
>>> insert_element_last('Hejsan', [])
['Hejsan']
>>> insert_element_last([1, 2, 3], ['a', 'b', 'c'])
['a', 'b', 'c', [1, 2, 3]]
Skriv funktionen get_first_element() som tar ut det första elementet i en lista. Funktionen tar en lista som argument och returnerar ett element.
Funktionen ska kunna anropas på följande sätt.
>>> get_first_element([1, 2, 3])
1
>>> get_first_element (['Hejsan'])
'Hejsan'
>>> get_first_element([[1, 2, 3], ['a', 'b', 'c']])
[1, 2, 3]
Skriv en funktion generate_pet_name() som tar en lista med strängar som argument och som returnerar ett slumpmässigt djurnamn. För att slumpa ett element ur en lista a_list använder man
import random
random.choice(a_list)
Funktionen ska kunna anropas på följande sätt:
>>> generate_pet_name(['Fluff', 'Puff', 'Kurr', 'Murr', 'Buff', 'Tuff'])
Tuff-Tuff
>>> generate_pet_name(['Fleff', 'Morr', 'Biff', 'Taff'])
Morr-Fleff
Skriv en funktion random_sentence() som får en lista som i sin tur innehållande tre listor:
Funktionen slumpar fram en mening genom att kombinera ett element från de nästlade listorna. Exempel på körning:
>>> word_list = [['Lisa', 'Kalle', 'En robot', 'En katt'], ['ser', 'har', 'vill ha', 'undviker'], ['en båt', 'en bil', 'ett äpple', 'ett ufo']]
>>> random_sentence(word_list)
'En katt ser en båt'
>>> random_sentence(word_list)
'Lisa vil ha ett ufo'
Skriv en funktion create_person() som skapar (returnerar) en dictionary för en person med nycklarna name och age. Funktionen tar två argument ett namn, dvs en sträng, och en ålder, dvs ett tal. Funktionen ska returnera det skapade dictionary-objektet.
Funktionen ska kunna anropas på följande sätt:
>>> create_person("Kalle", 23)
{'age': 23, 'name': 'kalle'}
>>> create_person("Katarina", 34)
{'age': 34, 'name': 'Katarina'}
Om man vill spara de “personer”, dvs de dictionaries, som man skapar måste man lagra dessa i variabler, t ex
>>> kalle = create_person("Kalle", 23)
>>> katarina = create_person("Katarina", 34)
Då kan man använda dem senare, se nästa uppgift.
Skriv en funktion print_person_info() som tar en dictionary för en person med nycklarna name och age och skriver ut en informationstext där namnet och åldern har använts, se exemplen nedan. I exemplet är kalle en variabel som innehåller en dictionary, se föregående uppgift
>>> print_person_info(kalle)
Hejsan Kalle
Visste du att du är 3.28571428571 hundår?
Men du är också 725328000 sekunder gammal!
Om ett litet barn ville ha din uppmärksamhet skulle dit namn bli:
KalleKalleKalleKalleKalle
>>> print_person_info(katarina)
Hejsan Katarina
Visste du att du är 4.85714285714 hundår?
Men du är också 1072224000 sekunder gammal!
Om ett litet barn ville ha din uppmärksamhet skulle dit namn bli:
KatarinaKatarinaKatarinaKatarinaKatarina
TIPS! Hundår beräknas som åldern delat med 7 och sekunder är åldern * 365 * 24 * 60 * 60. För att upprepa en sträng kan man använda operatorn *. T.ex.
>>> "hej"*5
'hejhejhejhejhej'
SyntaxError?"hejsan""hoppsan"""Tjopp"""a = 8 + 0 + 9[4, 6 "a"]a[]I detta avsnitt kommer ni att få labba med mera funktioner och med villkorssatser.
Skriv en funktion greeting() som tar en sträng som argument och som returnerar en sträng. Strängen som ges som input ska antas vara ett namn. För de flesta namn ska funktionen returnera strängen “Hejsan X”, där X är strängen som skickades till funktionen. För vissa namn (lagrade i en lista) ska den dock säga “Hej X, vad roligt att se dig igen!” Se exempelkörning nedan.
>>> greeting("Mia")
'Hejsan Mia'
>>> greeting("Nike")
'Hejsan Nike, vad roligt att se dig igen!'
Skriv en funktion confirm_quit() som frågar användaren efter ett svar. Om användaren svarar “ja”, eller “yes”, ska funktionen returnera True. Annars ska den returnera false. Exempel på körning:
>>> confirm_quit()
Are you sure you want to quit? (yes/no): Yes
True
>>>
Skriv en funktion is_this_a_long_list() som tar en lista som argument och returnerar True eller False beroende på hur lång listan är. Listor längre än 5 element anses som långa. Exempelkörning nedan:
>>> is_this_a_long_list([1, 2, 3])
False
>>> is_this_a_long_list([1, 2, 3, 5, 6, 7])
True
>>>
Skriv en funktion guess_dice() som låter användaren gissa ett träningskast. Du kan använda funktionen random.randint(1,6) används för att slumpa ett tal mellan 1 och 6. Glöm inte att du måste importera modulen random med import random.
>>> guess_dice()
Din gissning: 3
Tärningen visar 4
Du förlorar!
>>> guess_dice()
Din gissning: 3
Tärningen visar 3
Du vinner!
def score_to_grade():
resultat = int(raw_input("Ange resultatpoäng på tentan: "))
if resultat > 20:
print "Du fick G på tentan" elif (resultat > 30):
print "Grattis, du fick VG på tentan" else:
print "Tyvärr, du fick U på tentan"
Ovanstående kod är ett försök att skriva en funktion, score_to_grade() som returnerar betyg givet poäng på en tenta
Hur kan man skriva om följande uttryck i funktionen så att det blir ett if - elif - else uttryck
def even_odd_or_large(x):
if x < 100:
if odd(x):
return str(x) + " is a small, odd number."
else:
return str(x) + " is a small, even number."
else:
return str(x) + " is large."
Funktionen odd(x) är definierad i labbskelettet och returnerar True om x är ett udda tal och False om x är ett jämnt tal.
Skriv om följande funktion days_in_month så att det innehåller så få villkorssatser som möjligt, men bibehåller samma funktionalitet.
def days_in_month(name_of_month):
if name_of_month == "jan":
print 31
elif name_of_month == "feb":
print 28
elif name_of_month == "mar":
print 31
elif name_of_month == "apr":
print 30
elif name_of_month == "may":
print 31
elif name_of_month == "jun":
print 30
elif name_of_month == "jul":
print 31
elif name_of_month == "aug":
print 31
elif name_of_month == "sep":
print 30
elif name_of_month == "oct":
print 31
elif name_of_month == "nov":
print 30
elif name_of_month == "dec":
print 31
Skriv om följande funktion get_integer_category() så att if - elif delen står med så få villkor som möjligt.
def get_integer_category(x):
if x > 0:
if odd(x):
return "Positive, odd integer"
else:
if not odd(x):
return "Positive, even integer"
if x < 0:
if odd(x):
return "Negative, odd integer"
else:
if not odd(x):
return "Negative, even integer"
if x == 0:
return "Zero"
Skriv om följande funktion get_cold_string() så att det använder så få villkorsatser som möjligt.
def get_cold_string(temp):
if temp > 0:
if temp < 10:
return "Hmm"
else:
if temp < 20:
return "Mmm"
else:
if temp < 30:
return "Puh"
if temp < 0:
return "Brr"
Skriv om följande if-uttryck i funktionen entrance_fee() med så få villkor som möjligt.
def entrance_fee(age, gender):
if age >= 20:
return 100
else:
if age < 20:
if gender == "female":
if age > 17:
return 100
else:
return 1000
else:
return 1000
I Python finns en modul som heter datetime som innehåller en klass som heter date. Med metoden today() får man en instans av date som innehåller dagens datum i instansvariablerna year, month och day.
Här är ett kod som ger dagens datum uppdelat i tre variabler för år, månad och dag
import datetime
today = datetime.date.today()
year = today.year
month = today.month
day = today.day
Skriv en funktion get_todays_date() där dagens datum returneras på formen: 2007-04-03. Använd if-satser för att göra om siffror mindre än 10 till en sträng med en inledande nolla.
>>> get_todays_date()
'2008-11-05'
Skriv sedan ytterligare en funktion get_todays_date2() där datumet returneras på formen: 3 april 2007. Använd if-satser för att göra om en månadssiffra till en sträng med månadens namn.
>>> get_todays_date2()
'5 november 2008'
Vad är en funktion och vad är nyttan med att kunna skriva egna funktioner?
I denna del får du öva på loopar samt repetera det du lärt dig i tidigare kapitel om listor och villkorssatser. Ingen felhantering behöver skrivas, utan du kan anta att funktionen får in rätt argument.
def eggs_for():
for i in range(1, 11):
print str(i) + ' square is ' + str((i * i))
eggs_for() och kalla den för eggs_while() så att den använder en while-loop istället för en for-loop.def bacon_while():
l = ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
i = 0
res = []
while i < len(l):
res = res + [l[i]]
i = i + 2
return res
l, i och res för värde när loopen är slut?for-loop och kalla den för bacon_for()Skriv en funktion flip_coins() som slumpmässigt singlar slant 1000 gånger och räknar hur många krona och klave det blir. På slutet ska antalet krona och klave returneras som en lista.
Skriv sedan funktionen print_coin_result() som tar listan som argument.
>>> result = flip_coins()
>>> result
[491, 509]
>>> print_coin_result(result)
491 heads and 509 tails!
TIPS! Se labbskelettet för vägledning.
Skriv en funktion list_even() som returnerar en lista med alla jämna tal mellan två tal som ges som argument. Se körexempel nedan.
>>> list_even(1, 10)
[2, 4, 6, 8, 10]
TIPS! Använd range(start, stop, step)
Skriv en funktion list_number_sequence() som returnerar en lista med alla tal mellan två tal som ges som argument. Om det första talet är större än det andra ska talsekvensen skrivas med minskande tal. Se körexempel nedan.
>>> list_number_sequence(1, 10)
[1, 2, 3, 4, 6, 7, 8, 9, 10]
>>> list_number_sequence(10, 5)
[10, 9, 8, 7, 6, 5]
make_lowercase_for som använder en for-loop för att gå igenom en sträng och byta ut alla stora bokstäver mot små bokstäver. Strängen ska sedan returneras.make_lowercase_while som använder en while-loop för att gå igenom en sträng och byta ut alla stora bokstäver mot små bokstäver. Strängen ska sedan returneras.OBS! Använd ej den inbyggda metoden str.lower() på hela strängen. Tanken är att ni ska loopa genom strängen en bokstav i taget. Ni får dock använda str.lower() på enstaka bokstäver. Se nedan för exempelanvändning av str.lower()
>>> a = "HEjsAN"
>>> a.lower()
'hejsan'
>>>
Exempel på hur funktionerna ska kunna köras:
>>> print make_lowercase_for("Det var en gång. Och den var sandad.")
det var en gång. och den var sandad.
>>> print make_lowercase_while("ABC123")
abc123
add_newlines_for() som använder en for-loop för att gå igenom en sträng och byta ut alla ‘.’-tecken (punkter) mot radbrytningar. Resulterande sträng returneras av funktionen.add_newlines_while() som använder en while-loop för att gå igenom en sträng och byta ut alla ‘.’-tecken (punkter) mot radbrytningar. Resulterande sträng returneras av funktionen.Använd ej den inbyggda funktionen str.replace().
Exempel på hur funktionerna ska kunna köras:
>>> print add_newlines_for("Solen skiner.Himlen är blå.Fåglarna kvittrar.")
Solen skiner
Himlen är blå
Fåglarna kvittrar
>>> print add_newlines_for("Solen skiner")
Solen skiner
TIPS! I en sträng betyder "\n" ny rad. Om man faktiskt skulle vilja skriva ut "\n" får man skriva "\\n".
Skriv en funktion reverse() som tar en mening/ord som argument och returnerar detta baklänges.
>>> reverse("alla rör är slutna")
'antuls rä rör alla'
TIPS! Funktionen len() kan användas för att ta reda på hur lång en sträng är. Se exempel nedan.
>>> len("eggs")
4
>>>
get_nums_for som använder en for-loop för att gå igenom en lista och som returnerar en ny lista med endast talen.get_nums_while som använder en while-loop för att gå igenom en lista och returnerar en ny lista med endast talen.Exempel på hur programmet ska kunna köras:
>>> print get_nums_for([1,"2",'three',4,[5]])
[1, 4]
>>> print get_nums_while([1,"2",'three',4,[5]])
[1, 4]
>>> print get_nums_for([[1], "2",'three'])
[]
>>> print get_nums_while([])
[]
TIPS! För att testa om ett element är ett tal kan man använda type(e) == int som ger True om e är en int och False i annat fall.
Skriv en funktion intersection() som tar två listor som argument och returnerar en lista som är snittet av dessa.
>>> intersection([1, 2, 3], [3, 4, 5])
[3]
>>> intersection([1, 2, 3], [])
[]
TIPS! Du kommer att behöva använda två loopar för att gå igenom listorna systematiskt. En inre loop och en yttre loop. Använd inte den inbyggda intersection()-funktionen för sets.
Skriv en funktion union() som tar två listor som argument och returnerar en lista som är unionen av dessa.
>>> union([1, 2, 3],[3, 4, 5])
[1, 2, 3, 4, 5]
>>> union([1, 2, 3],[])
[1, 2, 3]
TIPS! Samma sak gäller här, som för 3.10. Två loopar behövs.
OBS! Använd ej list.extend(). Tanken är att ni ska lösa problemet med två loopar och bygga en tredje lista som innehåller unionen.
Skriv två versioner av en funktion samlar upp alla tal i en lista som är mindre än ett givet värde och returnerar en ny lista med dessa tal. Funktionen tar två argument, ett minvärde, och en lista. Skriv en version som använder for-satsen och döp funktionen till collect_less_than_for. Skriv en version som använder while-satsen och döp funktionen till collect_less_than_while
>>> collect_less_than_for(50, [3, 100, 34, 55])
[3, 34]
>>> collect_less_than_while(50, [3, 100, 34, 55])
[3, 34]
nfirst_for() som använder en for-loop för att gå igenom en lista och skapa en ny lista med de n första elementen på listan.nfirst_while() som använder en while-loop för att gå igenom en lista och skapa en ny lista med de n första elementen på listan.Exempel på körning:
>>> nfirst_for([1,2,3,4,5], 3)
[1, 2, 3]
>>> nfirst_for([1,2,3,4,5], 0)
[]
>>> nfirst_for(["a","b","c","d"], 3)
["a", "b", "c"]
Skriv en funktion my_range() som genererar en lista med tal. Funktionen tar tre heltal som argument, start, slut och inkrement. OBS! Du får inte använda den inbyggda range-funktionen!
>>> my_range(0,2,1)
[0, 1]
>>> my_range(5,35,5)
[5, 10, 15, 20, 25, 30]
Skriv en funktion my_slicer() som tar ut en delsträng ur en sträng. Funktionen tar tre argument, ett startindex, ett slutindex och en sträng. Index kan bara vara positiva heltal. OBS! Du får inte använda den inbyggda slice operatorn! Första tecknet har index 0.
>>> my_slicer(0, 2, "abrakadabra")
'ab'
>>> my_slicer(5, 15, "abrakadabra")
'adabra'
Skriv en funktion average() som tar en lista med tal som argument och returnerar medelvärdet för talen i listan. OBS! Du får inte använda den inbyggda sum-funktionen!
>>> average([1, 2, 3, 4])
2.5
TIPS! Tänk på att för att få decimaltal vid division krävs att ett av talen är et flyttal. float() kan användas för att omvandla ett heltal till flyttal och att heltal som divideras med heltal ger heltal som resultat vilket i vissa fall inte har tillräckligt hög precision.
Skriv en funktion play_dice() som låter en användare gissa tärningskast. Programmet kör tills man skriver in siffran 0.
>>> play_dice()
Välkommen till tärningsspelet!
Avsluta med 0.
Din gissning: 3
För lågt!
Din gissning: 4
För lågt!
Din gissning: 3
Tärningen visar 3. Du vinner!
Din gissning: 0
Tack för den här gången!
(uppdaterat 2012–10–10)
Gå igenom föreläsningsbilderna. Avsnitt i kapitel 4 och 7 i Think Python kan vara av intresse även om vi inte använder Swampy-paketet utan Pythons inbyggda turtle-modul.
Se följande sida för en lista på funktioner i turtle-modulen som är lämpliga att använda i denna labb: http://www.ida.liu.se/~729G04/kompis/turtlefunktioner
Se även exempel på enklare turtle-program: http://www.ida.liu.se/~729G04/kompis/turtleexempel
Labbskelettet hittar du under /home/729G04/labbmaterial/labb4-labbskelett.py
Skriv en funktion square(size) som tar in ett argument size. Funktionen styr sköldpaddan så att den ritar en fyrkant där varje sida är size lång. Använd en loop.
Skriv en funktion triangle(size) som tar in ett argument size. Funktionen styr sköldpaddan så att den ritar en liksidig triangel med varje sida size lång. Använd en loop.
Skriv en funktion house() som ritar ett hus vid koordinaterna x, y. Funktionen ska använda sig av de tidigare definierade funktionerna square() och triangle(). Huset ska ha en triangel som tak, fyrkant som huskropp, en fyrkant som dörr och två fyrkanter som fönster.
TIPS! Ta upp pennan, flytta sköldpaddan dit den ska, sätt ner pennan och rita huset.
Skriv en funktion polygon(edges, size) som tar in två argument, edges och size. Funktionen ska rita en regelbunden månghörning där varje sida i månghörningen är size lång. Summan av vinklarna i en regebunden månghörning är (n-2)*180 grader där n är antal hörn i månghörningen. Funktionen bör använd en loop.
Mer information om regelbundna månghörningar hittar du t.ex. här: http://www.math.com/school/subject3/lessons/S3U2L1DP.html
Skriv en funktion quad_square(size) som använder en inre loop för att rita en fyrkant med en fyrkant i varje hörn. Den stora fyrkantens sidor ska vara size långa. De kan du skala ner enligt eget tycke. Använd två loopar (en yttre och en inre).
Skriv en funktion rekursiv funktion squares(size) som ritar ut en fyrkant med en fyrkant i varje hörn av fyrkanten som i sin tur har en fyrkant i varje hörn osv. Rita bara en fyrkant i ett hörn om dess sidor blir större eller lika med 5.
Det går bra om funktionen inte är “helt” rekursiv, dvs det går bra att använda en loop i funktionen och i den anropa på squares(size-n) där du själv bestämmer n.
I labbskelettet finns en funktion generate_random_positions(n, xmin, xmax, ymin, ymax) som genererar en lista med n antal slumpade positioner (x, y), där x har ett värde mellan xmin och xmax och y har ett värde mellan ymin och ymax.
Använd funktionen för att generera en lista med “skatter”. Skriv sedan en funktion mark_treasure(L) som givet en lista med positioner (som tupler) ritar ut skatterna på rit-ytan med hjälp av turtle-modulfunktionerna setpos() och stamp(). Se till att inte rita streck på ytan bara. Gå sedan hem med home().
Skriv sedan en funktion start_treasure_hunt(L) som tar in listan L med skattpositioner. Funktionen navigerar sköldpaddan till varje skatt och ritar ett streck efter den. start_treasure_hunt(L) får inte flytta sköldpaddan med setpos().
TIPS 1! Du kan använda turtle-modul-funktionen towards(x, y) som givet en punkt på x-axeln och en punkt på y-axeln returnerar riktningen som sköldpaddan måste vända sig mot. Du kan med hjälp av riktningen använda funktionen seth(g) som vänder sköldpaddan åt det hållet.
TIPS 2! Se denna pythonkompissidan för mer information om funktionerna: http://www.ida.liu.se/~729G04/kompis/turtlefunktioner
Bonus: Gör en alternativ variant som heter start_dizzy_treasure_hunt(L, d) som gör samma sak som start_treasure_hunt() men där du försöker simulera en viss “obalans”, d, hos sköldpaddan. Sköldpaddan har nått en skatt när den är inom ett visst avstånd till skatten (som du själv bestämmer). Du kan mäta avstånd med funktionen distance(pos) som tar in en positions-tupel och returnerar avståndet. Yrsel kan simuleras genom att introducera en viss slump när det gäller den riktning som sköldpaddan försöker vända sig mot.
Du ska göra ett litet spel. Spelet går ut på att skjuta iväg sköldpaddor på olika mål. Spelet anropas med funktionen angry_turtles(). Så här ska spelet det gå till:
TIPS 1 Du kan flytta origo med hjälp av turtle-modul-funktionen setworldcoordinates(llx, lly, urx, ury) där argumenten är följande:
llx: x-koordinaten i det nedersta vänstra hörnetlly: y-koordinaten i det nedersta vänstra hörneturx: x-koordinaten i det översta högra hörnetury: y-koordinaten i det översta högra hörnetGivet en rityta på 600x600 kommer setworldcoordinates(0, 0, 600, 600) att flytta origo så att (0, 0) ligger längst ner till vänster och (600, 600) ligger högst upp till höger. OBS! Efter att ha använt setworldcoordinates() kommer rikning 0 vara rakt österut.
TIPS 2 Du kan välja hur realistiskt din bana ska gå.
Alt 1 Ett sätt är att använda en loop som för varje iteration gör följande:
fd() sköldpaddan enligt den angivna hastigheten.heading() == -90 är nedåt efter setworldcoordinates(), heading() == 180 är nedåt om man inte använt setworldcoordinates()), ändra riktning på sköldpaddan så att den pekar lite mer nedåt , t.ex. med rt(2).Fortsätt med loopen tills y-pos <= 0.
Tänk på att det kan vara så att du missar exakt nedåt på grund av startvinkel och “snurrhastighet”. Kompensera för detta genom att inte göra t.ex. rt(2) om resultatet skulle bli en heading som pekar “bakåt”.
Alt 2
Ett annat alternativ är en lite mer fysikbaserad parabel. Detta alternativ kan ta längre tid att implementera. Här delar du upp styrkan som sköldpaddan skjuts iväg med i två komponenter – hastighet i x-led och hastighet i y-led (använd sinus och cosinus; x-hastighet = cos(vikel) * styrka och y-hastighet = sin(vinkel) * styrka).
För varje iteration, minskar du hastigheten i y-led (detta är tyngdkraften och den kommer göra att y-hastigheten efter ett tag blir negativ). Om du vill kan du också minska hastigheten i x-led (luftmotstånd).
Varje iteration flyttar du också sköldpaddans position med hjälp av hastigheten i x-led och i y-led. Dvs ny x-pos är x-pos + x-hastighet och ny y-pos är y-pos + y-hastighet.
Fortsätt tills y-pos <= 0.
Skriv en funktion som returnerar det “största” elementet i en lista. Funktionen använder linjär sökning.
>> find_max([4,2,3,1])
4
>> find_max(["Adam","Beata","Ceasar","Diana"])
'Diana'
Pseudokod
Sätt variablen max till det första elementet i listan
För varje element i listan gör följande:
Om talet är större än max:
Sätt max till talet
Returnera max
Skriv en funktion guess_number() som ber dig tänka på ett tal mellan 0 och 100 och datorn ska gissa vilket tal det är.
Datorn gissar och du får säga om det är rätt eller inte. Om datorn gissade fel får den fråga dig något och du får svara ja eller nej.
Skriv först pseudokod för en gissnings-algoritm. Du kan använda linjär sökning men det kan ta väldigt lång tid. Du kan också gissa med hjälp av slumptal, men även det kan ta lång tid. Prova att utgå från hur du själv gissar.
TIPS!: Tänk binär sökning.
Körexempel där jag tänker på 37:
>>> guess_number()
Jag kan gissa tal mellan 0 och 100!
Tänk på ett tal!
Är det 50? nej
Är det större än 50? nej
Är det 25? nej
Är det större än 25? ja
Är det 37? ja
Jippie jag klarade det fast jag bara är en dator!
Du ska skriva ett program där man ska gissa ord. Programmet innehåller en lista med t.ex. 20 ord. Ett ord slumpas fram av programmet. Det ska man gissa sig fram till. Man skriver in en bokstav och får se bokstäverna som man gissar på om de finns i ordet. Ordet byggs stegvis upp när man gissar. Programmet håller reda på hur många gånger användaren har gissat.
Börja med att göra en algoritm för programmet. Gör eventuellt en översiktlig algoritm och förfina sedan den stegvis. Gör pseudokod och ett diagram.
Visa din algoritm och diagrammet för en labbhandledare innan du börjar implementera. Skriv sedan kod.
>>> guess_word()
Välkommen till gissningsspelet!
Jag tänker på ett ord!
++++++++++
Gissa en bokstav: x
Fanns inte!
Gissa en bokstav: k
K+++++++++
Gissa en bokstav: l
K+++L++LL+
# och så vidare tills man är klar!
Gissa en bokstav: u
KANELBULLE
Grattis du klarade det på 10 gissningar!
Uppgifter att klura på med papper och penna i första hand.
def foo(x, y, z):
a = []
for b in z:
if b == x:
a.append(y)
else:
a.append(b)
return a
def foo(x):
y = []
for z in x:
for a in z:
y.append(a)
return y
def foo(x, y, z):
a = []
for b in x:
if b <= z and b >= y:
a.append(b)
return a
def foo(a, b): c=0
for d in b:
if a == d:
c += 1
return c
def foo(a):
b=1
c = []
for d in a:
if odd(b):
c = c + [d]
b += 1
return c
def odd(x):
return x % 2 != 0