/* Author: LukArToDo Created: 21.june 2018 Bugs: unknown Description: The code simulate the World Cup and predict the winner! Simulate the competition multiple times (100 times) and predict the winner based on the outcome. Note: The code consider multiple factors when predicting the outcome of a match (e.g.: the rank of the teams, the group they play in, etc.). For example: In the group stage, the two top ranked teams have a combined 62% chance of going through the group. In a knockout stage, a better ranked team has a 4% higher chances of winning. Let's enjoy the exciting matches, and the winner of the World Cup all the congratulations! 🏆🏅️🎉🎉🎆 👉 IMPORTANT: Kotlin's compiler on SL has a bug, so it often gives output: "Compilation error" or "No output". Please ignore that and hit RUN again...and again... Thank you 😊 */ import java.util.TreeMap val ranking=mapOf( "Argentina" to 5, "Australia" to 36, "Belgium" to 3, "Brazil" to 2, "Colombia" to 16, "Costa_Rica" to 23, "Croatia" to 20, "Denmark" to 12, "Egypt" to 45, "England" to 12, "France" to 7, "Germany" to 1, "Iceland" to 22, "Iran" to 37, "Japan" to 61, "Korea_Republic" to 57, "Mexico" to 15, "Morocco" to 41, "Nigeria" to 48, "Panama" to 55, "Peru" to 11, "Poland" to 8, "Portugal" to 4, "Russia" to (70-21), // correction of 30% due to the advantage of the domestic field "Saudi_Arabia" to 67, "Senegal" to 27, "Serbia" to 34, "Spain" to 10, "Sweden" to 24, "Switzerland" to 6, "Tunisia" to 21, "Uruguay" to 14) val groups = mapOf( "A" to listOf( "Egypt", "Russia", "Saudi_Arabia", "Uruguay" ), "B" to listOf( "Iran", "Morocco", "Portugal", "Spain" ), "C" to listOf( "Australia", "Denmark", "France", "Peru" ), "D" to listOf( "Argentina", "Croatia", "Iceland", "Nigeria" ), "E" to listOf( "Brazil", "Costa_Rica", "Serbia", "Switzerland" ), "F" to listOf( "Germany", "Korea_Republic", "Mexico", "Sweden" ), "G" to listOf( "Belgium", "England", "Panama", "Tunisia" ), "H" to listOf( "Colombia", "Japan", "Poland", "Senegal" ) ) // define the map "winners16" to store winners of groups. The key will be group and position in group (f.e.: A1), and value will be name of the team val winners16 : MutableMap = mutableMapOf() // define the probabilities for teams to pass the group = 33,29,23 (best ranked team 33%, next team 29%, next team 23% and last team 100-33-29-23 = 15%) var chance = listOf(33,29,23) // the driver fun main(FifaWC2018: Array) { val l="\n"+"*".repeat(25)+"\n" println("Winners by groups:") for((k,v) in groups){ println("\nGroup $k :") // pass the list of group members (v) and name of group (k) to the function "groupPass" to get the winners of the group groupPass(v!!,k) } // redefine the probabilities for teams to win in the match in knockout stage = 52,48 (best ranked team 52%, second team 48%) chance=listOf(52,48,0) // define the list "winners8" to store the winners of knockout stage 1/16 final val winners8= mutableListOf () println("\n${l}1/8 final:${l}") // take the teams from the map "winners16" (the winners of group stage) using key: A1 and B2, A2 and B1, C1 and D2, C2 and D1, etc..., and pass the pairs (names of teams) to the function "knockoutRank" to get the winner which will be stored to list "winners8" // Note: (65).toChar()='A', (66).toChar()='B', (67).toChar()='C', etc. for(i in 0 until 8 step 2){ winners8.add(knockoutRank (winners16[(65+i).toChar()+"1"]!!, winners16[(66+i).toChar()+"2"]!!)) winners8.add(knockoutRank (winners16[(65+i).toChar()+"2"]!!, winners16[(66+i).toChar()+"1"]!!)) } println("\n${l}1/4 final:${l}") // define the list "winners4" to store the winners of knockout stage 1/8 final val winners4=mutableListOf () // need to get pairs for 1/4 final according given schedule // to list "winners8" the winners stored in next order: winner1(of A1:B2), winner2(of A2:B1), winner3(of C1:D2), etc. So, for 1/4 final we need arrange next pairs from the list "winners8": winner1:winner3, winner5:winner7, winner2:winner4, winner6:winner8 // above pairs need to pass to the function "knockoutRank" to get the winner which will be stored to the list "winners4" for(i in 0 until winners8.size step 4) winners4.add(knockoutRank (winners8[i],winners8[i+2])) for(i in 1 until winners8.size step 4) winners4.add(knockoutRank (winners8[i],winners8[i+2])) println("\n${l}1/2 final:${l}") // define sf1 and sf2 as winners of 1/2 finals val(sf1,sf2) =arrayOf(knockoutRank (winners4[0],winners4[1]),knockoutRank(winners4[2],winners4[3])) println("\n\n${l}Third place:${l}") // after removing the finalist from the list "winners4", in the list remain teams for 3'rd place match winners4.removeAll(listOf(sf1, sf2)) knockoutRank(winners4[0],winners4 [1]) // finally, we have match for the champion of World Cup 2018 println("\n\n${l}FINAL:${l}") val CHAMPION= knockoutRank(sf1, sf2) println("\n\nThe winner of the WorldCup2018 is: ${CHAMPION. toUpperCase()}") } //accepts group members and name of group, calculate random winners (1.and 2.place) after 100 simulations and store the winners to map "winners16" fun groupPass(list: List, group:String){ // sorts the group members by ascending order according they ranking on Fifa list val sortedGroup = TreeMap(list. map { ranking[it] to it}.toMap()) // define the map "winners" to store results of 100 simulations (key=team, value=result of simulations) val winners : MutableMap = mutableMapOf() // pass the keys(rankings of group members) to function "random" and store the result of "random" function (key of winner) of each simulation. After simulations, group all results by key(ranking) and store the results to map "winners" (1..100).map{random(sortedGroup. keys.toList())}.groupBy{ it }.toMap ().forEach { (k,v) -> winners.put (sortedGroup[k],v.size) } // extract results of simulations from map "winners" and store to list "result" val result=winners.values. toList() // define and initialize "w1" and "w2" - winners of group (name of team) var (w1,w2)=arrayOf("","") //go trough map "winners" to find winners: for((k,v) in winners){ // if results "v" from map suits to second largest results of simulations we have "w2" - second place in group (sorted list "results" give the largest result as last element of list, and second largest result as element before last in the list) if(v==result.sorted()[result. size-2]&&w2=="") w2=k!! // if results "v" from map suits to largest results of simulations we have "w1" - first place in group if(v==result.sorted()[result. size-1]&&w2!=k!!) w1=k!! } // display the winners of group println("1.$w1 \n2.$w2") //store the winners of group winners16.put("${group}1",w1) winners16.put("${group}2", w2) } // accepts the teams from knockout stage // pass the teams to the function "knockout" according they ranks on the Fifa list: first argument=higher rank, second argument=lower rank (for example, if two team have ranks 14 and 7, firs arg=7, second arg=14) // returns the winner of the match fun knockoutRank(w1:String, w2: String) :String { if(ranking[w1]!!>ranking[w2]!!) return knockout (w2,w1) return knockout(w1,w2) } // accepts two teams in order according they ranks on the Fifa list, calculate random winner after 100 simulations, display and returns the winner of the match fun knockout(w1:String,w2:String): String{ // define the map "winners" to store results of 100 simulations (key=team, value=result of simulations) val winners : MutableMap =mutableMapOf() // pass the keys(1 for team "w1", 2 for team "w2" and 0 for next two arguments which have no any influence on final result) to function "random" and store the result of "random" function (key of winner: 1 or 2) of each simulation. After simulations, group all results by key(1 and 2) and store the results to map "winners" (1..100).map{random(listOf(1,2, 0,0))}.groupBy{ it }.toMap().forEach {(k,v) -> if(k==1) winners.put(w1, v.size) else if(k==2) winners.put(w2, v.size)} // the winner "ww" of the mach is team with higher score after 100 simulations val ww= if(winners[w1]!!>winners [w2]!!) w1 else w2 // display the winner of the match println("$w1 : $w2 -> $ww") // return the winner of the match return ww } // accepts list of ranks of teams and return the rank of random winner fun random(forRand: List):Int{ // the ranks of teams in order: from the highest to the lower (f.e.: 14,45,67,70 or for knockout stage: 1,2,0,0) val (x1,x2,x3,x4) = forRand // according to some research, the probabilities of passing a group of top16 teams are 62% and even 70%. I this code, for the group stage are defined the following probabilities for teams to pass the group=33,29,23 (best ranked team 33%, next team 29%, next team 23% and last team 100-33-29-23=15%) // for the knockout stage are defined the following probabilities: 52% for best ranked team, 48% for second team // so variable px1,px2,px3 takes the value of probabilities in given order val (px1,px2,px3) = chance val r = rand(100) // if the random number between 1 and px1 the winner is team x1 if (r <= px1) return x1!! // if the random number between px1 and px1+px2 the winner is team x2 if (r <= px1 + px2) return x2!! // if the random number between px1+px2 and px1+px2+px3 the winner is team x3 if(r<= px1+px2+px3) return x3!! // if the random number between px1+px2+px3 and 100 the winner is team x4 else return x4!! } // returns random number in range [1-100] fun rand(max: Int) = (Math.random()* max+1).toInt()

FIFA World Cup 2018 - simulator