This repository has been archived by the owner on Aug 4, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 1
/
prosjekter.html
972 lines (819 loc) · 50 KB
/
prosjekter.html
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
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="no" xml:lang="no">
<head>
<!-- 2020-03-03 Tue 14:54 -->
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Prosjekter</title>
<meta name="generator" content="Org mode" />
<meta name="author" content="Tarjei Bærland" />
<link rel="stylesheet" type="text/css" href="css/htmlize.css"/>
<link rel="stylesheet" type="text/css" href="css/readtheorg.css"/>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.4/js/bootstrap.min.js"></script>
<script type="text/javascript" src="js/jquery.stickytableheaders.min.js"></script>
<script type="text/javascript" src="js/readtheorg.js"></script>
<script type="text/javascript">
/*
@licstart The following is the entire license notice for the
JavaScript code in this tag.
Copyright (C) 2012-2020 Free Software Foundation, Inc.
The JavaScript code in this tag is free software: you can
redistribute it and/or modify it under the terms of the GNU
General Public License (GNU GPL) as published by the Free Software
Foundation, either version 3 of the License, or (at your option)
any later version. The code is distributed WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU GPL for more details.
As additional permission under GNU GPL version 3 section 7, you
may distribute non-source (e.g., minimized or compacted) forms of
that code without the copy of the GNU GPL normally required by
section 4, provided you include this license notice and a URL
through which recipients can access the Corresponding Source.
@licend The above is the entire license notice
for the JavaScript code in this tag.
*/
<!--/*--><![CDATA[/*><!--*/
function CodeHighlightOn(elem, id)
{
var target = document.getElementById(id);
if(null != target) {
elem.cacheClassElem = elem.className;
elem.cacheClassTarget = target.className;
target.className = "code-highlighted";
elem.className = "code-highlighted";
}
}
function CodeHighlightOff(elem, id)
{
var target = document.getElementById(id);
if(elem.cacheClassElem)
elem.className = elem.cacheClassElem;
if(elem.cacheClassTarget)
target.className = elem.cacheClassTarget;
}
/*]]>*///-->
</script>
<script type="text/x-mathjax-config">
MathJax.Hub.Config({
displayAlign: "center",
displayIndent: "0em",
"HTML-CSS": { scale: 100,
linebreaks: { automatic: "false" },
webFont: "TeX"
},
SVG: {scale: 100,
linebreaks: { automatic: "false" },
font: "TeX"},
NativeMML: {scale: 100},
TeX: { equationNumbers: {autoNumber: "AMS"},
MultLineWidth: "85%",
TagSide: "right",
TagIndent: ".8em"
}
});
</script>
<script type="text/javascript"
src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS_HTML"></script>
</head>
<body>
<div id="content">
<h1 class="title">Prosjekter</h1>
<div id="table-of-contents">
<h2>Innhold</h2>
<div id="text-table-of-contents">
<ul>
<li><a href="#org04137fa">Eksempelrapport: Primtallsfaktorisering</a>
<ul>
<li><a href="#org81dea20">Bakgrunn</a></li>
<li><a href="#org910fe8c">Algoritme</a></li>
<li><a href="#orge2cd235">Program</a></li>
<li><a href="#orgd04a675">Kommentarer</a></li>
</ul>
</li>
<li><a href="#orgbc52faa">Tekstbasert eventyrspill</a>
<ul>
<li><a href="#orgeb9c7c7">Introduksjon</a></li>
<li><a href="#orgd2075f6">Feilhåndtering</a></li>
<li><a href="#orgdf413be">Fiendekamp med stein-saks-papir</a></li>
<li><a href="#orgb849b0e">En ny struktur</a></li>
</ul>
</li>
<li><a href="#orgb528d51">Battleships</a>
<ul>
<li><a href="#orgc4505ec">Regler</a></li>
<li><a href="#orgcd819e6">Din oppgave</a></li>
</ul>
</li>
<li><a href="#org9c6606c">Droneaksellerasjon</a></li>
</ul>
</div>
</div>
<div id="outline-container-org04137fa" class="outline-2">
<h2 id="org04137fa">Eksempelrapport: Primtallsfaktorisering</h2>
<div class="outline-text-2" id="text-org04137fa">
</div>
<div id="outline-container-org81dea20" class="outline-3">
<h3 id="org81dea20">Bakgrunn</h3>
<div class="outline-text-3" id="text-org81dea20">
<p>
Ifølge aritmetikkens fundamentalteorem kan ethvert heltall større enn 1 skrives som et produkt av primtall på én og kun én måte. For eksempel er \(28 = 2^{2}\cdot 7\) og \(11 = 11\).
</p>
<p>
Jeg skal nå forsøke å løse <a href="https://projecteuler.net/problem=3">Project Euler oppgave 3</a>, som spør om følgende:
</p>
<blockquote>
<p>
Primtallsfaktorene til 13195 er 5, 7, 13, og 29.
</p>
<p>
Hva er den største primtallsfaktoren til tallet 600851475143?
</p>
</blockquote>
</div>
</div>
<div id="outline-container-org910fe8c" class="outline-3">
<h3 id="org910fe8c">Algoritme</h3>
<div class="outline-text-3" id="text-org910fe8c">
<p>
Merk at oppgaven kun er ute etter den <i>største</i> primtallsfaktoren. Siden det kun er én måte å faktorisere et tall til sine primtallsfaktorer på, kan vi jobbe med mindre og mindre tall ved å «dele bort» faktorene når vi finner dem.
</p>
<p>
Vi har funnet delt bort alle primtallsfaktorer når vi sitter igjen med tallet 1.
</p>
<p>
For eksempel, dersom vi ønsker å finne den største primtallsfaktoren 28, kan vi gjøre dette ved å gjøre følgende:
</p>
<ul class="org-ul">
<li>Starte med å teste faktoren 2</li>
<li>Dersom 2 er en faktor, dele bort 2-ere så lenge det er mulig \(28/2 = 14\), \(14/2 = 7\), når vi kommer til 7 er det ikke mulig å dele bort flere 2-ere.</li>
<li>Den største primtallsfaktoren i 28 er altså enten 7, eller den største primtallsfaktoren i 7.</li>
<li>Vi tester den neste faktoren (\(2+1 = 3\)).</li>
<li>\(7/3\) går ikke opp</li>
<li>Vi tester den neste faktoren, 4.</li>
<li>Går ikke opp.</li>
<li>Vi tester den neste faktoren, 5.</li>
<li>Går ikke opp.</li>
<li>Vi tester den neste faktoren, 6.</li>
<li>Går ikke opp.</li>
<li>Vi tester den neste faktoren, 7.</li>
<li>\(7/7=1\), vi har kommet til 1, og delt bort alle faktorer, altså var 7 den største primtallsfaktoren.</li>
</ul>
<p>
Vi kan oversette dette til omtrentlig følgende pseudokode:
</p>
<pre class="example">
hent inn TALL
sett TESTFAKTOR til 1
så lenge TALL er større enn 1, gjør:
øk TESTFAKTOR med 1
så lenge TESTFAKTOR er en faktor i TALL, gjør:
del bort TESTFAKTOR fra TALL
</pre>
<p>
Etter at dette programmet har kjørt, vil <code>TALL</code> være 1 og <code>TESTFAKTOR</code> vil holde den største primtallsfaktoren i det opprinnelige <code>TALL</code>.
</p>
</div>
</div>
<div id="outline-container-orge2cd235" class="outline-3">
<h3 id="orge2cd235">Program</h3>
<div class="outline-text-3" id="text-orge2cd235">
<div class="org-src-container">
<pre class="src src-python"><span class="org-keyword">import</span> time
<span class="org-variable-name">starttid</span> = time.time()
<span class="org-variable-name">tall</span> = 600851475143
<span class="org-variable-name">testfaktor</span> = 1
<span class="org-keyword">print</span>(f<span class="org-string">"Starter med tallet {tall}."</span>)
<span class="org-keyword">while</span> tall != 1:
<span class="org-variable-name">testfaktor</span> += 1
<span class="org-keyword">while</span> tall % testfaktor == 0:
<span class="org-keyword">print</span>(f<span class="org-string">"... deler bort {testfaktor}."</span>)
<span class="org-variable-name">tall</span> //= testfaktor
<span class="org-variable-name">sluttid</span> = time.time()
<span class="org-keyword">print</span>(f<span class="org-string">"Den største primtallsfaktoren i {TALL} er {testfaktor}."</span>)
<span class="org-keyword">print</span>(f<span class="org-string">"Denne utregningen tok {sluttid-starttid:.4f} sekunder."</span>)
</pre>
</div>
<pre class="example">
Starter med tallet 600851475143.
... deler bort 71.
... deler bort 839.
... deler bort 1471.
... deler bort 6857.
Den største primtallsfaktoren i 600851475143 er 6857.
Denne utregningen tok 0.0044 sekunder.
</pre>
</div>
</div>
<div id="outline-container-orgd04a675" class="outline-3">
<h3 id="orgd04a675">Kommentarer</h3>
<div class="outline-text-3" id="text-orgd04a675">
<p>
Programmet har mange mulige optimaliseringerer. Noen eksempler:
</p>
<ol class="org-ol">
<li>Det sjekker alle partall, selv etter den har delt bort alle toere.</li>
<li>Det sjekker alle verdier opptil <code>TALL</code>, selv om <code>TALL</code> må være et primtall dersom alle verdier opptil <code>sqrt(TALL)</code> har blitt sjekket.</li>
</ol>
<p>
Disse forbedringene ville kunne endret hvor lang tid programmet bruker på å kjøre.
</p>
<p>
Du finner kode over <a href="py/rapport_primtallsfaktorisering.py">file:py/rapport_primtallsfaktorisering.py</a>.
</p>
</div>
</div>
</div>
<div id="outline-container-orgbc52faa" class="outline-2">
<h2 id="orgbc52faa">Tekstbasert eventyrspill</h2>
<div class="outline-text-2" id="text-orgbc52faa">
</div>
<div id="outline-container-orgeb9c7c7" class="outline-3">
<h3 id="orgeb9c7c7">Introduksjon</h3>
<div class="outline-text-3" id="text-orgeb9c7c7">
<p>
Dette kan i enkleste format løses ved å bruke <code>if/elif/else</code>, <code>print</code> og <code>input</code>.
</p>
<p>
Fordelen med et program som dette, er at det fokuserer på et lite antall konsepter, så du kan konsentrere deg om å få disse til å sitte ordentlig.
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-keyword">print</span>(<span class="org-string">"Du våkner klokken 5:32 og føler deg våken, men vurderer å forsøke å fortsette å sove. Du ..."</span>)
<span class="org-variable-name">valg</span> = <span class="org-builtin">input</span>(<span class="org-string">"'står opp' / 'sover videre'"</span>)
<span class="org-variable-name">error</span> = <span class="org-string">"Det var jommen et ugyldig valg, fysikkens lover er brutt."</span>
<span class="org-keyword">if</span> valg == <span class="org-string">"står opp"</span>:
<span class="org-keyword">print</span>(<span class="org-string">"... står opp og ser en gammel bok i bokhylla. Du ..."</span>)
<span class="org-variable-name">valg</span> = <span class="org-builtin">input</span>(<span class="org-string">"'leser' / 'lar være'"</span>)
<span class="org-keyword">if</span> valg == <span class="org-string">"leser"</span>:
<span class="org-keyword">print</span>(<span class="org-string">"... får en fin start på dagen med en spennende bok."</span>)
<span class="org-keyword">elif</span> valg == <span class="org-string">"lar være"</span>:
<span class="org-keyword">print</span>(<span class="org-string">"... kjenner på en tomhetsfølelse som følger deg gjennom dagen."</span>)
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(error)
<span class="org-keyword">elif</span> valg ==<span class="org-string">"sover videre"</span>:
<span class="org-keyword">print</span>(<span class="org-string">"... sover og drømmer om et liv hvor muligheter gripes."</span>)
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(error)
</pre>
</div>
<p>
Programmet over kan lastes ned <a href="tekstbasert_intro.py">her (tekstbasert_intro.py)</a>.
</p>
</div>
</div>
<div id="outline-container-orgd2075f6" class="outline-3">
<h3 id="orgd2075f6">Feilhåndtering</h3>
<div class="outline-text-3" id="text-orgd2075f6">
<p>
Programmet over håndterer feil fra spilleren på en lite grasiøs måte. Spillet tvinger seg videre, uten å la spilleren forsøke å taste inn på nytt.
</p>
<p>
Starten på en forbedring vil være å restrukturere koden slik at teksten, selve «historien» vår, kommer foran. Vi kan da forsøke å skille mellom historien, og selve spillmotoren.
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-variable-name">tekst</span> = <span class="org-string">"Du våkner klokken 5:32 og føler deg våken, men vurderer å forsøke å fortsette å sove. Du ..."</span>
<span class="org-variable-name">valg_a</span> = <span class="org-string">"står opp"</span>
<span class="org-variable-name">tekst_a</span> = <span class="org-string">"... står opp og ser en gammel bok i bokhylla. Du ..."</span>
<span class="org-variable-name">valg_aa</span> = <span class="org-string">"leser"</span>
<span class="org-variable-name">tekst_aa</span> = <span class="org-string">"... får en fin start på dagen med en spennende bok."</span>
<span class="org-variable-name">valg_ab</span> = <span class="org-string">"lar være"</span>
<span class="org-variable-name">tekst_ab</span> = <span class="org-string">"... kjenner på en tomhetsfølelse som følger deg gjennom dagen."</span>
<span class="org-variable-name">valg_b</span> = <span class="org-string">"sover videre"</span>
<span class="org-variable-name">tekst_b</span> = <span class="org-string">"... sover og drømmer om et liv hvor muligheter gripes."</span>
<span class="org-variable-name">error</span> = <span class="org-string">"Det var jommen et ugyldig valg, fysikkens lover er brutt."</span>
</pre>
</div>
<p>
Når det er gjort kan vi så sette opp spillet på tilsvarende måte som siste, men vi begynner å ta høyde for feil fra brukeren. Legg også merke til at vi nå «pynter» på brukerens input ved først å gjøre alle bokstavene til små bokstaver (<code>"TestStreng".lower() => "teststreng"</code>) og ved å fjerne eventuelle mellomrom og tomme tegn på starten og slutten av strengen (<code>" test ".strip() => "test"</code>).
</p>
<p>
Vi kunne da ha «pakket» hver <code>input</code> inn med <code>f-strenger</code> avsluttet med <code>lower</code> og <code>strip</code>, noe à la
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-variable-name">valg</span> = <span class="org-builtin">input</span>(f<span class="org-string">"'{valg_a}' / '{valg_b}'"</span>).lower().strip()
</pre>
</div>
<p>
men dette ville ikke hjulpet oss med å be brukeren om å taste inn på nytt dersom det ikke fungerte.
</p>
<p>
Vi kan heller pakke det inn i en funksjon, hvor vi venter til brukeren har tastet et gyldig alternativ ved å bruke en <code>while</code>-løkke.
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-keyword">def</span> <span class="org-function-name">be_om_input</span>(alt1, alt2):
<span class="org-doc">"""Ber spilleren om å taste inn input til spillet, og gir seg først når</span>
<span class="org-doc"> spilleren har tastet inn noe gyldig.</span>
<span class="org-doc"> </span>
<span class="org-doc"> Returnerer valget brukeren tastet inn når dette er gyldig.</span>
<span class="org-doc"> Eksempel på bruk:</span>
<span class="org-doc"> valg = be_om_input('gå', 'løp')</span>
<span class="org-doc"> 'gå' / 'løp' >>> går</span>
<span class="org-doc"> Ugyldig alternativ, prøv igjen.</span>
<span class="org-doc"> 'gå' / 'løp' >>> gå # valg er nå 'gå'</span>
<span class="org-doc"> """</span>
<span class="org-variable-name">valgt</span> = <span class="org-constant">None</span>
<span class="org-keyword">while</span> valgt != alt1 <span class="org-keyword">and</span> valgt != alt2:
<span class="org-variable-name">valgt</span> = <span class="org-builtin">input</span>(f<span class="org-string">"'{alt1}' / '{alt2}'"</span>).lower().strip()
<span class="org-keyword">return</span> valgt
<span class="org-keyword">print</span>(tekst)
<span class="org-variable-name">valg</span> = be_om_input(valg_a, valg_b)
<span class="org-keyword">if</span> valg == valg_a:
<span class="org-keyword">print</span>(tekst_a)
<span class="org-variable-name">valg</span> = be_om_input(valg_aa, valg_ab)
<span class="org-keyword">if</span> valg == valg_aa:
<span class="org-keyword">print</span>(tekst_aa)
<span class="org-keyword">elif</span> valg == valg_ab:
<span class="org-keyword">print</span>(tekst_ab)
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(error)
<span class="org-keyword">elif</span> valg == valg_b:
<span class="org-keyword">print</span>(tekst_b)
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(error)
</pre>
</div>
<p>
Legg merke til at <i>oppførselen</i> til spillet vårt nå er identisk hva den var, men <i>koden</i> har blitt langt mer tydelig og enklere å utvide.
</p>
<p>
<b>Utfordring videre</b> Du ser at deler av koden gjentas her, og at vi får mange nivåer om vi skal fortsette forgreiningene ytterligere «innover». Kan du skissere en måte hvor <code>if</code>-setningene og valgene tas i en «hovedløkke», slik at vi klarer oss med en <code>if</code>-setning og utspørring, det er bare teksten og alternativene som byttes ut? Kanskje kan vi plassere tekststrengene i lister, slik at de kan itereres over?
</p>
<p>
Programmet over kan lastes ned <a href="tekstbasert_feilhaandtering.py">her (tekstbasert_feilhaandtering.py)</a>.
</p>
<p>
Det er mulig å gjøre langt mer med et tekstbasert spill enn det som kommer fram av et skjelett som det over. Fortsett kun med det følgende når du synes feilhåndteringsavsnittet er fullt forståelig og du har jobbet litt med å skrive egne «historier» i det rammeverket.
</p>
</div>
</div>
<div id="outline-container-orgdf413be" class="outline-3">
<h3 id="orgdf413be">Fiendekamp med stein-saks-papir</h3>
<div class="outline-text-3" id="text-orgdf413be">
<p>
La oss begynne med å lage oppsettet for en stein-saks-papir-kamp, før vi i det hele tatt legger det til i eventyret vårt.
</p>
<p>
Jeg har valgt å gjøre det her via to funksjoner, <code>avgjoer</code> som tar inn to valg og avgjør om det var det første eller andre valget som vant, samt <code>spill_steinsakspapir</code> som kjører en kamp med stein-saks-papir til enten spilleren eller maskinen har vunnet.
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-keyword">import</span> random <span class="org-keyword">as</span> rnd
<span class="org-keyword">def</span> <span class="org-function-name">avgjoer</span>(vaapen1, vaapen2):
<span class="org-doc">"""Tar inn to strenger, hver enten 'stein', 'saks', eller 'papir'.</span>
<span class="org-doc"> Returverdier er som følger:</span>
<span class="org-doc"> vaapen1 > vaapen2 => 1</span>
<span class="org-doc"> vaapen2 > vaapen1 => 2</span>
<span class="org-doc"> vaapen1 == vaapen2 => 0</span>
<span class="org-doc"> Rangeringen er</span>
<span class="org-doc"> 'stein' > 'saks' > 'papir'</span>
<span class="org-doc"> og 'papir' > 'stein'</span>
<span class="org-doc"> """</span>
<span class="org-keyword">if</span> vaapen1 == <span class="org-string">"stein"</span>:
<span class="org-keyword">if</span> vaapen2 == <span class="org-string">"stein"</span>:
<span class="org-keyword">return</span> 0
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"saks"</span>:
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"papir"</span>:
<span class="org-keyword">return</span> 2
<span class="org-keyword">elif</span> vaapen1 == <span class="org-string">"saks"</span>:
<span class="org-keyword">if</span> vaapen2 == <span class="org-string">"stein"</span>:
<span class="org-keyword">return</span> 2
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"saks"</span>:
<span class="org-keyword">return</span> 0
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"papir"</span>:
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> vaapen1 == <span class="org-string">"papir"</span>:
<span class="org-keyword">if</span> vaapen2 == <span class="org-string">"stein"</span>:
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"saks"</span>:
<span class="org-keyword">return</span> 2
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"papir"</span>:
<span class="org-keyword">return</span> 0
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(<span class="org-string">"Det skjedde noe feil i avgjørelsen."</span>)
<span class="org-keyword">def</span> <span class="org-function-name">spill_steinsakspapir</span>():
<span class="org-doc">"""En funksjon du kan spille stein-saks-papir mot. Den returner følgende:</span>
<span class="org-doc"> spill_steinsakspapir() => 1 # spilleren vant</span>
<span class="org-doc"> spill_steinsakspapir() => 2 # funksjonen vant</span>
<span class="org-doc"> </span>
<span class="org-doc"> Funksjonen fortsetter å spille til det er kåret en vinner.</span>
<span class="org-doc"> Rangeringen av 'stein', 'saks', og 'papir' gjøres i 'avgjoer'-funksjonen.</span>
<span class="org-doc"> """</span>
<span class="org-variable-name">vaapen</span> = [<span class="org-string">"stein"</span>, <span class="org-string">"saks"</span>, <span class="org-string">"papir"</span>]
<span class="org-keyword">while</span> <span class="org-constant">True</span>:
<span class="org-variable-name">spillers_valg</span> = <span class="org-builtin">input</span>(f<span class="org-string">" '{vaapen[0]}' / '{vaapen[1]}' / '{vaapen[2]}' "</span>)
<span class="org-variable-name">spillers_valg</span> = spillers_valg.lower().strip()
<span class="org-variable-name">mitt_valg</span> = rnd.choice(vaapen)
<span class="org-variable-name">avgjoerelse</span> = avgjoer(spillers_valg, mitt_valg)
<span class="org-keyword">if</span> avgjoerelse == 0:
<span class="org-keyword">print</span>(<span class="org-string">"Uavgjort, vi prøver igjen..."</span>)
<span class="org-keyword">elif</span> avgjoerelse == 1:
<span class="org-keyword">print</span>(<span class="org-string">"Æsj, du vant."</span>)
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> avgjoerelse == 2:
<span class="org-keyword">print</span>(<span class="org-string">"Ha ha, jeg vant!"</span>)
<span class="org-keyword">return</span> 2
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(<span class="org-string">"Vi klarte visst ikke helt dette, du og jeg."</span>)
</pre>
</div>
<p>
Dette kan vi så legge inn i eventyret vårt ved å gjøre klart ekstra forgreininger.
</p>
<div class="org-src-container">
<pre class="src src-python">
<span class="org-variable-name">tekst</span> = <span class="org-string">"Du våkner klokken 5:32 og føler deg våken, men vurderer å forsøke å fortsette å sove. Du ..."</span>
<span class="org-variable-name">valg_a</span> = <span class="org-string">"står opp"</span>
<span class="org-variable-name">tekst_a</span> = <span class="org-string">"... står opp og ser en gammel bok i bokhylla. Du ..."</span>
<span class="org-variable-name">valg_aa</span> = <span class="org-string">"leser"</span>
<span class="org-variable-name">tekst_aa</span> = <span class="org-string">""""... får en fin start på dagen med en spennende bok.</span>
<span class="org-string">Med ett spretter det en gnom ut av boka og sier "Hei, jeg vil spille stein-saks-papir." Du ..."""</span>
<span class="org-variable-name">valg_aaa</span> = <span class="org-string">"godtar"</span>
<span class="org-variable-name">tekst_aaa</span> = <span class="org-string">"Du gjør deg klar til kamp, tar fram nevene og velger..."</span>
<span class="org-variable-name">tekst_aaa1</span> = <span class="org-string">"Du vant kampen, for en lykke, for en glede, for en rus!"</span>
<span class="org-variable-name">tekst_aaa2</span> = <span class="org-string">"Du tapte kampen, mørket senker seg over sinnet ditt."</span>
<span class="org-variable-name">valg_aab</span> = <span class="org-string">"avslår"</span>
<span class="org-variable-name">tekst_aab</span>= <span class="org-string">"Du lukker boka, gnomen forsvinner, du fortsetter forundret med dagen din."</span>
<span class="org-variable-name">valg_ab</span> = <span class="org-string">"lar være"</span>
<span class="org-variable-name">tekst_ab</span> = <span class="org-string">"... kjenner på en tomhetsfølelse som følger deg gjennom dagen."</span>
<span class="org-variable-name">valg_b</span> = <span class="org-string">"sover videre"</span>
<span class="org-variable-name">tekst_b</span> = <span class="org-string">"... sover og drømmer om et liv hvor muligheter gripes."</span>
<span class="org-variable-name">error</span> = <span class="org-string">"Det var jommen et ugyldig valg, fysikkens lover er brutt."</span>
<span class="org-keyword">def</span> <span class="org-function-name">be_om_input</span>(alt1, alt2):
<span class="org-doc">"""Ber spilleren om å taste inn input til spillet, og gir seg først når</span>
<span class="org-doc"> spilleren har tastet inn noe gyldig.</span>
<span class="org-doc"> </span>
<span class="org-doc"> Returnerer valget brukeren tastet inn når dette er gyldig.</span>
<span class="org-doc"> Eksempel på bruk:</span>
<span class="org-doc"> valg = be_om_input('gå', 'løp')</span>
<span class="org-doc"> 'gå' / 'løp' >>> går</span>
<span class="org-doc"> Ugyldig alternativ, prøv igjen.</span>
<span class="org-doc"> 'gå' / 'løp' >>> gå # valg er nå 'gå'</span>
<span class="org-doc"> """</span>
<span class="org-variable-name">valgt</span> = <span class="org-constant">None</span>
<span class="org-keyword">while</span> valgt != alt1 <span class="org-keyword">and</span> valgt != alt2:
<span class="org-variable-name">valgt</span> = <span class="org-builtin">input</span>(f<span class="org-string">"'{alt1}' / '{alt2}'"</span>).lower().strip()
<span class="org-keyword">return</span> valgt
<span class="org-keyword">print</span>(tekst)
<span class="org-variable-name">valg</span> = be_om_input(valg_a, valg_b)
<span class="org-keyword">if</span> valg == valg_a:
<span class="org-keyword">print</span>(tekst_a)
<span class="org-variable-name">valg</span> = be_om_input(valg_aa, valg_ab)
<span class="org-keyword">if</span> valg == valg_aa:
<span class="org-keyword">print</span>(tekst_aa)
<span class="org-variable-name">valg</span> = be_om_input(valg_aaa, valg_aab)
<span class="org-keyword">if</span> valg == valg_aaa:
<span class="org-keyword">print</span>(tekst_aaa)
<span class="org-variable-name">resultat</span> = spill_steinsakspapir()
<span class="org-keyword">if</span> resultat == 1:
<span class="org-keyword">print</span>(tekst_aaa1)
<span class="org-keyword">elif</span> resultat == 2:
<span class="org-keyword">print</span>(tekst_aaa2)
<span class="org-keyword">elif</span> valg == valg_aab:
<span class="org-keyword">print</span>(tekst_aab)
<span class="org-keyword">elif</span> valg == valg_ab:
<span class="org-keyword">print</span>(tekst_ab)
<span class="org-keyword">elif</span> valg == valg_b:
<span class="org-keyword">print</span>(tekst_b)
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(error)
</pre>
</div>
<p>
Programmet over kan lastes ned <a href="tekstbasert_steinsakspapir.py">her (tekstbasert_steinsakspapir.py)</a>.
</p>
</div>
</div>
<div id="outline-container-orgb849b0e" class="outline-3">
<h3 id="orgb849b0e">En ny struktur</h3>
<div class="outline-text-3" id="text-orgb849b0e">
<div class="org-src-container">
<pre class="src src-python"><span class="org-keyword">import</span> random <span class="org-keyword">as</span> rnd
<span class="org-keyword">def</span> <span class="org-function-name">be_om_input</span>(alternativer):
<span class="org-doc">"""Tar inn en liste med alternativer og gir spilleren mulighet til å velge</span>
<span class="org-doc"> en av dem. Returnerer indeksen i lista for valget brukeren tok. Gir også </span>
<span class="org-doc"> brukeren mulighet til å velge ved å taste inn et tall.</span>
<span class="org-doc"> For eksempel:</span>
<span class="org-doc"> >>> svaridx = be_om_input(['stå opp', 'sov videre'])</span>
<span class="org-doc"> 1) 'stå opp'</span>
<span class="org-doc"> 2) 'sov videre'</span>
<span class="org-doc"> [1-2] / tekst: stå opp # svaridx er nå 0, siden 'stå opp' lå på indeks 0 i alternativer</span>
<span class="org-doc"> """</span>
<span class="org-variable-name">valgt</span> = <span class="org-constant">None</span>
<span class="org-variable-name">alternativstrenger</span> = [f<span class="org-string">" {num+1}) '{alternativ}'"</span> <span class="org-keyword">for</span>
num, alternativ <span class="org-keyword">in</span> <span class="org-builtin">enumerate</span>(alternativer)]
<span class="org-variable-name">alternativstreng</span> = <span class="org-string">"\n"</span>.join(alternativstrenger)
<span class="org-variable-name">alternativstreng</span> += f<span class="org-string">"\n[1-{len(alternativer)}] / tekst: "</span>
<span class="org-variable-name">idx</span> = -1
<span class="org-keyword">while</span> idx == -1:
<span class="org-variable-name">valgt</span> = <span class="org-builtin">input</span>(alternativstreng + <span class="org-string">" \n"</span>).lower().strip()
<span class="org-keyword">try</span>:
<span class="org-variable-name">idx</span> = <span class="org-builtin">int</span>(valgt) - 1
<span class="org-keyword">if</span> idx <span class="org-keyword">in</span> <span class="org-builtin">range</span>(<span class="org-builtin">len</span>(alternativer)):
<span class="org-keyword">break</span>
<span class="org-keyword">else</span>:
<span class="org-variable-name">idx</span> = -1
<span class="org-keyword">continue</span>
<span class="org-keyword">except</span> <span class="org-type">ValueError</span>:
<span class="org-keyword">pass</span>
<span class="org-keyword">try</span>:
<span class="org-variable-name">idx</span> = alternativer.index(valgt)
<span class="org-keyword">except</span> <span class="org-type">ValueError</span>:
<span class="org-keyword">pass</span>
<span class="org-keyword">return</span> idx
<span class="org-keyword">def</span> <span class="org-function-name">ferdig</span>():
<span class="org-doc">"""Funksjon som kjøres hver gang man er ferdig med å spille."""</span>
<span class="org-keyword">print</span>(<span class="org-string">"Du er ferdig."</span>)
<span class="org-keyword">def</span> <span class="org-function-name">avgjoer</span>(vaapen1, vaapen2):
<span class="org-doc">"""Tar inn to strenger, hver enten 'stein', 'saks', eller 'papir'.</span>
<span class="org-doc"> Returverdier er som følger:</span>
<span class="org-doc"> vaapen1 > vaapen2 => 1</span>
<span class="org-doc"> vaapen2 > vaapen1 => 2</span>
<span class="org-doc"> vaapen1 == vaapen2 => 0</span>
<span class="org-doc"> Rangeringen er</span>
<span class="org-doc"> 'stein' > 'saks' > 'papir'</span>
<span class="org-doc"> og 'papir' > 'stein'</span>
<span class="org-doc"> """</span>
<span class="org-keyword">if</span> vaapen1 == <span class="org-string">"stein"</span>:
<span class="org-keyword">if</span> vaapen2 == <span class="org-string">"stein"</span>:
<span class="org-keyword">return</span> 0
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"saks"</span>:
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"papir"</span>:
<span class="org-keyword">return</span> 2
<span class="org-keyword">elif</span> vaapen1 == <span class="org-string">"saks"</span>:
<span class="org-keyword">if</span> vaapen2 == <span class="org-string">"stein"</span>:
<span class="org-keyword">return</span> 2
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"saks"</span>:
<span class="org-keyword">return</span> 0
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"papir"</span>:
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> vaapen1 == <span class="org-string">"papir"</span>:
<span class="org-keyword">if</span> vaapen2 == <span class="org-string">"stein"</span>:
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"saks"</span>:
<span class="org-keyword">return</span> 2
<span class="org-keyword">elif</span> vaapen2 == <span class="org-string">"papir"</span>:
<span class="org-keyword">return</span> 0
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(<span class="org-string">"Det skjedde noe feil i avgjørelsen."</span>)
<span class="org-keyword">def</span> <span class="org-function-name">spill_steinsakspapir</span>():
<span class="org-doc">"""En funksjon du kan spille stein-saks-papir mot. Den returner følgende:</span>
<span class="org-doc"> spill_steinsakspapir() => 1 # spilleren vant</span>
<span class="org-doc"> spill_steinsakspapir() => 2 # funksjonen vant</span>
<span class="org-doc"> </span>
<span class="org-doc"> Funksjonen fortsetter å spille til det er kåret en vinner.</span>
<span class="org-doc"> Rangeringen av 'stein', 'saks', og 'papir' gjøres i 'avgjoer'-funksjonen.</span>
<span class="org-doc"> """</span>
<span class="org-variable-name">vaapen</span> = [<span class="org-string">"stein"</span>, <span class="org-string">"saks"</span>, <span class="org-string">"papir"</span>]
<span class="org-keyword">while</span> <span class="org-constant">True</span>:
<span class="org-variable-name">spillers_valg</span> = <span class="org-builtin">input</span>(f<span class="org-string">" '{vaapen[0]}' / '{vaapen[1]}' / '{vaapen[2]}' "</span>)
<span class="org-variable-name">spillers_valg</span> = spillers_valg.lower().strip()
<span class="org-variable-name">mitt_valg</span> = rnd.choice(vaapen)
<span class="org-variable-name">avgjoerelse</span> = avgjoer(spillers_valg, mitt_valg)
<span class="org-keyword">if</span> avgjoerelse == 0:
<span class="org-keyword">print</span>(<span class="org-string">"Uavgjort, vi prøver igjen..."</span>)
<span class="org-keyword">elif</span> avgjoerelse == 1:
<span class="org-keyword">print</span>(<span class="org-string">"Æsj, du vant."</span>)
<span class="org-keyword">return</span> 1
<span class="org-keyword">elif</span> avgjoerelse == 2:
<span class="org-keyword">print</span>(<span class="org-string">"Ha ha, jeg vant!"</span>)
<span class="org-keyword">return</span> 2
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(<span class="org-string">"Vi klarte visst ikke helt dette, du og jeg."</span>)
</pre>
</div>
<div class="org-src-container">
<pre class="src src-python"><span class="org-variable-name">tekst</span> = <span class="org-string">"Du våkner klokken 5:32 og føler deg våken, men vurderer å forsøke å fortsette å sove. Du ..."</span>
<span class="org-variable-name">valg_a</span> = <span class="org-string">"står opp"</span>
<span class="org-variable-name">tekst_a</span> = <span class="org-string">"... står opp og ser en gammel bok i bokhylla. Du ..."</span>
<span class="org-variable-name">valg_aa</span> = <span class="org-string">"leser"</span>
<span class="org-variable-name">tekst_aa</span> = <span class="org-string">""""... får en fin start på dagen med en spennende bok.</span>
<span class="org-string">Med ett spretter det en gnom ut av boka og sier "Hei, jeg vil spille stein-saks-papir." Du ..."""</span>
<span class="org-variable-name">valg_aaa</span> = <span class="org-string">"godtar"</span>
<span class="org-variable-name">tekst_aaa</span> = <span class="org-string">"Du gjør deg klar til kamp, tar fram nevene og velger..."</span>
<span class="org-variable-name">tekst_aaa1</span> = <span class="org-string">"Du vant kampen, for en lykke, for en glede, for en rus!"</span>
<span class="org-variable-name">tekst_aaa2</span> = <span class="org-string">"Du tapte kampen, mørket senker seg over sinnet ditt."</span>
<span class="org-variable-name">valg_aab</span> = <span class="org-string">"avslår"</span>
<span class="org-variable-name">tekst_aab</span>= <span class="org-string">"Du lukker boka, gnomen forsvinner, du fortsetter forundret med dagen din."</span>
<span class="org-variable-name">valg_ab</span> = <span class="org-string">"lar være"</span>
<span class="org-variable-name">tekst_ab</span> = <span class="org-string">"... kjenner på en tomhetsfølelse som følger deg gjennom dagen."</span>
<span class="org-variable-name">valg_b</span> = <span class="org-string">"sover videre"</span>
<span class="org-variable-name">tekst_b</span> = <span class="org-string">"... sover og drømmer om et liv hvor muligheter gripes."</span>
<span class="org-variable-name">error</span> = <span class="org-string">"Det var jommen et ugyldig valg, fysikkens lover er brutt."</span>
<span class="org-variable-name">vaakne</span> = {<span class="org-string">'tekst'</span>: <span class="org-string">"Du våkner..."</span>,
<span class="org-string">'alternativer'</span>: [<span class="org-string">"fortsett å sove"</span>, <span class="org-string">"stå opp"</span>],
<span class="org-string">'videre'</span>: [[<span class="org-string">"Du fortsetter å sove, kjedelig dag."</span>, <span class="org-constant">False</span>],
[<span class="org-string">"Du står opp og er klar for en ny dag"</span>, 1]],
<span class="org-string">'fiende'</span>: <span class="org-constant">False</span>}
<span class="org-variable-name">kjoekken</span> = {<span class="org-string">'tekst'</span>: <span class="org-string">"Du går inn på kjøkkenet, her ser du masse ting."</span>,
<span class="org-string">'alternativer'</span>: [<span class="org-string">"fortsett"</span>, <span class="org-string">"ikke"</span>],
<span class="org-string">'videre'</span>: [[<span class="org-string">"Du fortsetter"</span>, <span class="org-constant">False</span>],
[<span class="org-string">"Du blir"</span>, <span class="org-constant">False</span>]],
<span class="org-string">'fiende'</span>: <span class="org-constant">True</span>}
<span class="org-variable-name">scenarioer</span> = [vaakne, kjoekken]
<span class="org-variable-name">idx</span> = 0 <span class="org-comment-delimiter"># </span><span class="org-comment">Vi starter i første scenario i sceneriolista</span>
</pre>
</div>
<div class="org-src-container">
<pre class="src src-python"><span class="org-variable-name">TEKSTIDX</span> = 0
<span class="org-variable-name">NESTEIDX</span> = 1
<span class="org-variable-name">hovedperson</span> = {<span class="org-string">'hp'</span>: 100,
<span class="org-string">'str'</span>: 30}
<span class="org-keyword">while</span> <span class="org-constant">True</span>:
<span class="org-variable-name">scenario</span> = scenarioer[idx]
<span class="org-keyword">print</span>(scenario[<span class="org-string">'tekst'</span>])
<span class="org-variable-name">valgidx</span> = be_om_input(scenario[<span class="org-string">'alternativer'</span>])
<span class="org-keyword">print</span>(scenario[<span class="org-string">'videre'</span>][valgidx][TEKSTIDX])
<span class="org-variable-name">neste</span> = scenario[<span class="org-string">'videre'</span>][valgidx][NESTEIDX]
<span class="org-keyword">if</span> neste:
<span class="org-variable-name">idx</span> = neste
<span class="org-keyword">else</span>:
<span class="org-keyword">break</span>
ferdig()
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-orgb528d51" class="outline-2">
<h2 id="orgb528d51">Battleships</h2>
<div class="outline-text-2" id="text-orgb528d51">
</div>
<div id="outline-container-orgc4505ec" class="outline-3">
<h3 id="orgc4505ec">Regler</h3>
<div class="outline-text-3" id="text-orgc4505ec">
<p>
Battleships spilles på et rutenett med ti ganger ti ruter, man navngir kolonnene A til J og radene 1 til 10. Rute "B8" viser da til rute nummer åtte ovenfra, nummer to fra venstre, som i et regneark. Hver spiller setter ut båter på sitt rutenett, hvor størrelsen sier hvor mange ruter båten tar.
</p>
<table border="2" cellspacing="0" cellpadding="6" rules="groups" frame="hsides">
<colgroup>
<col class="org-right" />
<col class="org-left" />
<col class="org-right" />
</colgroup>
<thead>
<tr>
<th scope="col" class="org-right">Antall</th>
<th scope="col" class="org-left">Type</th>
<th scope="col" class="org-right">Størrelse</th>
</tr>
</thead>
<tbody>
<tr>
<td class="org-right">1</td>
<td class="org-left">Hangarskip</td>
<td class="org-right">5</td>
</tr>
<tr>
<td class="org-right">1</td>
<td class="org-left">Jagere</td>
<td class="org-right">4</td>
</tr>
<tr>
<td class="org-right">1</td>
<td class="org-left">Fregatter</td>
<td class="org-right">3</td>
</tr>
<tr>
<td class="org-right">2</td>
<td class="org-left">Korvetter</td>
<td class="org-right">2</td>
</tr>
<tr>
<td class="org-right">2</td>
<td class="org-left">Undervanssbåt</td>
<td class="org-right">1</td>
</tr>
</tbody>
</table>
<p>
To spillere plasserer ut båtene på hvert sitt brett. Spiller 1 begynner så å «skyte» på spiller 2s brett ved å si koordinater, for eksemepel "I5". Spiller 2 forteller så spiller 1 hvorvidt det var treff eller bom, og skyter så sitt eget skudd.
</p>
</div>
</div>
<div id="outline-container-orgcd819e6" class="outline-3">
<h3 id="orgcd819e6">Din oppgave</h3>
<div class="outline-text-3" id="text-orgcd819e6">
<p>
Du skal lage en kunstig intelligens som spiller Battleships. Jeg kommer til å sette opp et «spilleder»-program, hvor dette kommer til å kjøre din kode opp mot en av medelevene dines.
</p>
<p>
Mitt program ser ut som følger:
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-keyword">import</span> battleships_spillereksempel <span class="org-keyword">as</span> p1
<span class="org-keyword">import</span> battleships_spillereksempel <span class="org-keyword">as</span> p2
<span class="org-keyword">import</span> time
<span class="org-variable-name">ANTALL</span> = 15
<span class="org-variable-name">p1treff</span> = 0
<span class="org-variable-name">p2treff</span> = 0
<span class="org-keyword">while</span> <span class="org-constant">True</span>:
<span class="org-variable-name">p1skudd</span> = p1.skudd()
<span class="org-variable-name">p2svar</span> = p2.mottak(p1skudd)
<span class="org-keyword">if</span> p2svar:
<span class="org-keyword">print</span>(<span class="org-string">"p1 traff"</span>)
<span class="org-variable-name">p1treff</span> +=1
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(<span class="org-string">"p1 bomma"</span>)
p1.tilbakemelding(p2svar)
<span class="org-variable-name">p2skudd</span> = p2.skudd()
<span class="org-variable-name">p1svar</span> = p1.mottak(p2skudd)
<span class="org-keyword">if</span> p1svar:
<span class="org-keyword">print</span>(<span class="org-string">"p2 traff"</span>)
<span class="org-variable-name">p2treff</span> += 1
<span class="org-keyword">else</span>:
<span class="org-keyword">print</span>(<span class="org-string">"p2 bomma"</span>)
p2.tilbakemelding(p1svar)
<span class="org-keyword">if</span> p1treff == ANTALL <span class="org-keyword">and</span> p2treff != ANTALL:
<span class="org-keyword">print</span>(<span class="org-string">"p1 vant!"</span>)
<span class="org-keyword">break</span>
<span class="org-keyword">elif</span> p1treff != ANTALL <span class="org-keyword">and</span> p2treff == ANTALL:
<span class="org-keyword">print</span>(<span class="org-string">"p2 vant!"</span>)
<span class="org-keyword">break</span>
<span class="org-keyword">elif</span> p1treff == ANTALL <span class="org-keyword">and</span> p2treff == ANTALL:
<span class="org-keyword">print</span>(<span class="org-string">"Uavgjort!"</span>)
<span class="org-keyword">break</span>
<span class="org-keyword">else</span>:
time.sleep(0.3)
</pre>
</div>
<p>
Dette ser altså ut som en slags trespillerutgave, hvor spillederprogrammet fungerer som en megler mellom de to motstanderne. Linjene i programmet over kan oppsummeres omtrent som følger:
</p>
<dl class="org-dl">
<dt>megler</dt><dd>Spiller 1 (<code>p1</code>), hvor skyter du?</dd>
<dt>p1</dt><dd>Jeg skyter i <code>"B4"</code>.</dd>
<dt>megler</dt><dd>(Lagrer <code>"B4"</code> som <code>p1skudd</code>.)</dd>
<dt>megler</dt><dd>Spiller 2 (<code>p2</code>), <code>p1</code> skyter i <code>"B4"</code>, hva er ditt svar?</dd>
<dt>p2</dt><dd>Det var bom (svaret er <code>False</code>).</dd>
<dt>megler</dt><dd>(Lagrer <code>False</code> som <code>p2svar</code>.)</dd>
<dt>megler</dt><dd><code>p1</code>, du bomma.</dd>
<dt>megler</dt><dd><code>p2</code>, hvor skyter du?</dd>
<dt>p2</dt><dd>jeg skyter i <code>"I9"</code>.</dd>
<dt>megler</dt><dd>(Lagrer <code>"I9"</code> som <code>p2skudd</code>.)</dd>
<dt>megler</dt><dd><code>p1</code>, <code>p2</code> skyter i <code>"I9"</code>, hva er ditt svar?</dd>
<dt>p1</dt><dd>Det var treff (svaret er <code>True</code>).</dd>
<dt>megler</dt><dd>(Lagrer <code>True</code> som <code>p1svar</code>.)</dd>
<dt>megler</dt><dd><code>p2</code>, du traff</dd>
<dt>megler</dt><dd><code>p1</code>, hvor skyter du?</dd>
</dl>
<p>
Ditt program kan settes opp på omtrent en måte à la denne:
</p>
<div class="org-src-container">
<pre class="src src-python"><span class="org-keyword">import</span> random <span class="org-keyword">as</span> rnd
<span class="org-variable-name">mitt_spillbrett</span> = [ [0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
[0, 1, 0, 1, 1, 1, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 1, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 1, 1, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 0, 0, 0] ]
<span class="org-keyword">def</span> <span class="org-function-name">bokstav_til_kolonne</span>(bokstav):
<span class="org-doc">"""Tar inn en bokstavverdi, og returnerer hvilken kolonne det tilsvarer,</span>
<span class="org-doc"> null-indeksert.</span>
<span class="org-doc"> Eksempler:</span>
<span class="org-doc"> bokstav_til_kolonne('A') # => 0</span>
<span class="org-doc"> bokstav_til_kolonne('D') # => 3</span>
<span class="org-doc"> bokstav_til_kolonne('J') # => 9</span>
<span class="org-doc"> bokstav_til_kolonne('C') # => 2</span>
<span class="org-doc"> """</span>
<span class="org-keyword">return</span> <span class="org-string">"ABCDEFGHIJ"</span>.index(bokstav.upper())
<span class="org-keyword">def</span> <span class="org-function-name">finn_verdi</span>(koordinatstreng):
<span class="org-doc">"""Tar inn en koordinatstreng på formen "bokstavtall" og returnerer</span>
<span class="org-doc"> hvorvidt det er en båt i den koordinaten.</span>
<span class="org-doc"> """</span>
<span class="org-variable-name">bokstav</span> = koordinatstreng[0]
<span class="org-variable-name">rad</span> = <span class="org-builtin">int</span>(koordinatstreng[1])
<span class="org-variable-name">kol</span> = bokstav_til_kolonne(bokstav)
<span class="org-variable-name">verdi</span> = mitt_spillbrett[rad][kol]
<span class="org-keyword">return</span> verdi
<span class="org-keyword">def</span> <span class="org-function-name">tilbakemelding</span>(koordinatstreng):
<span class="org-doc">"""Denne funksjonen kalles når jeg får tilbakemelding på skuddet mitt."""</span>
<span class="org-keyword">return</span> <span class="org-constant">None</span>
<span class="org-keyword">def</span> <span class="org-function-name">skudd</span>():
<span class="org-doc">"""Dette er hovedfunksjonen som blir kjørt når jeg skal skyte."""</span>
<span class="org-variable-name">bokstav</span> = rnd.choice(<span class="org-string">"ABCDEFGIJ"</span>)
<span class="org-variable-name">tall</span> = <span class="org-builtin">str</span>(rnd.randint(0, 9))
<span class="org-keyword">return</span> bokstav + tall
<span class="org-keyword">def</span> <span class="org-function-name">mottak</span>(koordinatstreng):
<span class="org-doc">"""Denne funksjonen kalles når «jeg» skytes på."""</span>
<span class="org-keyword">return</span> finn_verdi(koordinatstreng) == 1
</pre>
</div>
</div>
</div>
</div>
<div id="outline-container-org9c6606c" class="outline-2">
<h2 id="org9c6606c">Droneaksellerasjon</h2>
<div class="outline-text-2" id="text-org9c6606c">
</div>
</div>
</div>
</body>
</html>