Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
{
"cells": [
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"# Eksamen kont 2023 Programmering\n",
"**Merk at flervalgsoppgavene og kodeforståelse ikke er med her.**\n",
"\n",
"Hele eksamen ligger på BlackBoard. Her ligger også funksjoner som var vedlagt oppgaven, som kan være nyttig å bruke mens du arbeider med oppgavene under."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"## Oppgave 6 - Counting words (6%)\n",
"\n",
"Vi ønsker en funksjon **count_start_end_words(word_list, letter)**\n",
"\n",
"Funksjonen har to parametre, **word_list** som er ei liste av tekststrenger, og **letter**, som er en\n",
"enkelt bokstav. Funksjonen skal returnere antall strenger i **word_list** som er slik at de både\n",
"begynner og slutter på bokstaven **letter**.\n",
"\n",
"Eksempel på ønsket virkemåte av funksjonen, hvis vi har\n",
"\n",
"word_list = [\"ada\", \"ida\", \"alta\", \"ana\", \"y\"]\n",
"\n",
"så skal\n",
"\n",
"- **count_start_end_words(word_list, \"a\")** returnere 3, fordi 3 strenger, \"ada\", \"alta\", \"ana\" har \"a\" i begge ender.\n",
"- **count_start_end_words(wordlist, \"i\")** returnere 0 (ingen streng har \"i\" i begge ender)\n",
"- **count_start_end_words(wordlist, \"y\")** returnere 1 (dvs. en streng på bare 1 bokstav skal telle med, gitt at bokstaven er riktig)\n",
"\n",
"Skriv koden for funksjonen **count_start_end_words( )**"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"# Skriv ditt svar her..."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"## Oppgave 7 - Taxfree (5%)\n",
"\n",
"Følgende kvoter gjelder for hvor mye alkoholholdig drikke en person tollfritt kan innføre til Norge:\n",
"- 1 liter brennevin\n",
"- 1,5 liter vin\n",
"- 2 liter øl\n",
"Brennevinskvoten kan byttes i 1,5 liter vin eller øl (men det omvendte er ikke mulig, dvs. man får\n",
"ikke ta med mer brennevin om man dropper vin eller øl), dvs. 3 liter vin + 2 liter øl vil også være\n",
"innenfor. Likeledes kan vinkvoten byttes samme volum øl (men ikke omvendt), så kun 5 liter øl vil\n",
"også være innenfor. Videre gjelder at man må være minst 18 år gammel for å ha noen kvote\n",
"overhodet, og minst 20 år gammel for å ha med brennevin.\n",
"\n",
"Vi ønsker en funksjon **legal_alcohol(age, booze, wine, beer)** som har fire parametre:\n",
"- age - et heltall for personens alder i antall hele år\n",
"- booze, wine, beer - flyttall som viser antall liter av henholdsvis brennevin, vin og øl. Alle tall\n",
"som gis inn kan antas å være >= 0.\n",
"\n",
"Funksjonen skal returnere **True** hvis man er innenfor kvoten, **False** hvis ikke. Noen eksempler:\n",
"- legal_alcohol(17, 0.0, 0.0, 3.6) -> False (personen var for ung, kunne ikke ha med øl)\n",
"- legal_alcohol(19, 1.0, 0.0, 0.0) -> False (for ung til å ha med brennevin)\n",
"- legal_alcohol(19, 0.0, 3.0, 2.0) -> True (alder 19 er ok her, bare vin og øl)\n",
"- legal_alcohol(20, 1.0, 1.5, 2.0) -> True (akkurat innenfor på alt)\n",
"- legal_alcohol(20, 1.5, 0.0, 0.0) -> False (for mye brennevin)\n",
"- legal_alcohol(20, 0.5, 3.0, 0.0) -> False (mer enn 1.5 vin kun ok helt UTEN brennevin)\n",
"- legal_alcohol(20, 0.0, 0.0, 5.0) -> True (både brennevin og vin byttet til øl)\n",
"- legal_alcohol(20, 0.5, 1.5, 4.0) -> False (1.5 vin + 4 øl er for mye til sammen)\n",
"\n",
"Skriv koden for funksjonen **legal_alcohol( )**"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"# Skriv ditt svar her..."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## NB: Resten av oppgvene var ulike former for drag and drop og infylling, så forekommer omformuleringer her for at oppgavene skal passe bedre for dette formatet"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"## Oppgave 8 - Plot (5%)\n",
"\n",
"Koden vår skal plotte de tre grafene vist under i samme skjermbilde. (NB: utskrift av de tre\n",
"bokstavene f, g, h er ikke med i koden, disse er tatt med i bildet bare for å vise tydelig hva som er\n",
"hvilken funksjon)\n",
"\n",
"<img src=\"img/8_1.png\" width=\"700px\">\n",
"\n",
"\n",
"OPPGAVE: Fyll inn kodelinjer fra bildet under der det mangler **ved å erstatte komentarer det står \"fyll inn\" med kode fra blokkene under** så programmet virker som det skal. Ingen minuspoeng for feil svar, så du BØR svare noe også der du er usikker. Tre av kodelinjene\n",
"skal ikke brukes\n",
"\n",
"\n",
"<img src=\"img/8_2.png\" width=\"700px\">"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fyll inn\n",
"import matplotlib.pyplot #Fyll inn\n",
"\n",
"def f(x):\n",
" return 0.25*x**3 - 0.25*x**2 - 2*x + 1\n",
"\n",
"def g(x):\n",
" return 3*x**2/(np.sin(x)+5) - 5\n",
"\n",
"def h(x):\n",
" return -3*np.cos(x**2)-x\n",
"\n",
"fig, ax = # Fyll inn\n",
"# Fyll inn\n",
"ax.plot(x, g(x))\n",
"# Fyll inn\n",
"ax.plot(x, f(x))\n",
"# Fyll inn\n",
"# Fyll inn\n",
"# Fyll inn"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"## Oppgave Lottery (4%)\n",
"\n",
"I et lotteri hvor brukerne skraper fram kombinasjoner av bokstaver, er reglene slik:\n",
"- 1.premie hvis det er 3 eller flere A'er: 100\n",
"- 2.premie hvis det er 3 eller flere B'er: 60\n",
"- 3.premie hvis det er 3 eller flere C'er: 20\n",
" \n",
"Ingen premie hvis det ikke er 3 eller flere av noen bokstav, eller hvis det bare er 3 eller flere\n",
"av andre bokstaver enn A, B, C.\n",
"Man får kun én premie (dvs. hvis det f.eks. er 6 A'er, får man likevel bare 100), og kun den beste\n",
"mulige premien (hvis det er både 3 A'er og 3 B'er, får man 100, ikke 60).\n",
"\n",
"Eksempel på ønsket resultat ved kjøring av funksjonen:\n",
"- calc_prize('ABABBCCCCA') skal returnere 100\n",
"- calc_prize('ABACCBCCCCC') skal returnere 20\n",
"- calc_prize('DDDXABDDDXX') skal returnere 0\n",
"\n",
"**Fyll inn det som mangler slik at funksjonen virker som den skal. Ingen minuspoeng for feil,\n",
"så du BØR svare noe også der du er usikker. Merk at det allerede står apostrofer inni\n",
"parentesene i kallene av funksjonen count() og i [ ]-parentesene for prizes, slik at du selv\n",
"IKKE skal skrive apostrofer der. Startkode ligger under bildet**\n",
"\n",
"\n",
"<img src=\"img/9.png\" width=\"700px\" align=\"left\">"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"# MERK: Her skal kode legges til mange plasser. Se bilde.\n",
"def calc_prize(string):\n",
" prizes = {'A': 100, 'B': 60, 'C': 20}\n",
" reward = \n",
" if string.count('') 3:\n",
" reward = prizes[' ']\n",
" elif string.count('B') 3:\n",
" reward = prizes['B']\n",
" string.count(' ') 3:\n",
" reward = prizes[' ']\n",
" return\n",
"\n",
"print(calc_prize('ABABBCCCCA')) # skal returnere 100\n",
"print(calc_prize('ABACCBCCCCC')) # skal returnere 20\n",
"print(calc_prize('DDDXABDDDXX')) # skal returnere 0"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"## Oppgave 10 - Names (5%)\n",
"\n",
"Gitt lister av navn, f.eks.\n",
"\n",
"**navn = ['Logan Paul', 'Ada Wong', 'Andy Warhol', 'Paul Anka',\n",
"'Grace Hopper', 'Ada Lovelace', 'Kalle Anka', 'Andy Anka']**\n",
"\n",
"For enkelhets skyld antar vi at alle navn består av bare to ord, fornavn og etternavn, uten noe\n",
"mellomnavn eller andre tillegg. Vi ønsker å lage to funksjoner:\n",
"\n",
"- **name_sets(name_list)** skal få inn ei liste av navn som f.eks. ovenstående, og returnere\n",
"tre mengder (set), nemlig ei mengde som inneholder fornavnene, ei med etternavnene, og\n",
"ei med initialene som fantes i lista.\n",
"- **dual_use_names(first_names, last_names)** skal returnere mengden av navn som er i\n",
"bruk både som fornavn og etternavn, dvs. som forekommer i begge mengdene som gis\n",
"inn som parametre\n",
"\n",
"**Eksempel på kode for å kalle funksjonene:**"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"# Merk at koden ikke vil funke før funksjonene er implementert\n",
"first, last, inits = name_sets(navn)\n",
"print(first)\n",
"print(last)\n",
"print(inits)\n",
"print(dual_use_names(first,last))"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Ønsket resultat av kjøring, hvis variabelen navn har innhold som gitt øverst:\n",
"<img src=\"img/10.png\" width=\"700px\">\n",
"\n",
"**OPPGAVE: Trekk kodelinjer til riktig plass så de to funksjonene virker som de skal. To av\n",
"kodefragmentene skal ikke brukes. Ingen minuspoeng for feil svar, så du BØR svare noe\n",
"også der du er usikker. Startkode under bildene**\n",
"\n",
"<img src=\"img/10_2.png\" width=\"700px\">\n",
"<img src=\"img/10_3.png\" width=\"700px\">\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def name_sets(name_list):\n",
" fi_n, la_n, init =\n",
" for name in name_list:\n",
" names =\n",
" fi_n.add( )\n",
" la_n.add( )\n",
" init.add( + )\n",
" return fi_n, la_n, init\n",
"\n",
"def dual_use_names(first_names, last_names):\n",
" return\n",
"\n",
"navn = ['Logan Paul', 'Ada Wong', 'Andy Warhol', 'Paul Anka',\n",
"'Grace Hopper', 'Ada Lovelace', 'Kalle Anka', 'Andy Anka']\n",
"\n",
"print(navn)\n",
"first, last, inits = name_sets(navn)\n",
"print(first)\n",
"print(last)\n",
"print(inits)\n",
"print(dual_use_names(first,last))"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"## Oppgave 11 - Convert file (5%)\n",
"\n",
"VI har tekstfiler med flyttall separert med mellomrom. Hver rad i fila kan antas å ha like mange\n",
"elementer. Et eksempel på mulig innhold kan være:\n",
"\n",
"3.22242 4.50020 5.67230 6.33232\n",
"\n",
"5.04001 6.66666 4.48341 7.93939\n",
"\n",
"3.00001 5.72992 4.40001 0.77077\n",
"\n",
"Vi ønsker en funksjon **convert_file(filename)** som får navnet på ei slik fil inn som parameter, og\n",
"som kan skrive ei ny fil med tilsvarende data, men hvor hvert tall har blitt multiplisert med **1.25**\n",
"(dvs. økt 25%) og hvert tall skal også være **avrundet til to desimaler**. Navnet på den nye fila\n",
"skal tilsvare navnet på den gamle fila, men med tillegg av _conv bakerst i filnavnet (men foran\n",
"filtypen). Eksempel: Hvis fila vi fikk inn, het **data.txt** skal fila som skrives av funksjonen hete\n",
"**data_conv.txt** og hvis data.txt hadde innhold som vist over, ville kjøring av funksjonen\n",
"convert_file på denne fila gjøre at data_conv.txt ble skrevet med følgende innhold:\n",
"\n",
"4.03 5.63 7.09 7.92\n",
"\n",
"6.30 8.33 5.60 9.92\n",
"\n",
"3.75 7.16 5.50 0.96\n",
"\n",
"**OPPGAVE: Fyll inn kodelinjer fra bildet på riktig sted så funksjonen edit_file() virker som den skal. 5\n",
"av kodelinjene skal ikke brukes. Ingen minuspoeng for feil svar, så du BØR svare noe også\n",
"der du er usikker.**\n",
"\n",
"Her finnes filen **data.txt** og ligger i samme mappe for å kunne teste. På eksamen var ikke det mulig. \n",
"\n",
"<img src=\"img/11.png\" width=\"700px\">\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"def convert_file(filename):\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" names = # Fyll inn\n",
" new_name = # Fyll inn\n",
" # Fyll inn\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"## Oppgave 12 - Dictionary, mutering (5%)\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {
"deletable": false,
"editable": false,
"run_control": {
"frozen": true
}
},
"source": [
"Vi ønsker å justere en ordbok (dictionary) hvor verdiene er lister av heltall slik at alle partall\n",
"fjernes, mens oddetall blir værende igjen. Hvis ei liste som følge av fjerning av partall blir tom,\n",
"skal hele den tilhørende nøkkelen fjernes fra ordboka. Vi ønsker to funksjoner for dette:\n",
"\n",
"- **remove_even_nos(d)** som muterer ordboka (dictionary) og listene inni\n",
"- **even_nos_removed(d)** , som returnerer ny versjon av ordboka og listene inni, uten å\n",
"endre originaldataene.\n",
"\n",
"For den muterende **remove_even_nos** skal endringene skje i samme ordbok og mutere listene.\n",
"For **even_nos_removed** skal det lages en ny ordbok med nye lister som verdier.\n",
"\n",
"Eksempel på kjøring av funksjonene:\n",
"\n",
"```python\n",
"d = {'A': [3, 2, 4, 5], 'B': [5, 4, 1, 1, 8, 3], 'C': [1, 7, 7], 'D': [2, 4, 6] }\n",
"print(even_nos_removed(d)) # viser justert ordbok, endrer ikke original\n",
"print(d) # printer original ordbok\n",
"remove_even_nos(d) # endrer original ordbok ved mutering\n",
"print(d) # printer original ordbok på nytt\n",
"```\n",
"**Gjør at følgende printes:**\n",
"```python\n",
"{'A': [3,5], 'B': [5,1,1,3], 'C': [1, 7, 7] }\n",
"{'A': [3,2,4,5], 'B': [5,4,1,1,8,3], 'C': [1, 7, 7], 'D': [2, 4, 6] }\n",
"{'A': [3,5], 'B': [5,1,1,3], 'C': [1, 7, 7] }\n",
"```\n",
"\n",
"Som vi ser forsvinner nøkkelen 'D' helt fra ordboka ved justering i dette eksemplet fordi alle\n",
"tallene i lista til den nøkkelen var partall, slik at lista endte opp med å bli tom.\n",
"**OPPGAVE: Fyll inn kodelinjer til rett posisjon slik at de to funksjonene virker som de\n",
"skal. 1 boks passer i hver instans av \"Fyll inn\". Ingen minuspoeng for feil valg, så du BØR svare noe også der du er usikker**\n",
"\n",
"<img src=\"img/12.png\" width=\"700px\">\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def remove_even_nos(d): # Mutating the dictionary\n",
" for key in list(d): #list(d) avoids iterating d itself while changing\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
"\n",
"def even_nos_removed(d): # not changing the original\n",
" # Fyll inn\n",
" for key in d:\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
"\n",
"d = {'A': [3, 2, 4, 5], 'B': [5, 4, 1, 1, 8, 3], 'C': [1, 7, 7], 'D': [2, 4, 6] }\n",
"print(even_nos_removed(d)) # viser justert ordbok, endrer ikke original\n",
"print(d) # printer original ordbok\n",
"remove_even_nos(d) # endrer original ordbok ved mutering\n",
"print(d) # printer original ordbok på nytt"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Oppgave 13 - Diagonal (6%)\n",
"\n",
"Funksjonen diagonal(a) får inn et todimensjonalt numpy array (matrise) og skal returnere et\n",
"endimensjonalt array (vektor) med samme innhold, men hvor rekkefølgen på elementene i\n",
"vektoren fremkommer ved å iterere det todimensjonale arrayet diagonalt.\n",
"\n",
"**Eksempel på kjøring:**\n",
"\n",
"Hvis `a = numpy.array([ [0,1,2], [3,4,5], [6,7,8], [9,10,11] ])`\n",
"skal kallet print(diagonal(a)) resultere i utskrift\n",
"\n",
"`[ 0 3 1 6 4 2 9 7 5 10 8 11]`\n",
"\n",
"Dvs., den diagonale iterasjonen av matrisa skal starte i øvre venstre hjørne, og så ta en og en\n",
"stigende diagonal helt til den ender i nedre høyre hjørne, jfr. figur:\n",
"\n",
"<img src=\"img/13.png\" width=\"700px\">\n",
"\n",
"**OPPGAVE: Fyll inn det som mangler i funksjonen så den virker som den skal. Vær nøye\n",
"med små og store bokstaver, siden det er semantisk signifikant i Python.**\n",
"\n",
"<img src=\"img/13_2.png\" width=\"500px\">\n",
"\n",
"\n",
"<img src=\"img/13_3.png\" width=\"500px\">\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Merk Kode skal fylles in mange plasser for at koden skal fungere, se bildet over for å se hvor\n",
"import numpy as np\n",
"def diagonal(a):\n",
" result = \n",
" n_rows, n_cols = a.shape\n",
" n_diags = n_rows + n_cols\n",
" for d in range(n_diags):\n",
" if d < n_rows:\n",
" i =\n",
" j =\n",
" else:\n",
" i =\n",
" j = - i\n",
" while and j < n_cols:\n",
" result.append(a[i,j])\n",
" i 1\n",
" j 1\n",
" return np.array(result)\n",
" "
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Oppgave 14 - Dice game (6%)\n",
"\n",
"Terningspillet Titusen spilles med seks terninger og har (litt forenklet) følgende poengregler:\n",
"\n",
"- Tre spesialkombinasjoner gir ekstra mye poeng:\n",
"to ganger tre like, f.eks. [2,2,2,5,5,5], gir 2500 poeng\n",
"straight [1,2,3,4,5,6] gir 2000 poeng\n",
"tre par, f.eks. [1,1,4,4,6,6] gir 1500 poeng\n",
"- Hvis man ikke har noen spesialkombinasjon, gjelder følgende:\n",
"tre enere oppnådd i samme kast gir 1000 poeng\n",
"tre like av annet tall, gir tallet x 100 (f.eks. tre 6'ere, 600, tre 2'ere, 200)\n",
"fire like gir det dobbelte av tre like, fem like det dobbelte av fire like, og seks like igjen\n",
"dobbelt av dette (f.eks. 4 enere gir 2000, 5 enere 4000, 6 enere 8000).\n",
"enkeltstående 1 gir 100 poeng per stykk, og enkeltstående 5 gir 50 poeng per stykk.\n",
"Andre tall gir ikke noen poeng enkeltvis.\n",
"\n",
"Vi ønsker en funksjon **points(throw)** som kan regne ut poengverdien av ett kast med 6\n",
"terninger, hvor inn-parameteren **throw** er ei liste av heltall som var i kastet, og hvor vi kan anta at\n",
"tallene alltid kommer sortert i stigende rekkefølge. Eksempel på ønsket resultat av kjøring:\n",
"\n",
"**points([1,2,3,4,5,6])** gir 2000 poeng (straight)\n",
"**points([1,1,1,2,2,2])** gir 2500 poeng (to tripletter)\n",
"**points([1,1,1,2,5,5])** gir 1100 poeng (1000 for 3 enere + 2 x 50 for to femmere)\n",
"**points([1,2,2,2,4,4])** gir 300 poeng (200 for 3 toere, pluss 100 for den ene eneren)\n",
"**points([2,3,4,4,4,4]]** gir 800 poeng (for 4 firere, dvs. dobbelt av poeng for tre firere)\n",
"**points([1,2,3,3,4,5])** gir 150 poeng (100 for eneren, 50 for femmeren)\n",
"**points([2,3,3,4,4,6])** gir 0 poeng\n",
"\n",
"**Fyll inn det som mangler slik at funksjonen virker som den skal. Ingen minuspoeng for feil,\n",
"så du BØR svare noe også der du er usikker. Alternativene står kommaseparert i parentes på bilde etter hver boks med \"Velg alternativ\"**\n",
"\n",
"<img src=\"img/14_1.png\" width=\"500px\">\n",
"<img src=\"img/14_2.png\" width=\"500px\">\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def points(throw):\n",
" if throw == # Fyll inn\n",
" score = 2000 # straight\n",
" elif len(set(throw)) == 2 and # Fyll inn\n",
" score = 2500 # two triplets\n",
" elif len(set(throw)) == 3 and # Fyll inn\n",
" score = 1500 # thr\n",
" else:\n",
" # Fyll inn\n",
" for n in set(throw):\n",
" ct=throw.count(n)\n",
" # Fyll inn\n",
" multi = # Fyll inn\n",
" if n == 1:\n",
" score += # Fyll inn\n",
" else:\n",
" score += n*100*multi\n",
" # Fyll inn\n",
" score += ct * 100\n",
" # Fyll inn\n",
" score += ct * 50\n",
" return score\n"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Oppgave 15 - Func as param, p1 (6%)\n",
"\n",
"Vi ønsker å lage en funksjon **n_crossings(f, g, x_values)** som får inn som parametre to andre\n",
"funksjoner **f** og **g**, samt et array **x_values** som inneholder en serie x-verdier. Funksjonen\n",
"n_crossings() skal returnere antall ganger f (x) og g(x) krysser hverandre over den gitte serien\n",
"av x-verdier, dvs. .ganger hvor det skifter hvilken funksjon som er størst. NB: funksjonene må\n",
"krysse hverandre for at det skal gi telling, det er ikke nok at de tangerer hverandre. (Dvs., hvis\n",
"f.eks. f og g var samme funksjon, slik at de var like hele tiden, skulle dette gi returverdi 0 fra\n",
"n_crossings)\n",
"\n",
"**Eksempel:** Hvis f(x) er sin(2*x) + 0.2*x (oransje kurve) og g(x) er 0.5*x (blå linje), som vist i\n",
"figuren nedenfor, så skal n_crossings(f, g, x_values) returnere **3** hvis **x_values** er np.arange(-2,\n",
"2, 0.1) siden de to funksjonene krysser hverandre tre steder i intervallet -2 til +2 og\n",
"inkrementverdien 0.1 er fingranulær nok til å fange opp alle disse kryssingene. Hvis derimot\n",
"x_values er np.arange(4, 6, 0.1) skal den returnere 0, siden det ikke er noen kryssinger i\n",
"intervallet mellom x=4 og x=6.\n",
"\n",
"<img src=\"img/15_1.png\" width=\"700px\">\n",
"\n",
"**OPPGAVE: Fyll inn kodelinjer til riktig sted så funksjonen virker som den skal. Tre av\n",
"kodelinjene skal IKKE brukes. Ingen minuspoeng for feil, så du BØR svare noe også der\n",
"du er usikker.**\n",
"\n",
"<img src=\"img/15_2.png\" width=\"500px\">\n",
"<img src=\"img/15_3.png\" width=\"500px\">\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def n_crossings(f, g, x_values):\n",
" # Fyll inn\n",
" big, small = # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" big, small = # Fyll inn\n",
" elif f(x) > g(x):\n",
" big, small = # Fyll inn\n",
" # Fyll inn\n",
" big, small = # Fyll inn\n",
" # Fyll inn"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Oppgave 16 Func as param, p2 (6%)\n",
"\n",
"Hvis to funksjoner krysser hverandre svært hyppig, kan det lett skje at funksjonen\n",
"**n_crossings()** som vi laget i forrige oppgave, ikke finner alle krysningene. Dette skjer typisk hvis\n",
"krysningene kommer tettere enn x-verdiene i arrayet som vi får inn. Et eksempel på en slik\n",
"situasjon er gitt i bildet, med funksjonene f(x) = 0.25 - 0.25*x (oransje linje) og g(x) = sin(x**4 -\n",
"x**2) (blå). Hvis det er 0.1 intervall mellom x-verdiene, vil n_crossings-funksjonen virke fint for\n",
"intervallet 0.0-1.2, hvor det bare er én kryssing, men f.eks. for intervallet 3.5-4.0 vil den returnere\n",
"et altfor lite tall fordi krysningene kommer hyppigere enn x-verdiene.\n",
"\n",
"<img src=\"img/16_1.png\" width=\"700px\">\n",
"\n",
"Vi ønsker derfor å lage en ny funksjon som skal kalle funksjonen n_crossings(). Den nye\n",
"funksjonen skal hete **test_n_crossings(f, g, a, b)** og skal få inn fire parametre: to funksjoner f og\n",
"g, samt tallene a og b som er henholdsvis startverdi og sluttverdi for intervallet hvor vi skal telle\n",
"krysninger. Test-funksjonen skal starte med avstand 1 mellom x-verdiene og så gå gjentatte\n",
"runder, hvor avstanden deles på 10 for hver runde, inntil tre påfølgende runder har gitt identisk\n",
"resultat. Funksjonen skal returnere ei liste med antall krysninger den fant på hver runde.\n",
"Eksempel på kjøring (hvis funksjonene f og g var som i bildet over):\n",
"\n",
"```python\n",
">>>test_n_crossings(f, g, 0.0, 2.0)\n",
"[0, 2, 2, 2]\n",
">>>test_n_crossings(f, g, 3.5, 4.0)\n",
"[0, 2, 20, 32, 32, 32]\n",
"```\n",
"\n",
"Som vi ser, returnerer det første kallet feilaktig 0 når x-avstand er 1 (finner ingen kryssinger fordi\n",
"blå kurve er lavere enn oransje linje både for x = 0.0, 1.0 og 2.0), men kommer så til riktig svar\n",
"allerede med x-avstand 0.1 og lavere. Det neste kallet returnerer feilaktig få krysninger både med\n",
"x-avstand 1.0, 0.1 og 0.01, før den stabilt kommer til svaret 32 fra 0.001 og utover.\n",
"\n",
"**OPPGAVE: Trekk kodelinjer til riktig posisjon slik at funksjonen test_n_crossings() virker\n",
"som den skal. Tre av kodefragmentene skal ikke brukes. Ingen minuspoeng for feil svar,\n",
"så du bør svare noe også der du er usikker**\n",
"\n",
"<img src=\"img/16_2.png\" width=\"700px\">\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def test_n_crossings(f, g, a, b):\n",
" h = 1\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn(NB: 2 Muligheter!)\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn\n",
" # Fyll inn"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Oppgave 17\n",
"\n",
"Lærer \"Leif\" ønsker å lage et program som kan illustrere manuelt utført divisjon for elevene. Som\n",
"del av dette programmet ønskes en funksjon **show_division(n, m)** som skal returnere en streng\n",
"over flere linjer som viser hvordan man går fram for å dele n på m. Eksempel på kjøring:\n",
"show_division(127, 4) skal returnere en streng på 7 linjer som vist under. Linje 2 viser -12 fordi\n",
"første siffer i løsningen er 3, og 3 x 4 (divisoren) er 12. Linje 4 viser 7 fordi det er det man har\n",
"igjen av dividenden når man trekker fra 12 - 12. Linje 5 viser -4 fordi neste siffer i løsningen er 1,\n",
"som multiplisert med divisoren gir 4. Til slutt får vi 3 i rest på linja nederst.\n",
"\n",
"```\n",
"127 : 4 = 31\n",
"-12\n",
"----\n",
"7\n",
"-4\n",
"----\n",
"3 i rest\n",
"```\n",
"\n",
"Hvis divisjonen går opp, f.eks. **show_division(124, 4)** skal det stå **0 i rest** på siste linje av\n",
"resultatstrengen. Merk at det ikke nødvendigvis blir 7 linjer i strengen som returneres. Hvis\n",
"svaret bare blir ensifret, vil resultatet ha færre linjer, og hvis det blir mer enn tosifret, flere linjer.\n",
"\n",
"**OPPGAVE: Velg rett alternativ i hvert tomrom slik at funksjonen show_division() virker\n",
"som den skal. Ingen minuspoeng for feil valg, så du BØR svare noe også der du er\n",
"usikker. Funksjonen len_diff() er en hjelpefunksjon som brukes for å finne differansen i\n",
"lengde mellom to tall (i antall siffer). Tekststrengen '\\n' betyr linjeskift. Ingen startkode lagt til her, så skriv det du synes er nødvendig**\n",
"\n",
"<img src=\"img/17_1.png\" width=\"700px\">\n",
"<img src=\"img/17_2.png\" width=\"700px\">\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fyll inn kode her..."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Oppgave 18 - 2D arrays (12%)\n",
"\n",
"Funksjonen **same_row_col(a, b, n)** skal få inn to todimensjonale numpy-array (matriser) a og b\n",
"som inneholder tall, samt opsjonelt en tredje parameter n som vil inneholde et heltall >= 0. Det\n",
"skal også gå an å kalle funksjonen uten å gi inn noe tall for n, i så fall skal den være null.\n",
"Funksjonen skal returnere ei liste av tupler, hvor hvert tuppel består av to heltall (r, k) - hvor r er\n",
"indeks til ei rad i arrayet a, og k er indeks til ei kolonne i arrayet b. Kriteriet for at et tuppel (r, k)\n",
"skal være med i løsningen er at det forekommer en identisk tallserie i aktuell rad og kolonne, dvs.\n",
"samme tall i samme rekkefølge. Mer detaljert er kravene:\n",
"\n",
"- hvis det ikke gis noe tredje argument til funksjonen, eller tredje argument n er 0, må rad r\n",
"og kolonne k være identiske i sin helhet (dvs. hele rada lik hele kolonna)\n",
"- hvis n er et heltall > 0, må rad r og kolonne k ha en identisk tallserie på minst n elementer.\n",
"\n",
"```\n",
"a [[1 2 3 4] b [[5 0 6 6]\n",
" [5 6 7 8] [6 0 6 7]\n",
" [1 1 1 1]] [7 0 8 8]\n",
" [8 1 1 1]]\n",
"```\n",
"\n",
"Eksempel, gitt at a og b har innhold som vist over:\n",
"\n",
"- **same_row_column(a, b)** skal returnere **[(1, 0)]**. Eneste tilfelle hvor ei hel rad i a er identisk\n",
"med ei hel kolonne i b, er tallserien [5 6 7 8] som fins i rad i a med indeks 1, kolonne i b\n",
"med indeks 0 - illustrert med fet skrift i a og b ovenfor.\n",
"- **same_row_column(a, b, 3)** skal returnere **[(1, 0), (1, 3)]**. Tallserien [5 6 7 8] fra forrige\n",
"eksempel tilfredsstiller kravet også her (siden 4 tall er ok når det trengs minst 3 tall).\n",
"Dessuten får vi med (1, 3) fordi tallserien 6, 7, 8 fins i både rad 1 i a og kolonne 3 i b (vist\n",
"med kursiv i b)\n",
"- **same_row_column(a, b, 5)** skal returnere tom liste **[ ]**, fordi det ikke fins noen serie på\n",
"minst 5 tall som er identisk mellom de to matrisene.\n",
"\n",
"Merk at resultatlista kun skal inneholde én forekomst av hvert tuppel som er med. I\n",
"eksemplet same_row_column(a,b,3) vil tuppelet (1,0) kvalifisere på tre ulike måter: hele\n",
"tallserien 5,6,7,8 matcher, 5,6,7 matcher, og 6,7,8 matcher, men (1,0) skal likevel bare være en\n",
"gang i resultatet, ikke 3. For å få full score på oppgaven må løsningen ikke bare returnere korrekt\n",
"svar, men også unngå å lete videre etter flere matcher for en gitt (r, k) hvis det allerede er\n",
"fastslått at tuppelet skal være med i løsningen.\n",
"**Skriv koden for funksjonen same_row_column().**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Din funksjon:\n",
"def same_row_col(a, b, n):\n",
"\n",
"\n",
"\n",
"# Testing:\n",
"a = [[1, 2, 3, 4], \n",
" [5, 6, 7, 8],\n",
" [1, 1, 1, 1]]\n",
"\n",
"b = [[5, 0, 6, 6], \n",
" [6, 0, 6, 7],\n",
" [7, 0, 8, 8],\n",
" [8, 1, 1, 1]]\n",
"\n",
"print(same_row_column(a, b)) # skal returnere [(1, 0)]\n",
"print(same_row_column(a, b, 3)) # skal returnere [(1, 0), (1, 3)]\n",
"print(same_row_column(a, b, 5)) # skal returnere tom liste [ ]"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.10"
},
"vscode": {
"interpreter": {
"hash": "84613ed7f399af20e1e2ef8af506be689ae865345b9dceeaa3cba33ce1bef069"
}
}
},
"nbformat": 4,
"nbformat_minor": 2
}