DAT 060 Laboration 2 I Malmös kasino Institutionen för datavetenskap 17 juni 2002 Per tänkte dryga ut sitt magra studielån genom att jobba som labbassistent på sommarkursen. Tyvärr fanns det redan tillräckligt många duktiga människor som tog jobbet, därför vände sig Per till den näst bästa lämpliga institutionen, d.v.s. Malmös nya kasino. Bland många intressanta spel blev Pelle särskilt attraherad av Black Jack - ett kortspel som man kan vinna stora pengar på. Men, efter några besök blev det tyvärr slut på studielånet och nu sitter Pelle och tänker på hur han borde spela för att vinna, eller åtminstone få sitt lån tillbaka. Hans korridorare, Micke, läser nu Scheme-kursen och bestämmer sig därför att utnyttja sina färska kunskaper inom ämnet för att hjälpa Pelle. Han tänker skriva en Black Jack-simulator för att prova olika strategier varav någon förhoppningsvis kan leda Pelle till en säker vinst. Black Jack kommer för oss att vara ett spel mellan två spelare. Målet med spelet är att få ett antal kort som ger så mycket poäng som möjligt, men som inte överskrider 21. Varje kort mellan 2 och 9 ger ett antal poäng motsvarande sitt nummer, ett ess ger 1 poäng, medan klädda kort räknas som 10 poäng var. Varje spelare får först ett kort som den andre spelaren får se. Följande kort delas ut så att endast spelaren som får dem får se dem. En spelare spelar först genom att be om nya kort (ett så kallade slag, hit på engelska), ett i taget, tills hon bestämmer sig att stanna med de poäng hon redan fått, eller tills hon får mer poäng än 21. I det andra fallet förlorar hon omedelbart (to bust på engelska). Om den första spelaren inte förlorar så tar den andre spelaren (kallad huset ) över och spelar genom att dra nya kort, ett i taget, tills han stannar eller förlorar genom att få mer än 21 poäng. När huset stannar avslöjas alla kort, poäng räknas och den spelare som har mest poäng vinner. I fall av likaantal poäng vinner huset. Den här versionen av spelet är förenklad μ vi tar inte hänsyn till att ett ess kan räknas på olika sätt, eller till delning ( splitting ). Eftersom vi endast kommer att analysera spelstrategier och jämföra dem med varandra, kommer vi inte heller att modellera satsning av pengar. Det måste Pelle fundera på själv. En spelares strategi bestämmer när vill han dra ett nytt kort och när vill han stanna med nuvarande hand (mängd av kort). I vårt fall kommer varje spelare modelleras som en procedur som implementerar hans strategi. Eftersom en typisk strategi för att bestämma när man bör slå samt när man bör stanna, är beroende av spelarens nuvarande hand och opponentens synliga kort, kommer en strategi att representeras som en procedur med två argument: spelarens hand och värdet på opponentens kort. Proceduren returnerar sann (#t) om spelaren skulle slå (be om ett nytt kort) och falsk (#f) om spelaren bör stanna. T.ex. skulle följande (ganska dumma) strategi alltid ta ett kort om opponentens kort är större än 5: (define (stupid-strategy my-hand opponent-up-card) (> opponent-up-card 5)) Följande procedur play-hand tar som argument en strategi, en hand, och opponentens synliga kortet. Proceduren slår så länge strategin tillåter det eller tills värdet på korten i handen överskrider 21. play-hand returnerar som sitt värde hela handen som delades ut. (define (play-hand strategy my-hand opponent-up-card) (cond ((> (hand-total my-hand) 21) my-hand) ; I lose... give up ((strategy my-hand opponent-up-card) ; hit? (play-hand strategy (hand-add-card my-hand (deal)) opponent-up-card)) (else my-hand))) ; stay Ett stort tack till Julian Togelius Ekwall för språkhjälp. Alla fel som fortfarande finns är förstås mina. Jacek Malec. This lab assignment has been prepared on the basis of the MIT's The ame of Twenty-one, available on the SICP homepage http://mitpress.mit.edu/sicp. 1
Institutionen för datavetenskap, DAT060, Laboration 2 2 För denna enkla simulerings skull kommer handen att representeras som ett par tal μ värdet på det synliga kortet och värdet på spelares alla kort. Vi ska använda en enkel form av dataabstrahering som kommer att diskuteras på föreläsningen onsdagen den 19:e juni. Vi har en konstruktor-procedur make-hand som skapar en hand utav två tal, och två selektorer hand-up-card och hand-total som returnerar det synliga kortet och värde på alla kort i handen: (define (make-hand up-card total) (cons up-card total)) (define (hand-up-card hand) (car hand)) (define (hand-total hand) (cdr hand)) Vi kommer här att bortse från Schemes primitiver cons, car och cdr som används för att implementera dessa procedurer μ vi kommer att diskutera dem senare på föreläsningarna. Betrakta än så länge make-hand, hand-up-card och hand-total som enkla svarta lådor som tillåter oss att representera händer. Vi kan nu implementera några nyttiga operationer på händer. make-new-hand tar som sitt argument ett nytt kort och returnerar en hand med endast detta kort (d.v.s. kortet är både synligt och ingår i det totala värdet): (define (make-new-hand first-card) (make-hand first-card first-card)) hand-add-card tar en hand och ett nytt kort och returnerar en hand med samma synliga kort, men med det nya kortet inräknade i totalvärdet: (define (hand-add-card hand new-card) (make-hand (hand-up-card hand) (+ new-card (hand-total hand)))) Istället för att modellera en verklig kortlek delar vi ut kort slumpmässigt och antar att varje värde på kort mellan 1 och 10 är lika sannolik 1. (Det är förstås en översimplifiering, men eftersom vi fokuserar på strategier, så är skillnaderna inte så viktiga.) Att dela ett kort är då att slumpa fram ett tal mellan 1 och 10: (define (deal) (+ 1 (random 10))) Slutligen introducerar vi den översta nivån av simulering, proceduren twenty-one. Den tar två strategier: spelarens och husets, som sina två argument. Proceduren skapar ursprungliga händer för en spelare och för huset, sedan spelar spelarens strategi och slutligen spelar husets strategi. twenty-one returnerar 1 om spelaren vinner och 0 om huset vinner. (define (twenty-one player-strategy house-strategy) (let ((house-initial-hand (make-new-hand (deal)))) ; set up house hand ; let is covered on pp.58-61 of text (let ((player-hand ; set up initial hand, and play out (play-hand player-strategy ; strategy to use (make-new-hand (deal)) ; initial player hand (hand-up-card house-initial-hand)))) ; ;information about house hand available to player (if (> (hand-total player-hand) 21) 0 ; bust : player loses (let ((house-hand ; play out house hand (play-hand house-strategy house-initial-hand (hand-up-card player-hand)))) (cond ((> (hand-total house-hand) 21) 1) ; bust : house loses ((> (hand-total player-hand) (hand-total house-hand)) 1) ; house loses (else 0))))))) ; player loses hit? är en enkel interaktiv strategiprocedur som kan användas med twenty-one. Den visar informationen tillgänglig för spelaren den simulerar och frågar om den bör ta ett nytt kort. Proceduren returnerar #t om du skriver j och #f om du skriver något annat 2. 1 En möjlig utvidgning vore att modellera en kortlek med större nogrannhet. Se utöknings-uppgifterna. 2 user-says-y? är definierat som (lambda () (eq? (read) 'j)). Proceduren jämför uttrycket läst från tangentbordet med symbolen j. Vi skall betrakta symboler och symboliska uttryck om ett par veckor (kapitel 2.2.3 i boken.)
Institutionen för datavetenskap, DAT060, Laboration 2 3 (define (hit? your-hand opponent-up-card) (printf " Opponentens synligt kort: ") (printf " Λa" opponent-up-card) (printf " Din totalvärde: ") (printf " Λa" (hand-total your-hand)) (printf " Hit? ") (user-says-y?)) (define (user-says-y?) (eq? (read) 'j)) Att göra på laborationen Ladda koden från filen lab2.ss och försök spela mot dig själv genom att evaluera: (twenty-one hit? hit?) Kom ihåg att den första sekvensen av frågor gäller spelares hand, medan den andra husets hand. Definiera nu en procedur stanna-vid som tar ett tal som argument och returnerar en strategi. Strategin stanna-vid bör fråga om ett nytt kort om och endast om det totala värdet av handen är mindre än argumenten till stanna-vid. T.ex. (stanna-vid 15) bör returnera en strategi som frågar om ett kort när värdet av handen är mindre än 15, men stannar omedelbart om värdet blir 15 eller mer. För att testa din implementation av stanna-vid, spela några spel genom att evaluera: (twenty-one hit? (stanna-vid 16)) D.v.s. du ska spela mot huset som har strategin att stanna vid 16. Visa din procedur och några resultat för labbledaren. Definiera nu en procedur testa-strategi som testar två strategier genom att spela ett fördefinierat antal spel med de två strategierna. testa-strategi bör returnera antalet spel vunna av spelaren (därmed förlorade av huset). T.ex. (testa-strategi (stanna-vid 16) (stanna-vid 15) 10) bör spela tio BlackJack spel med (stanna-vid 16) som spelarens strategi och (stanna-vid 15) som husets strategi. Den bör returnera ett heltal som säger hur många spel som vunnits av spelaren. Visa proceduren och resultaten för en labbledare 3. Det är omöjligt att säga hur spelen pågår om man använder testa-strategi för testning, eftersom ingen kontroll kan utföras på enstaka spel. Det vore bra att kunna observera hur spelet utvecklas genom att se invärde till strategierna och deras beslut. Definiera en procedur observera-spelare som tar en strategi som argument och returnerar en strategi som resultat. Strategin som returneras av observera-spelare bör implementera exakt samma strategi som argumentet gör, men den bör dessutom skriva ut informationen som passerades till strategin och beslut som den fattade. T.ex.: (testa-strategi (observera-spelare (stanna-vid 16)) (observera-spelare (stanna-vid 15)) 2) bör spela två simulerade spel och visavad varje spelare gör i varje steg av spelet 4.Visakoden och resultat för din labbledare. Micke har slutligen övertygat Pelle att beskriva sin Black Jack strategi. Den är följande: Om handen är mindre än 12 poäng så ber alltid Pelle om ett nytt kort. Om handen är mer än 16 poäng så stannar Pelle alltid. Om handen är exakt 12 poäng så frågar Pelle efter ett nytt kort endast om husets synliga kort är mindre än 4. Om hans hand är exakt 16 så stannar han om husets synliga kort är värd 10. Om ingen av dessa villkor är uppfyllda (d.v.s. om hans hand ligger mellan 13 och 15) så frågar Pelle om ett nytt kort 3 Det bör finnas här en markering på marginalen i form av enbokstav. Det betyder att labbledaren bör godkänna det du gjorde. Senare i texten förekommer fler sådana markeringar, med samma betydelse. 4 Du kan ha nytta av Schemes dokumentation som finns tillgänglig i systemet. Leta efter utskriftsatserna och eventuellt utskriftsformattering. Du får prova DrSchemes inbyggd hjälp, men det kan också visa sig nyttig att leta efter R5RS. (Vad är det och var finns det?)
Institutionen för datavetenskap, DAT060, Laboration 2 4 endast om husets synliga kort är större än 6, annars stannar han. Definiera en strategi som heter pelle som implementerar Pelles strategi. Prova hans strategi mot strategierna som stannar vid 15, 16 och 17 genom att evaluera: (testa-strategi pelle (stanna-vid 15) 10) (testa-strategi pelle (stanna-vid 16) 10) (testa-strategi pelle (stanna-vid 17) 10) Visa koden för din labbledare. Implementera proceduren båda som tar två strategier som argument och returnerar en ny strategi. Den nya strategin bör be om ett nytt kort om och endast om båda argumentstrategierna gör det. T.ex. en strategi (båda (stanna-vid 19) hit?) ska fråga om ett nytt kort endast om värdet på handen är mindre än 19 och användaren ber om ett kort. Visa proceduren och resultat för din labbledare. Att utvidga simulatorn vidare Denna avsnitt innehåller förslag på utvidgningar som du skulle kunna vilja införa i ditt program. Eftersom de bygger på dataabstraktioner, behöver du inte nödvändigtvis vara redan bekant med materialet. Men du får gärna återkomma till uppgiften när du känner dig intresserad. Problem 1 Simulationen ovan är mycket förenklad eftersom en hand endast representeras som ett par tal. Låt oss anta att vi vill ha mer information om handen, nämligen vilka kort (deras storlek och färg) vi har i handen. En möjlighet vore att introducera dataabstraktionen kort som representerar ett kort och, m.h.a. kort, implementera kortmängd för att representera en mängd med kort i. En hand i denna simulering vore representerat som opponentens synliga kort och en mängd kort. Hur kan man implementera detta? Använd liststruktur för att representera kort och kortmängder. Hur skulle du ändra procedurerna make-hand, first-card, hand-up-card, hand-total och hand-add-card?vad mer måste du göra för att få simuleringen att fungera? Problem 2 I simuleringen ovan används en oändlig kortlek där alla kort mellan 1 och 10 är lika sannolika. Om Pelle verkligen siktar på Malmös kasino så är sådan simulering inte till stor hjälp. För att t.ex. använda strategin att räkna kort måste man kunna modellera utgång av kort från kortleken (eller kortlekerna - på de flesta kasinon använder man fyra till sex kortlekar tillsammans för att eliminera fördelar för snabbt räknande spelare). 1. Hur skulle du implementera en procedur som genererar en färsk kortlek som ser ut så här: (1 1 1 1 2 2 2 2 3 3 3 3... 10 10 10 10) Hur skulle du modifiera den för att också ta hänsyn till de klädda korten givet att varje också ger 10 poäng? 2. Hur skulle du implementera en procedur blanda, som tar en kortlek som argument och producerar en ny kortlek med samma kort, men i ändrad ordning. T.ex. det kan göras genom att dela kortleken i två lika stora delar och sedan blandning av de två halvor i tur och ordning: första kortet från första halvan, första kortet från andra halvan, andra kortet från första halvan, andra kortet från andra halvan,... 3. Observera att proceduren blanda alltid skulle returnera samma resultat givet samma argument. blanda är en deterministisk procedur. En bättre blandning skulle introducera en slumpfaktor i processen. Hur skulle du implementera slump-blanda som skulle ge icke-deterministiska resultat?
Institutionen för datavetenskap, DAT060, Laboration 2 5 4. Slutligen, hur skulle du ta hänsyn i simuleringen till en ändlig kortlek? En möjlighet vore att passera kortleken som ett extra argument till relevanta procedurer och implementera procedurerna som tar det första kortet från kortleken och som returnerar resten av kortleken. En ganska verklig simulering skulle använda en färsk kortlek (eller några färska kortlekar), blanda den några gånger och sedan spela spelet tills antalet kort i kortleken blir tillräckligt litet (låt oss säga 10% av det ursprungliga antalet kort). Tack för idag.