Solutions for exercises No.3

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

@@ -1,5 +1,7 @@
 package exercise3.task1
 
+import java.util.*
+
 /**
  * Task1: Balanced Brackets (Parentheses) Problem
  *
@@ -24,9 +26,21 @@ package exercise3.task1
  *
  */
 
+val brackets: Map<Char, Char> = mapOf(']' to '[', '}' to '{', ')' to '(')
 
-internal fun isExpressionBalanced(expression: String): Boolean {
-    TODO("Implement me!!!")
+fun isExpressionBalanced(expression: String): Boolean {
+    val stack = LinkedList<Char>()
+    expression.forEach {
+        when (it) {
+            in brackets.values -> stack.push(it)
+            in brackets.keys -> {
+                if (stack.isEmpty() || brackets[it] != stack.pop()) {
+                    return false
+                }
+            }
+        }
+    }
+    return stack.isEmpty()
 }
 
 fun main() {

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

@@ -1,5 +1,8 @@
 package exercise3.task2
 
+import exercise3.task1.brackets
+import java.util.*
+
 /**
  * Task 2: Split Expression To Parentheses Clusters
  *
@@ -24,7 +27,27 @@ package exercise3.task2
  */
 
 internal fun String.splitToBracketsClusters(): List<String> {
-    TODO("Implement me!!!")
+    val stack = LinkedList<Char>()
+    val returnListOfBrackets = mutableListOf<String>()
+
+    var currBalancedBrackets = ""
+    this.forEach {
+        currBalancedBrackets += it
+        when (it) {
+            in brackets.values -> stack.push(it)
+            in brackets.keys -> {
+                if (stack.isEmpty() || brackets[it] != stack.pop()) {
+                    return listOf()
+                }
+            }
+        }
+        if (stack.isEmpty()) {
+            returnListOfBrackets.add(currBalancedBrackets)
+            currBalancedBrackets = ""
+        }
+    }
+    if (!stack.isEmpty()) return listOf()
+    return returnListOfBrackets
 }
 
 fun main() {

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

@@ -29,7 +29,16 @@ package exercise3.task3
  */
 
 internal fun isSherlockValid(s: String): String {
-    TODO("Implement me!!!")
+    val freqOfFreqMap: Map<Int, Int> = s.groupingBy { it }.eachCount().values.groupingBy { it }.eachCount()
+
+    return when (freqOfFreqMap.size) {
+        2 -> {
+            val (minFrequency, maxFrequency) = freqOfFreqMap.keys.sorted()
+            if ((freqOfFreqMap[minFrequency] == 1 && minFrequency == 1) || (freqOfFreqMap[maxFrequency] == 1 && maxFrequency - minFrequency == 1)) "YES" else "NO"
+        }
+        1 -> "YES"
+        else -> "NO"
+    }
 }
 
 fun main() {
@@ -40,8 +49,11 @@ fun main() {
         val errorMessageFactory = { answer: String -> if (answer == "YES") "is valid" else "is not valid" }
 
         require(expectedIsValid == actualIsValid) {
-            "String \"$string\" is ${errorMessageFactory(expectedIsValid)}," +
-                    " but actual value was ${errorMessageFactory(actualIsValid)}."
+            "String \"$string\" is ${errorMessageFactory(expectedIsValid)}," + " but actual value was ${
+                errorMessageFactory(
+                    actualIsValid
+                )
+            }."
         }
     }
 }

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

@@ -10,29 +10,49 @@ package exercise3.task4
  * Find all the drivers who performed no trips.
  */
 internal fun TaxiPark.findFakeDrivers(): Set<Driver> {
-    TODO("Implement me!!!")
+    return this.allDrivers.minus(this.trips.map { it.driver }
+        .intersect(this.allDrivers))
 }
 
 /**
  * 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!!!")
+    println(this.trips.flatMap { it.passengers }
+        .groupingBy { it }
+        .eachCount())
+
+    return this.trips.flatMap { it.passengers }
+        .groupingBy { it }
+        .eachCount()
+        .filter { it.value >= minTrips }
+        .map { it.key }
+        .toSet()
 }
 
 /**
  * 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 }
+        .map { it.key }
+        .toSet()
 }
 
 /**
  * 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 this.trips
+        .filter { it.discount != null }
+        .flatMap { it.passengers }
+        .toSet()
 }