ITI0011:Tikumäng - Redigeerimiste ajalugu

Ago: /* Näpunäiteid */

2015-03-03T00:19:04Z

Näpunäiteid

Ago – 23. veebruar 2015, kell 00:56

2015-02-23T00:56:20Z

Ago: /* Mall */

2015-02-19T10:36:32Z

Mall

Ago: /* Lisaülesanne: võidukäik (1p) */

2015-02-16T12:04:11Z

Lisaülesanne: võidukäik (1p)

Ago – 16. veebruar 2015, kell 11:57

2015-02-16T11:57:23Z

Näita muudatusi

Ago – 13. veebruar 2015, kell 15:02

2015-02-13T15:02:18Z

Ago: /* Lisaülesanne: võidukäigu õppimine (3p) */

2015-02-13T14:04:42Z

Lisaülesanne: võidukäigu õppimine (3p)

Ago – 13. veebruar 2015, kell 14:02

2015-02-13T14:02:03Z

Ago – 13. veebruar 2015, kell 07:59

2015-02-13T07:59:09Z

Ago – 3. veebruar 2015, kell 02:40

2015-02-03T02:40:35Z

←Vanem redaktsioon		Redaktsioon: 3. märts 2015, kell 00:19
345. rida:		345. rida:
	* [[Java:Muutujad#Klassimuutujad]]		* [[Java:Muutujad#Klassimuutujad]]
	* [[Java:Muutujad#Magic number]] - kui checkstyle plugin Eclipse'is hädaldab "magic number"		* [[Java:Muutujad#Magic number]] - kui checkstyle plugin Eclipse'is hädaldab "magic number"
		+	* [[Java:Kogumid]]

←Vanem redaktsioon		Redaktsioon: 23. veebruar 2015, kell 00:56
339. rida:		339. rida:

	</source>		</source>
		+
		+	== Näpunäiteid ==
		+
		+	Mõned peatükid Java juhendist:
		+	* [[Java:Muutujad#Klassimuutujad]]
		+	* [[Java:Muutujad#Magic number]] - kui checkstyle plugin Eclipse'is hädaldab "magic number"

@@ 227. rida: / 227. rida: @@
 Etteantud mall '''GameOfSticks.java''':
 <source lang="java">
 import java.io.ByteArrayInputStream;

@@ 98. rida: / 98. rida: @@
 Kui realiseeritud on vaid põhiosa, saab selle lisaülesande lahendamise eest 1p. Kui realiseeritud on lisaosa dünaamiliste parameetrite kohta, saab selle ülesande eest 2p.
-Selle lisaülsande puhul peate muutma <code>makeComputerMove()</code> selliselt, et suvalise käigu asemel tagastatakse alati parim võimalik käik. Kui parimat käiku pole võimalik teha, siis tuleb tagastada suvaline.
+Selle lisaülesande puhul peate muutma <code>makeComputerMove()</code> selliselt, et suvalise käigu asemel tagastatakse alati parim võimalik käik. Kui parimat käiku pole võimalik teha, siis tuleb tagastada suvaline.
 == Lisaülesanne: võidukäigu õppimine (3p) ==

←Vanem redaktsioon		Redaktsioon: 13. veebruar 2015, kell 15:02
224. rida:		224. rida:

	Näidatud väljund ei pea täpselt selline olema. See on lihtsalt üks näide.		Näidatud väljund ei pea täpselt selline olema. See on lihtsalt üks näide.
		+
		+	Etteantud mall '''GameOfSticks.java''' testimaks AI õppimise funktsionaalsust:
		+	<source lang="java">
		+	/**
		+	* (Bigger) homework 01 - Game of sticks.
		+	*
		+	*/
		+	public class GameOfSticks {
		+
		+	/**
		+	* The main method, which is the entry point of the program.
		+	* This is the method where the main logic of your game is.
		+	* @param args Arguments from the command line
		+	*/
		+	public static void main(String[] args) {
		+	}
		+
		+	/**
		+	* In case of AI bonus task, gets the possible move
		+	* for AI given the board state (number of sticks on the board).
		+	* The move itself should not be done!
		+	* This method will be used to test your AI learning ability.
		+	* @param sticksOnBoard The number of sticks on the board.
		+	* @return Sticks to remove from the board in the given state.
		+	*/
		+	public static int getComputerMove(int sticksOnBoard) {
		+	return -1;
		+	}
		+
		+	/**
		+	* In case of AI bonus task, makes the AI move
		+	* and returns the number of sticks on the board after the move.
		+	* The program should internally keep the track of the board state
		+	* (the number of sticks on the board).
		+	* The program should make the move and make the required operations
		+	* to store the move. If this method returns 0 (game is over),
		+	* the coefficients for different states should be modified accordingly.
		+	* @return The number of sticks after the AI move.
		+	*/
		+	public static int makeComputerMove() {
		+	return -1;
		+	}
		+
		+	/**
		+	* Sets the number of sticks initially on the board.
		+	* If this method is never called, your program should
		+	* still work with default value n = 10.
		+	* @param n The number of sticks initially on the board.
		+	*/
		+	public static void setNumberOfSticksOnBoard(int n) {
		+	// TODO: your code
		+	}
		+
		+	/**
		+	* Sets the number of sticks a player can take during its turn.
		+	* If this method is never called, your program should
		+	* still work with default value m = 3.
		+	* @param m The number of sticks a player can take during its turn.
		+	*/
		+	public static void setMaxNumberOfSticksToTake(int m) {
		+	// TODO: your code
		+	}
		+
		+	/**
		+	* In case of AI bonus task, this method should accept
		+	* human player move. Internally, the program should
		+	* keep the board state (the number of stick on the board).
		+	* This method is required to test the AI working part.
		+	* If this method returns 0 (game is over),
		+	* the coefficients for different states should be modified accordingly.
		+	* @param sticksToTake The human player's move, how many sticks
		+	* the player takes.
		+	* @return The number of sticks after human player move.
		+	*/
		+	public static int makeHumanMove(int sticksToTake) {
		+	// TODO: your code
		+	return 0;
		+	}
		+	}
		+	</source>

@@ 112. rida: / 112. rida: @@
 Üks viis teha tikumängule tehisintellekt (AI) on analüüsida mängu ülesehitust ning selle järgi koostada valem, millega saab arvutada mängija (või arvuti) kõige optimaalseima käigu. Selles lisaosas on vaja teha täpselt vastupidist. Tuleb luua tehisintellekt, mis analüüsib varasemaid mänge ning nende tulemuste põhjal formuleerib järgnevatele mängudele strateegia.
-Siinne kirjeldus on toodud N = 10 ja M = 3 kohta (ehk siis laual on alguses 10 tikku ja korraga võib ära võtta 1 kuni 3 tikku). Kui oled realiseerinud lisaosa, kus N ja M võivad muutuda, piisab sellest, kui ajalugu hoitakse seni, kuni M ja N on samad. Kui neid muudetakse, võid alustada algseisust (ehk siis ajalugu puudub).
+Siinne kirjeldus on toodud N = 10 ja M = 3 kohta (ehk siis laual on alguses 10 tikku ja korraga võib ära võtta 1 kuni 3 tikku). Kui oled realiseerinud lisaosa, kus N ja M võivad muutuda, piisab sellest, kui ajalugu hoitakse seni, kuni M ja N on samad. Kui neid muudetakse, võid alustada algseisust (ehk siis ajalugu puudub). Võib teha ka nii, et alguses küsitakse ära M ja N ning neid muuta ei saa.
 AI näide tikumängule:

@@ 121. rida: / 121. rida: @@
 * Mida rohkem mänge mängitakse, seda rohkem "hea valiku" kuule koguneb ning kotist suvalise kuuli võtmisel on tõenäolisem, et arvuti teeb häid käike.
 Näide:
-Vaatame olukorda kus alguses on 10 tikku ja korraga võib võtta kuni 3 tikku. Koti sisud on järgmised:
+Vaatame olukorda, kus alguses on 10 tikku ja korraga võib võtta kuni 3 tikku. Koti sisud on järgmised:
 kott	1	2	3	4	5	6	7	8	9	10
 sisu	1,2,3	1,2,3	1,2,3	1,2,3	1,2,3	1,2,3	1,2,3	1,2,3	1,2,3	1,2,3
-Mäng kulgeb järgmiselt:
+Aktiivne on see kott, kui palju on tikke laual. Alguses on kõige viimane kott aktiivne. Kui laual on 5 tikku, siis vastavalt kott number 5 jne.
-Nüüd AI jaoks on olukord selline:
+Koti sisu näitab, milliste väärtustega kuulid selles kotis on. Alguses on igal pool 1, 2, 3. See tähendab, et sellisest seisust on võrdne võimalus võita, kui võtta kas 1, 2 või 3 tikku (tegelikult see nii ei ole, aga alguses on AI rumal ning ei oska ühte valikut teisele eelistada).
 kott	1	2	3	4	5	6	7	8	9	10
-sisu	1,2,3	1,2,3	1,2,3	1,2	1,2,3	1,2,3	1,3	1,2,3	1,2,3	1,2,3
+sisu	1,2,3	1,3	1,2,3	1,2,3	2,3	1,2,3	1,2,3	1,3	1,2,3	1,2,3
-valitud				3			2
+valitud		2			1			2
-Kuna AI võitis, siis paneb ta valitud kuulid kotti tagasi ning lisab uued samade väärtustega kuulid.
+Kuna AI võitis, siis paneb ta valitud kuulid kotti tagasi ning lisab uued samade väärtustega kuulid:
 kott	1	2	3	4	5	6	7	8	9	10
-sisu	1,2,3	1,2,3	1,2,3	1,2,3,3	1,2,3	1,2,3	1,2,2,3	1,2,3	1,2,3	1,2,3
+sisu	1,2,3	1,2,2,3	1,2,3	1,2,3	1,1,2,3	1,2,3	1,2,3	1,2,2,3	1,2,3	1,2,3
-Nüüd on AI-l suurem võimalus võtta 3 tikku juhul kui laual on 4 tikku järel ja 2 tikku kui on 7 tikku järel.
+Nüüd on AI-l suurem võimalus võtta:
-Sinu ülesandeks on kirjutada AI, mis uuendab kottide sisu iga mängu korral. Esialgu mängib AI suvaliselt, kuid mida mäng edasi, seda targemaid käike hakkab ta tegema.
+Kui arvuti kaotab, siis ta viskab valitud kuulid ära juhul, kui kotis on vähemalt üks selline kuul alles. Ehk siis, kui algselt oli kotis näiteks kuulid 1, 2, 2, 2, 3. Juhuslikult valib arvuti kuuli "2", kotti jääb 1, 2, 2, 3. Kui arvuti kaotab, siis visatakse see valitud kuul ära, kotti jääb 1, 2, 2, 3.
 Järgnev näide demonstreerib kuidas programm peaks käituma:
 . mäng:
 tikku laual ja korraga saab võtta kuni 3 tikku.
 Mängija võtab 3
-tikku laual
+| | | | | | |       (7)
 Arvuti võtab 2
-tikku laual
+| | | | |           (5)
 Mängija võtab 3
-tikku laual
+| | |               (3)
-Arvuti võtab 2ja kaotab
+Arvuti võtab 2
 .Mäng:
-tikku laual ja korraga saab võtta kuni 3 tikku.
 Mängija võtab 1
-tikku laual
+| | | | | | | | |   (9)
 Arvuti võtab 1
-tikku laual
+| | | | | | | |     (8)
 Mängija võtab 3
-tikku laual
+| | | | |           (5)
 Arvuti võtab 3
-tikku laual
+| |                 (2)
-Mängija võtab 2 ja kaotab
+Mängija võtab 2
 .Mäng:
-tikku laual ja korraga saab võtta kuni 3 tikku.
 Mängija võtab 3
-tikku laual
+| | | | | | |       (7)
 Arvuti võtab 2
-tikku laual
+| | | | |           (5)
 Mängija võtab 3
-tikku laual
+| |                 (2)
-Arvuti võtab 2 ja kaotab
+Arvuti võtab 2
--->
+Näidatud väljund ei pea täpselt selline olema. See on lihtsalt üks näide.

←Vanem redaktsioon		Redaktsioon: 13. veebruar 2015, kell 07:59
110. rida:		110. rida:
	Arvuti õpib mängitud mängude pealt, kuidas peaks mängima, et võita. See lisaülesanne tühistab eelmise võidukäigu lisaülesande (ehk siis valida tuleb üks).		Arvuti õpib mängitud mängude pealt, kuidas peaks mängima, et võita. See lisaülesanne tühistab eelmise võidukäigu lisaülesande (ehk siis valida tuleb üks).

−	~~Täpsem~~ kirjeldus ~~lähiajal~~.	+	Üks viis teha tikumängule tehisintellekt (AI) on analüüsida mängu ülesehitust ning selle järgi koostada valem, millega saab arvutada mängija (või arvuti) kõige optimaalseima käigu. Selles lisaosas on vaja teha täpselt vastupidist. Tuleb luua tehisintellekt, mis analüüsib varasemaid mänge ning nende tulemuste põhjal formuleerib järgnevatele mängudele strateegia.
		+
		+	Siinne kirjeldus on toodud N = 10 ja M = 3 kohta (ehk siis laual on alguses 10 tikku ja korraga võib ära võtta 1 kuni 3 tikku). Kui oled realiseerinud lisaosa, kus N ja M võivad muutuda, piisab sellest, kui ajalugu hoitakse seni, kuni M ja N on samad. Kui neid muudetakse, võid alustada algseisust (ehk siis ajalugu puudub).
		+
		+	AI näide tikumängule:
		+
		+	* Oletame, et AI-l on iga laual oleva tiku jaoks kott ja selle sees on esialgu 3 (M=3 korral) nummerdatud (1..3) kuuli.
		+	* Igal arvuti käigul võtab arvuti vastavalt seisule õigest kotist (mis viimase laualoleva tiku kohta käib) suvalise kuuli ning "paigutab" selle koti kõrvale. Seejärel enda käiguna eemaldab arvuti laualt niimitu tikku, kui kuulil kirjas oli.
		+	* Kui arvuti võidab selliselt oma käike valides, siis paneb ta igasse kotti kaks samasugust kuuli, mis sellest kotist välja sai võetud (mõlemal kuulil on sama arv). Kui arvuti kaotab, viskab ta kottide kõrval olevad kuulid minema juhul, kui kotis on sellise arvuga kuul (kotis peab alati olema vähemalt üks kuul igast arvust 1 - 3 (1 - M))
		+	* Mida rohkem mänge mängitakse, seda rohkem "hea valiku" kuule koguneb ning kotist suvalise kuuli võtmisel on tõenäolisem, et arvuti teeb häid käike.
		+
		+	<!--
		+	Näide:
		+
		+	Vaatame olukorda kus alguses on 10 tikku ja korraga võib võtta kuni 3 tikku. Koti sisud on järgmised:
		+	kott 1 2 3 4 5 6 7 8 9 10
		+	sisu 1,2,3 1,2,3 1,2,3 1,2,3 1,2,3 1,2,3 1,2,3 1,2,3 1,2,3 1,2,3
		+
		+	Mäng kulgeb järgmiselt:
		+	1. Mängija võtab 3 tikku, alles jääb 7 tikku.
		+	2. AI valib suvaliselt 2 kuuli kotist number 7. See tähendab, et AI võtab 2 tikku ja 5 tikku jääb järele.
		+	3. Mängija võtab 1 tiku ja järele jääb 4.
		+	4. AI valib suvaliselt kolmanda kuuli kotist 4. See tähenab, et võtab 3 tikku.
		+	5. Mängija peab võtma viimase tiku ja kaotab.
		+
		+	Nüüd AI jaoks on olukord selline:
		+	kott 1 2 3 4 5 6 7 8 9 10
		+	sisu 1,2,3 1,2,3 1,2,3 1,2 1,2,3 1,2,3 1,3 1,2,3 1,2,3 1,2,3
		+	valitud 3 2
		+
		+	Kuna AI võitis, siis paneb ta valitud kuulid kotti tagasi ning lisab uued samade väärtustega kuulid.
		+	kott 1 2 3 4 5 6 7 8 9 10
		+	sisu 1,2,3 1,2,3 1,2,3 1,2,3,3 1,2,3 1,2,3 1,2,2,3 1,2,3 1,2,3 1,2,3
		+
		+	Nüüd on AI-l suurem võimalus võtta 3 tikku juhul kui laual on 4 tikku järel ja 2 tikku kui on 7 tikku järel.
		+
		+	Sinu ülesandeks on kirjutada AI, mis uuendab kottide sisu iga mängu korral. Esialgu mängib AI suvaliselt, kuid mida mäng edasi, seda targemaid käike hakkab ta tegema.
		+
		+
		+	Järgnev näide demonstreerib kuidas programm peaks käituma:
		+
		+	1. mäng:
		+	10 tikku laual ja korraga saab võtta kuni 3 tikku.
		+
		+	Mängija võtab 3
		+	7tikku laual
		+	Arvuti võtab 2
		+	5 tikku laual
		+	Mängija võtab 3
		+	2 tikku laual
		+	Arvuti võtab 2ja kaotab
		+
		+	2.Mäng:
		+	10 tikku laual ja korraga saab võtta kuni 3 tikku.
		+
		+	Mängija võtab 1
		+	9 tikku laual
		+	Arvuti võtab 1
		+	8 tikku laual
		+	Mängija võtab 3
		+	5 tikku laual
		+	Arvuti võtab 3
		+	2 tikku laual
		+	Mängija võtab 2 ja kaotab
		+
		+	3.Mäng:
		+	10 tikku laual ja korraga saab võtta kuni 3 tikku.
		+
		+	Mängija võtab 3
		+	7 tikku laual
		+	Arvuti võtab 2
		+	5 tikku laual
		+	Mängija võtab 3
		+	2 tikku laual
		+	Arvuti võtab 2 ja kaotab
		+
		+
		+
		+
		+	-->

@@ 91. rida: / 91. rida: @@
 </source>
-== Lisaülesanne: dünaamilised parameetrid (3p) ==
+== Lisaülesanne: dünaamilised parameetrid (2p) ==
 Mängu alguses saab kasutaja määrata, mitu tikku on laual alguses (N) ja mis on maksimaalne käigu suurus (M).
@@ 100. rida: / 100. rida: @@
-== Lisaülesanne: võidukäik (1-2p) ==
+== Lisaülesanne: võidukäik (1p) ==
 Arvuti peab oma käigu ajal tegema optimaalse (võimaluse korral võidu-) käigu. Vt kirjeldust eespoolt [[#Kuidas tikumängus võita]].
 Kui realiseeritud on vaid põhiosa, saab selle lisaülesande lahendamise eest 1p. Kui realiseeritud on lisaosa dünaamiliste parameetrite kohta, saab selle ülesande eest 2p.