Finished exercise 7

src/main/kotlin/exercise2/task1/FindPairOfHighestSum.kt

@@ -18,7 +18,10 @@ import org.jetbrains.exercise2.task3.findPairWithBiggestDifference
  */
 
 internal fun List<Int>.findHighestSumPair(): Pair<Int, Int> {
-    TODO("Implement me!!")
+    val prvi = this.sorted().get(this.lastIndex)
+    val drugi = this.sorted().get(this.lastIndex-1)
+
+    return Pair(prvi, drugi)
 }
 
 fun main() {

src/main/kotlin/exercise2/task2/FindPairOfHighestSumFunctional.kt

@@ -20,7 +20,9 @@ import org.jetbrains.exercise2.task3.findPairWithBiggestDifference
  */
 
 internal fun List<Int>.findHighestSumPairFunctional(): Pair<Int, Int> {
-    TODO("Implement me!!")
+    return Pair(
+        this.sorted().get(this.lastIndex), this.sorted().get(this.lastIndex-1)
+    )
 }
 
 fun main() {

src/main/kotlin/exercise2/task3/ConvertMethodToFunctionalApproach.kt

@@ -17,24 +17,29 @@ import kotlin.math.abs
  */
 
 internal fun List<Int>.findPairWithBiggestDifference(): Pair<Int, Int> {
-    // TODO refactor me to functional approach and make tests pass!!!
-    var resultPair: Pair<Int, Int>? = null
-    var biggestDifference = Int.MIN_VALUE
-
-    for (i in this.indices) {
-        for (j in (i + 1) until this.size) {
-            val first = this[i]
-            val second = this[j]
-            val absDifference = abs(first - second)
-
-            if (absDifference >= biggestDifference) {
-                biggestDifference = absDifference
-                resultPair = Pair(first, second)
-            }
-        }
-    }
 
-    return resultPair!!
+    return Pair(
+        this.sorted().get(this.size-1), this.sorted().get(0)
+    )
+
+
+//    var resultPair: Pair<Int, Int>? = null
+//    var biggestDifference = Int.MIN_VALUE
+//
+//    for (i in this.indices) {
+//        for (j in (i + 1) until this.size) {
+//            val first = this[i]
+//            val second = this[j]
+//            val absDifference = abs(first - second)
+//
+//            if (absDifference >= biggestDifference) {
+//                biggestDifference = absDifference
+//                resultPair = Pair(first, second)
+//            }
+//        }
+//    }
+//
+//    return resultPair!!
 }
 
 fun main() {

src/main/kotlin/exercise2/task4/ProcessCountriesData.kt

@@ -59,27 +59,31 @@ internal val countries = listOf(
  */
 
 internal fun List<Country>.findCountryWithBiggestTotalArea(): Country {
-    TODO("Implement me!!!")
+    return countries.maxBy { it.totalAreaInSquareKilometers }
 }
 
 internal fun List<Country>.findCountryWithBiggestPopulation(): Country {
-    TODO("Implement me!!!")
+   return countries.maxBy { it.population }
 }
 
 internal fun List<Country>.findCountryWithHighestPopulationDensity(): Country {
-    TODO("Implement me!!!")
+    return countries.maxBy { it.population/it.totalAreaInSquareKilometers }
 }
 
 internal fun List<Country>.findCountryWithLowestPopulationDensity(): Country {
-    TODO("Implement me!!!")
+    return countries.minBy { it.population/it.totalAreaInSquareKilometers }
 }
 
 internal fun List<Country>.findLanguageSpokenInMostCountries(): String {
-    TODO("Implement me!!!")
+    return countries.flatMap { it.languages }
+        .groupingBy { it }
+        .eachCount()
+        .maxBy { it.value }
+        .key
 }
 
 internal fun List<Country>.filterCountriesThatSpeakLanguage(language: String): List<Country> {
-    TODO("Implement me!!!")
+    return countries.filter { country -> country.languages.contains(language) }
 }
 
 
@@ -88,7 +92,7 @@ fun main() {
     println("Country with a biggest population is a ${countries.findCountryWithBiggestPopulation().name}")
     println("Country with a biggest population density is a ${countries.findCountryWithHighestPopulationDensity().name}")
     println("Country with a lowest population density is a ${countries.findCountryWithLowestPopulationDensity().name}")
-    println("Language spoken in most countries is a ${countries.findLanguageSpokenInMostCountries()}")
+    println("Language spoken in most countries is ${countries.findLanguageSpokenInMostCountries()}")
     val countriesThatSpeakEnglish = countries.filterCountriesThatSpeakLanguage("English")
     println("Countries that speak English language are ${countriesThatSpeakEnglish.joinToString { it.name }}")
 }

src/main/kotlin/exercise2/task5/CreateUserDSL.kt

@@ -49,11 +49,15 @@ internal data class Address(
  */
 
 internal fun user(initUser: User.() -> Unit): User {
-    TODO("Implement me!!!")
+    val user = User()
+    return user.apply(initUser)
 }
 
-internal fun User.address(initAddress: Address.() -> Unit): User {
-    TODO("Implement me!!!")
+internal fun User.address   (initAddress: Address.() -> Unit): User {
+    val adr = Address()
+    adr.initAddress()
+    this.address = adr
+    return this
 }
 
 fun main() {

src/main/kotlin/exercise3/task1/BalancedBrackets.kt

@@ -1,4 +1,5 @@
 package exercise3.task1
+import java.util.Stack
 
 /**
  * Task1: Balanced Brackets (Parentheses) Problem
@@ -26,9 +27,32 @@ package exercise3.task1
 
 
 internal fun isExpressionBalanced(expression: String): Boolean {
-    TODO("Implement me!!!")
+    val chars = Stack<Char>()
+    val opening = "({["
+    val closing = ")}]"
+
+    for(char in expression) {
+        when {
+           char in opening -> chars.add(char)
+           char in closing -> {
+               if(chars.isEmpty() || !valid(chars.lastElement(), char)) {
+                   return false
+               }
+               chars.removeLast()
+           }
+        }
+    }
+    return chars.isEmpty()
 }
 
+fun valid(opening: Char, closing: Char): Boolean {
+    return (opening == '(' && closing == ')') ||
+            (opening == '[' && closing == ']') ||
+            (opening == '{' && closing == '}')
+}
+
+
+
 fun main() {
     val expressions = listOf(
         "{[()]}" to true,

src/main/kotlin/exercise3/task2/ParenthesesClusters.kt

@@ -24,7 +24,45 @@ package exercise3.task2
  */
 
 internal fun String.splitToBracketsClusters(): List<String> {
-    TODO("Implement me!!!")
+    val opening = "({["
+    val closing = ")}]"
+    val clusterList = ArrayList<String>()
+    val emptyList = ArrayList<String>()
+
+    var start = 0
+    var counter = 0
+    var balanced = true
+
+    for(i in this.indices) {
+        when (this[i]) {
+            '(' -> {
+                counter++
+                if (counter == 1) {
+                    start = i
+                }
+            }
+
+            ')' -> {
+                counter--
+                if (counter == 0) {
+                    clusterList.add(this.substring(start, i + 1))
+                } else if (counter < 0) {
+                    balanced = false
+                }
+            }
+        }
+    }
+
+    if(counter != 0) {
+        balanced = false
+    }
+
+    if(balanced) {
+        return clusterList
+    }
+    else {
+        return emptyList
+    }
 }
 
 fun main() {

src/main/kotlin/exercise3/task3/SherlockValidatesString.kt

@@ -29,7 +29,24 @@ package exercise3.task3
  */
 
 internal fun isSherlockValid(s: String): String {
-    TODO("Implement me!!!")
+    val charCounts = s.groupBy { it }.values.map { it.size }
+
+    if (charCounts.toSet().size == 1) {
+        return "YES"
+    }
+
+    if (charCounts.toSet().size == 2) {
+        val minFreq = charCounts.minOrNull() ?: return "NO"
+        val maxFreq = charCounts.maxOrNull() ?: return "NO"
+        val minFreqCounter = charCounts.count { it == minFreq }
+        val maxFreqCounter = charCounts.count { it == maxFreq }
+
+        if ((minFreq == 1 && minFreqCounter == 1) || (maxFreq - minFreq == 1 && maxFreqCounter == 1)) {
+            return "YES"
+        }
+    }
+
+    return "NO"
 }
 
 fun main() {

src/main/kotlin/exercise3/task4/TaxiParkTask.kt

@@ -10,29 +10,44 @@ package exercise3.task4
  * Find all the drivers who performed no trips.
  */
 internal fun TaxiPark.findFakeDrivers(): Set<Driver> {
-    TODO("Implement me!!!")
+    return allDrivers.minus(this.trips.map { it.driver }.toSet())
 }
 
-/**
+    /**
  * Subtask 2:
  * Find all the clients who completed at least the given number of trips.
  */
 internal fun TaxiPark.findFaithfulPassengers(minTrips: Int): Set<Passenger> {
-    TODO("Implement me!!!")
+    return this.trips
+        .flatMap { it.passengers }
+        .groupingBy { it }
+        .eachCount()
+        .filter { it.value >= minTrips }
+        .keys
 }
 
 /**
  * Subtask 3:
  * Find all the passengers, who were taken by a given driver more than once.
  */
 internal fun TaxiPark.findFrequentPassengers(driver: Driver): Set<Passenger> {
-    TODO("Implement me!!!")
+    return this.trips
+        .filter { it.driver == driver }
+        .flatMap { it.passengers }
+        .groupingBy { it }
+        .eachCount()
+        .filter { it.value > 1}
+        .keys
 }
 
 /**
  * Subtask 4:
  * Find the passengers who had a discount for the majority of their trips.
  */
 internal fun TaxiPark.findSmartPassengers(): Set<Passenger> {
-    TODO("Implement me!!!")
+    return allPassengers.filter { passenger ->
+        val eachPassengerTrips = trips.filter { it.passengers.contains(passenger) }
+        val discountedTripsCount = eachPassengerTrips.count { it.discount != null }
+        discountedTripsCount > eachPassengerTrips.size / 2
+    }.toSet()
 }