Partial solution for Exercise 3

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

@@ -18,7 +18,24 @@ import org.jetbrains.exercise2.task3.findPairWithBiggestDifference
  */
 
 internal fun List<Int>.findHighestSumPair(): Pair<Int, Int> {
-    TODO("Implement me!!")
+    var firstMaximal = this[0]
+    var maximalIndex = -1
+
+    for((index, num) in this.withIndex()) {
+        if(num > firstMaximal) {
+            firstMaximal = num
+            maximalIndex = index
+        }
+    }
+
+    var secondMaximal = this[0]
+    for((index, num) in this.withIndex()) {
+        if(num in (secondMaximal + 1)..firstMaximal && index != maximalIndex) {
+            secondMaximal = num
+        }
+    }
+
+    return firstMaximal to secondMaximal
 }
 
 fun main() {

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

@@ -20,7 +20,7 @@ import org.jetbrains.exercise2.task3.findPairWithBiggestDifference
  */
 
 internal fun List<Int>.findHighestSumPairFunctional(): Pair<Int, Int> {
-    TODO("Implement me!!")
+    return this.sortedDescending().let { it.first() to it[1] }
 }
 
 fun main() {

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

@@ -17,8 +17,8 @@ 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
+    return this.sorted().let { it.first() to it.last() }
+    /*var resultPair: Pair<Int, Int>? = null
     var biggestDifference = Int.MIN_VALUE
 
     for (i in this.indices) {
@@ -34,7 +34,7 @@ internal fun List<Int>.findPairWithBiggestDifference(): Pair<Int, Int> {
         }
     }
 
-    return resultPair!!
+    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 this.maxBy { it.totalAreaInSquareKilometers }
 }
 
 internal fun List<Country>.findCountryWithBiggestPopulation(): Country {
-    TODO("Implement me!!!")
+    return this.maxBy { it.population }
 }
 
 internal fun List<Country>.findCountryWithHighestPopulationDensity(): Country {
-    TODO("Implement me!!!")
+    return this.maxBy { it.population/it.totalAreaInSquareKilometers }
 }
 
 internal fun List<Country>.findCountryWithLowestPopulationDensity(): Country {
-    TODO("Implement me!!!")
+    return this.minBy { it.population / it.totalAreaInSquareKilometers }
 }
 
 internal fun List<Country>.findLanguageSpokenInMostCountries(): String {
-    TODO("Implement me!!!")
+    return this.flatMap { it.languages }
+        .groupingBy { it }
+        .eachCount()
+        .maxBy { it.value }
+        .key
 }
 
 internal fun List<Country>.filterCountriesThatSpeakLanguage(language: String): List<Country> {
-    TODO("Implement me!!!")
+    return this.filter { it.languages.contains(language) }
 }
 
 

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

@@ -26,7 +26,25 @@ package exercise3.task1
 
 
 internal fun isExpressionBalanced(expression: String): Boolean {
-    TODO("Implement me!!!")
+    val stack = mutableListOf<Char>()
+
+    for (char in expression) {
+        when (char) {
+            '(', '{', '[' -> stack.add(char)
+            ')', '}', ']' -> {
+                if (stack.isEmpty()) return false
+                val last = stack.removeAt(stack.size - 1)
+                if ((char == ')' && last != '(') ||
+                    (char == '}' && last != '{') ||
+                    (char == ']' && last != '[')
+                ) {
+                    return false
+                }
+            }
+        }
+    }
+
+    return stack.isEmpty()
 }
 
 fun main() {

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

@@ -24,9 +24,39 @@ package exercise3.task2
  */
 
 internal fun String.splitToBracketsClusters(): List<String> {
-    TODO("Implement me!!!")
+    val stack = mutableListOf<Char>()
+    val clusters = mutableListOf<String>()
+    var currentCluster = ""
+
+    for (char in this) {
+        when (char) {
+            '(' -> {
+                stack.add(char)
+                currentCluster += char
+            }
+            ')' -> {
+                if (stack.isEmpty())
+                    return emptyList()
+                val last = stack.removeAt(stack.size - 1)
+                if (last == '(')
+                    currentCluster += char
+                else
+                    return emptyList()
+                if (stack.isEmpty()) {
+                    clusters.add(currentCluster)
+                    currentCluster = ""
+                }
+            }
+        }
+    }
+    if (stack.isNotEmpty())
+        return emptyList()
+
+    return clusters
+
 }
 
+
 fun main() {
     val expressionsToClustersCatalog = mapOf(
         "()()()" to listOf("()", "()", "()"),

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

@@ -10,29 +10,56 @@ package exercise3.task4
  * Find all the drivers who performed no trips.
  */
 internal fun TaxiPark.findFakeDrivers(): Set<Driver> {
-    TODO("Implement me!!!")
+    return allDrivers.filter { driver -> trips.none { it.driver == 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!!!")
-}
+    val passengerTripsCount = trips
+        .flatMap { it.passengers }
+        .groupingBy { it }
+        .eachCount()
+
+    return passengerTripsCount
+        .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!!!")
+    val frequentPassengers = trips
+        .filter { it.driver == driver }
+        .flatMap { it.passengers }
+        .groupingBy { it }
+        .eachCount()
+        .filter { it.value > 1 }
+
+    return frequentPassengers.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!!!")
+    val passengerDiscountTripsCount = trips
+        .flatMap { trip ->
+            trip.passengers.map { passenger ->
+                passenger to (if (trip.discount != null && trip.discount > 0) 1 else 0)
+            }
+        }
+        .groupBy({ it.first }, { it.second })
+        .mapValues { (_, discounts) -> discounts.sum() }
+
+    return passengerDiscountTripsCount
+        .filter { (_, discounts) ->
+            discounts >= trips.size / 2
+        }
+        .keys
 }