{"id":394108,"date":"2024-06-29T11:24:38","date_gmt":"2024-06-29T11:24:38","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=394108"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-29T21:00:00","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=394108","title":{"rendered":"Solving coding problems with Kotlin: Collection functions<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n
<\/figcaption><\/figure>\n

(originally published on Medium<\/a>)<\/p>\n

I have talked to many Android developers, and most of them are excited about Kotlin. So am I. When I just started learning Kotlin, I was solving\u00a0Kotlin Koans<\/u><\/a>, and along with other great features, I was impressed with the power of functions for performing operations on collections. Since then, I spent three years writing Kotlin code but rarely utilised all the potential of the language.<\/p>\n

During this year, I did more than a hundred coding problems on Leetcode in Java. I didn\u2019t switch to Kotlin because I know the syntax of Java 6 so well, that I could effortlessly write code without autocompletion and syntax highlighting. But I didn\u2019t keep track of new Java features, as Android support of Java SDK lagged many versions behind. I didn\u2019t switch to Kotlin for solving problems right away. <\/p>\n

Although I was writing Kotlin code for several years, I felt that I need to make an extra cognitive effort to get the syntax and the language constructions right. Solving algorithmic problems, especially under the time pressure, is very different from Android app development. Still, the more I learned about Kotlin, the more I realised how many powerful features I\u2019m missing, and how much boilerplate code I need to write.<\/p>\n

One day, I have decided that I need to move on, so I started a new session in Leetcode and switched the compiler to Kotlin. I solved just a few easy problems, but I already feel that I have something to share.<\/p>\n

Loops<\/h3>\n

Let\u2019s start with loops. Let\u2019s say, you have an\u00a0IntArray<\/code>\u00a0of 10 elements\u00a00, 1, 2, 3, 4, 5, 6, 7, 8, 9<\/code>\u00a0and you want to print\u00a0123456789<\/code>.<\/p>\n

val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) for(index in (1 until array.size)) {   print(array[index]) }<\/code><\/pre>\n
(1 until array.size)<\/code>\u00a0is an\u00a0IntRange<\/code>, a class that represents a range of values of type\u00a0Int<\/code>. The first element in this range is\u00a01<\/code>\u00a0and the last one is\u00a09<\/code>\u00a0as we used\u00a0until<\/code>\u00a0to exclude the last value. We don\u2019t want to get\u00a0ArrayIndexOutOfBoundsException<\/code>\u00a0right?<\/p>\n
But what if we want to print all the elements of the array, except the element at index 5? Like this\u00a0012346789<\/code>. Let\u2019s get a bit more Kotliney then writing an\u00a0if<\/code>\u00a0statement in the loop.<\/p>\n
val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) for(index in array.indices - 5) {   print(array[index]) }<\/code><\/pre>\n
array.indices<\/code>\u00a0returns the range of valid indices for the array. In this case\u00a0array.indices<\/code>\u00a0represent\u00a0IntRange<\/code>\u00a0of\u00a0(0..9)<\/code>. Making\u00a0(0..9) - 5<\/code>\u00a0will result in\u00a0[0, 1, 2, 3, 4, 6, 7, 8, 9]<\/code>. This is exactly what we need.<\/p>\n
Kotlin also provides an ability to iterate from the greater number down to the smaller number using\u00a0downTo<\/code>. The iteration step size can also be changed using\u00a0step<\/code>.<\/p>\n
val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) for(index in array.size - 1 downTo 1 step 2) {   print(array[index]) }<\/code><\/pre>\n
The code above with result in\u00a097531<\/code>.<\/p>\n
Remove Vowels from a String<\/h3>\n
It\u2019s a problem number\u00a01119<\/u><\/a>\u00a0on Leetcode.<\/p>\n
\n
Given a string\u00a0<\/em>S<\/code>, remove the vowels\u00a0<\/em>'a'<\/code>,\u00a0<\/em>'e'<\/code>,\u00a0<\/em>'i'<\/code>,\u00a0<\/em>'o'<\/code>, and\u00a0<\/em>'u'<\/code>\u00a0from it, and return the new string.<\/em><\/p>\n<\/blockquote>\n
Even in Java there is a 1 line regex solution, but my intuition was the following:<\/p>\n
    \n
  1. \n
    Create a StringBuilder.<\/p>\n<\/li>\n
  2. \n
    Iterate over characters, and if the current character is not a vowel, append it to the StringBuilder.<\/p>\n<\/li>\n
  3. \n
    Return String from the StringBuilder.<\/p>\n<\/li>\n<\/ol>\n
    public String removeVowels(String S) {   StringBuilder sb = new StringBuilder();     for(char s: S.toCharArray()) {     if(s != 'a' && s != 'e' && s != 'i' && s !='o' && s != 'u') {       sb.append(s);       }   }   return sb.toString(); }<\/code><\/pre>\n
    What about Kotlin? More idiomatic way is to use\u00a0filter()<\/code>\u00a0or\u00a0filterNot()<\/code>.<\/p>\n
    fun removeVowels(S: String): String {   val vowels = setOf('a', 'e', 'i', 'o', 'u')   return S.filter { it !in vowels } }<\/code><\/pre>\n
    filter {predicate: (Char) -> Boolean}<\/code>\u00a0returns a string containing only those characters from the original string that match the given predicate.<\/p>\n
    But instead of inverting\u00a0!in<\/code>\u00a0let\u2019s use\u00a0filterNot()<\/code><\/p>\n
    fun removeVowels(S: String): String {   val vowels = setOf('a', 'e', 'i', 'o', 'u')   return S.filterNot { it in vowels } }<\/code><\/pre>\n
    That was simple even for a beginner. Let\u2019s move on to something a bit more sophisticated.<\/p>\n
    Running Sum of 1d Array<\/h3>\n
    It\u2019s another easy problem from Leetcode. Number\u00a01480<\/u><\/a>.<\/p>\n
    \n
    Given an array\u00a0nums<\/code>. We define a running sum of an array as\u00a0runningSum[i] = sum(nums[0]\u2026nums[i])<\/code>. Return the running sum of\u00a0nums<\/code>.<\/p>\n
    Input:<\/strong>\u00a0nums = [1,2,3,4]
    Output:<\/strong>\u00a0[1,3,6,10]
    Explanation:<\/strong>\u00a0Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].<\/p>\n<\/blockquote>\n
    So we need to iterate over the array, adding the value at the current index to the running sum, and put it to the same index in the result array.<\/p>\n
    Is there something in Kotlin to help us with the running sum? Well, there\u2019s different variations of\u00a0fold()<\/code>\u00a0and\u00a0reduce()<\/code>\u00a0operations. Here\u2019s\u00a0a good explanation<\/u><\/a>\u00a0of those functions. But since Kotlin 1.4 there\u2019s even more:\u00a0runningFold()<\/code>\u00a0and\u00a0runningReduce()<\/code>. As we want to start with the first element and return an array, it looks like\u00a0runningReduce()<\/code>\u00a0is what we need. Let\u2019s check it\u2019s signature.<\/p>\n
    \/**  * Returns a list containing successive accumulation values generated by applying [operation] from left to right  * to each element and current accumulator value that starts with the first element of this array.  *   * @param [operation] function that takes current accumulator value and an element, and calculates the next accumulator value.  *   * @sample samples.collections.Collections.Aggregates.runningReduce  *\/ @SinceKotlin(\"1.4\") @kotlin.internal.InlineOnly public inline fun IntArray.runningReduce(operation: (acc: Int, Int) -> Int): List<Int><\/code><\/pre>\n
    Sounds a bit too complex, but it will make sense when you\u2019ll see an example.<\/p>\n
    fun runningSum(nums: IntArray): IntArray {   return nums.runningReduce { sum, element -> sum + element }.toIntArray() }<\/code><\/pre>\n
    This is the whole solution to the running sum problem using Kotlin\u00a0runningReduce()<\/code>\u00a0function.\u00a0sum<\/code>\u00a0starts with the first element in the array,\u00a0element<\/code>\u00a0represens the current element. In lambda, we calculate the value of the next\u00a0sum<\/code>. Oh\u2026 I guess my explanation isn\u2019t making it more clear that a doc. Let\u2019s just print out the values of the\u00a0sum<\/code>\u00a0and the\u00a0element<\/code>\u00a0at each step:<\/p>\n
    sum: 1; element: 2; sum + element: 3sum: 3; element: 3; sum + element: 6sum: 6; element: 4; sum + element: 10sum: 10; element: 5; sum + element: 15<\/code><\/p>\n
    And the array we return is\u00a0[1, 3, 6, 10, 15]<\/code>. There is no\u00a0sum + element: 1<\/code>, I didn\u2019t miss the line. The thing is that\u00a0runningReduce<\/code>, as we see in the doc, takes the first value as the initial accumulator.<\/p>\n
    Unfortunately, Leetcode doesn\u2019t support Kotlin 1.4 yet, so the code above might not compile.<\/p>\n
    Most Common Word<\/h3>\n
    Easy Leetcode problem, number\u00a0819<\/u><\/a>.<\/p>\n
    \n
    Given a paragraph and a list of banned words, return the most frequent word that is not in the list of banned words. It is guaranteed there is at least one word that isn\u2019t banned, and that the answer is unique.<\/em><\/p>\n
    Input:<\/em><\/strong>
    paragraph = «Bob hit a ball, the hit BALL flew far after it was hit.»
    banned = [«hit»]
    <\/em>Output:<\/em><\/strong>\u00a0«ball»<\/em><\/p>\n<\/blockquote>\n
    What are the steps to solve it?<\/p>\n
      \n
    1. \n
      Convert string to lower case and split by words.<\/p>\n<\/li>\n<\/ol>\n
      [bob, hit, a, ball, the, hit, ball, flew, far, after, it, was, hit]<\/code><\/p>\n
      2. Create a set of banned words.<\/p>\n
      [hit]<\/code><\/p>\n
      3. Create a map of words to their occurrence, excluding the banned words.<\/p>\n
      {bob=1, a=1, ball=2, the=1, flew=1, far=1, after=1, it=1, was=1}<\/code><\/p>\n
      4. Return word with the highest number of occurrences from the map.<\/p>\n
      ball<\/code><\/p>\n
      Let\u2019s implement those 4 steps in Java.<\/p>\n
      public String mostCommonWord(String paragraph, String[] banned) {   \/\/ 1. Covert string to lower case and split by words.   String[] words = paragraph.replaceAll(\"[^a-zA-Z0-9 ]\", \" \").toLowerCase().split(\"\\\\s+\");    \/\/ 2. Create a set of banned words.   Set<String> bannedWords = new HashSet();   for (String word : banned)     bannedWords.add(word);    \/\/ 3. Create a map of words to their occurrence, excluding the banned words   Map<String, Integer> wordCount = new HashMap();   for (String word : words) {     if (!bannedWords.contains(word))       wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);   }    \/\/ 4. Return word with the highest number of occurrences from the map.   return Collections.max(wordCount.entrySet(), Map.Entry.comparingByValue()).getKey(); }<\/code><\/pre>\n
      And the same 4 steps in Kotlin.<\/p>\n
      fun mostCommonWord(paragraph: String, banned: Array<String>): String {   \/\/ 1. Covert string to lower case and split by words.   val words = paragraph.toLowerCase().split(\"\\\\W+|\\\\s+\".toRegex())   \/\/ 2. Create a set of banned words.   val bannedSet = banned.toHashSet()   \/\/ 3. Create a map of words to their occurrence, excluding the banned words   val wordToCount = words.filterNot { it in bannedSet }.groupingBy { it }.eachCount()   \/\/ 4. Return word with the highest number of occurrences from the map.   return wordToCount.maxBy { it.value }!!.key }<\/code><\/pre>\n
      Now let\u2019s go through the functions to see what is happening here.<\/p>\n
        \n
      1. \n
        We split the string into\u00a0words: List<String><\/code>. The type is inferred.<\/p>\n<\/li>\n
      2. \n
        Converting\u00a0banned: Array<String><\/code> to\u00a0HashSet<\/code>\u00a0to make\u00a0in<\/code>\u00a0checks in O(1) time<\/p>\n<\/li>\n
      3. \n
        In this step, we chain 3 function calls. First, we use\u00a0filterNot()<\/code>\u00a0to filter out banned words.\u00a0filterNot { it in banned }<\/code>\u00a0will return a\u00a0List<String><\/code>\u00a0that contains only those strings that are not in the\u00a0banned<\/code>\u00a0array. Unlike\u00a0groupBy()<\/code>\u00a0that returns a map,\u00a0groupingBy()<\/code>\u00a0returns an object of\u00a0Grouping<\/code>\u00a0type, that could be used later with one of group-and-fold operations. We use\u00a0it<\/code>\u00a0in\u00a0groupingBy()<\/code>\u00a0lambda. This means that we are grouping by the current element (word) in the collection. In other words \u2014 we create a map, where the key is a word, and the value is a count of occurrences of the word. To get the number of occurrences we use\u00a0eachCount()<\/code>\u00a0on the\u00a0Grouping.<\/code><\/p>\n<\/li>\n
      4. \n
        We use\u00a0maxBy<\/code>\u00a0function to get the first largest element in the map, by\u00a0value<\/code>. This returns us an object of\u00a0Map.Entry<String, Int>?<\/code>, e.g.\u00a0ball = 2<\/code>. And we return a key, which is the most common word in the sentence.<\/p>\n<\/li>\n<\/ol>\n
        Order of elements<\/h3>\n
        When you create a set setOf(\u201ca\u201d, \u201cb\u201d, \u201cc\u201d)<\/code>\u00a0or converting array to set using\u00a0arrayOf(\u201ca\u201d, \u201cb\u201d, \u201cc\u201d).toSet()<\/code>\u00a0the returned set is\u00a0LinkedHashSet<\/code>\u00a0and therefore element iteration order is preserved.<\/p>\n
        The same is true about maps<\/p>\n
        mapOf(Pair(\u201ca\u201d, 1), Pair(\u201cb\u201d, 2))<\/code><\/p>\n
        arrayOf<\/em>(Pair(\u201ca\u201d, 1), Pair(\u201cb\u201d, 2)).toMap()<\/code><\/p>\n
        Both functions will return an instance of\u00a0LinkedHashMap<\/code>\u00a0that keeps preserves the original element order. Knowing it might be helpful when solving problems.<\/p>\n
        I have covered just a few of all available collection functions in Kotlin. There\u2019s\u00a0map<\/code>,\u00a0flatMap<\/code>,\u00a0count<\/code>,\u00a0find<\/code>,\u00a0sum<\/code>\u00a0and much more!<\/p>\n<\/div>\n<\/div>\n<\/div>\n
        <\/div>\n

         \u0441\u0441\u044b\u043b\u043a\u0430 \u043d\u0430 \u043e\u0440\u0438\u0433\u0438\u043d\u0430\u043b \u0441\u0442\u0430\u0442\u044c\u0438  https:\/\/habr.com\/ru\/articles\/526384\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
        <\/div>\n
        \n
        \n
        \n
        \n
        <\/figcaption><\/figure>\n
        (originally published on Medium<\/a>)<\/p>\n
        I have talked to many Android developers, and most of them are excited about Kotlin. So am I. When I just started learning Kotlin, I was solving\u00a0Kotlin Koans<\/u><\/a>, and along with other great features, I was impressed with the power of functions for performing operations on collections. Since then, I spent three years writing Kotlin code but rarely utilised all the potential of the language.<\/p>\n
        During this year, I did more than a hundred coding problems on Leetcode in Java. I didn\u2019t switch to Kotlin because I know the syntax of Java 6 so well, that I could effortlessly write code without autocompletion and syntax highlighting. But I didn\u2019t keep track of new Java features, as Android support of Java SDK lagged many versions behind. I didn\u2019t switch to Kotlin for solving problems right away. <\/p>\n
        Although I was writing Kotlin code for several years, I felt that I need to make an extra cognitive effort to get the syntax and the language constructions right. Solving algorithmic problems, especially under the time pressure, is very different from Android app development. Still, the more I learned about Kotlin, the more I realised how many powerful features I\u2019m missing, and how much boilerplate code I need to write.<\/p>\n
        One day, I have decided that I need to move on, so I started a new session in Leetcode and switched the compiler to Kotlin. I solved just a few easy problems, but I already feel that I have something to share.<\/p>\n
        Loops<\/h3>\n
        Let\u2019s start with loops. Let\u2019s say, you have an\u00a0IntArray<\/code>\u00a0of 10 elements\u00a00, 1, 2, 3, 4, 5, 6, 7, 8, 9<\/code>\u00a0and you want to print\u00a0123456789<\/code>.<\/p>\n
        val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) for(index in (1 until array.size)) {   print(array[index]) }<\/code><\/pre>\n
        (1 until array.size)<\/code>\u00a0is an\u00a0IntRange<\/code>, a class that represents a range of values of type\u00a0Int<\/code>. The first element in this range is\u00a01<\/code>\u00a0and the last one is\u00a09<\/code>\u00a0as we used\u00a0until<\/code>\u00a0to exclude the last value. We don\u2019t want to get\u00a0ArrayIndexOutOfBoundsException<\/code>\u00a0right?<\/p>\n
        But what if we want to print all the elements of the array, except the element at index 5? Like this\u00a0012346789<\/code>. Let\u2019s get a bit more Kotliney then writing an\u00a0if<\/code>\u00a0statement in the loop.<\/p>\n
        val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) for(index in array.indices - 5) {   print(array[index]) }<\/code><\/pre>\n
        array.indices<\/code>\u00a0returns the range of valid indices for the array. In this case\u00a0array.indices<\/code>\u00a0represent\u00a0IntRange<\/code>\u00a0of\u00a0(0..9)<\/code>. Making\u00a0(0..9) - 5<\/code>\u00a0will result in\u00a0[0, 1, 2, 3, 4, 6, 7, 8, 9]<\/code>. This is exactly what we need.<\/p>\n
        Kotlin also provides an ability to iterate from the greater number down to the smaller number using\u00a0downTo<\/code>. The iteration step size can also be changed using\u00a0step<\/code>.<\/p>\n
        val array = intArrayOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9) for(index in array.size - 1 downTo 1 step 2) {   print(array[index]) }<\/code><\/pre>\n
        The code above with result in\u00a097531<\/code>.<\/p>\n
        Remove Vowels from a String<\/h3>\n
        It\u2019s a problem number\u00a01119<\/u><\/a>\u00a0on Leetcode.<\/p>\n
        \n
        Given a string\u00a0<\/em>S<\/code>, remove the vowels\u00a0<\/em>'a'<\/code>,\u00a0<\/em>'e'<\/code>,\u00a0<\/em>'i'<\/code>,\u00a0<\/em>'o'<\/code>, and\u00a0<\/em>'u'<\/code>\u00a0from it, and return the new string.<\/em><\/p>\n<\/blockquote>\n
        Even in Java there is a 1 line regex solution, but my intuition was the following:<\/p>\n
          \n
        1. \n
          Create a StringBuilder.<\/p>\n<\/li>\n
        2. \n
          Iterate over characters, and if the current character is not a vowel, append it to the StringBuilder.<\/p>\n<\/li>\n
        3. \n
          Return String from the StringBuilder.<\/p>\n<\/li>\n<\/ol>\n
          public String removeVowels(String S) {   StringBuilder sb = new StringBuilder();     for(char s: S.toCharArray()) {     if(s != 'a' && s != 'e' && s != 'i' && s !='o' && s != 'u') {       sb.append(s);       }   }   return sb.toString(); }<\/code><\/pre>\n
          What about Kotlin? More idiomatic way is to use\u00a0filter()<\/code>\u00a0or\u00a0filterNot()<\/code>.<\/p>\n
          fun removeVowels(S: String): String {   val vowels = setOf('a', 'e', 'i', 'o', 'u')   return S.filter { it !in vowels } }<\/code><\/pre>\n
          filter {predicate: (Char) -> Boolean}<\/code>\u00a0returns a string containing only those characters from the original string that match the given predicate.<\/p>\n
          But instead of inverting\u00a0!in<\/code>\u00a0let\u2019s use\u00a0filterNot()<\/code><\/p>\n
          fun removeVowels(S: String): String {   val vowels = setOf('a', 'e', 'i', 'o', 'u')   return S.filterNot { it in vowels } }<\/code><\/pre>\n
          That was simple even for a beginner. Let\u2019s move on to something a bit more sophisticated.<\/p>\n
          Running Sum of 1d Array<\/h3>\n
          It\u2019s another easy problem from Leetcode. Number\u00a01480<\/u><\/a>.<\/p>\n
          \n
          Given an array\u00a0nums<\/code>. We define a running sum of an array as\u00a0runningSum[i] = sum(nums[0]\u2026nums[i])<\/code>. Return the running sum of\u00a0nums<\/code>.<\/p>\n
          Input:<\/strong>\u00a0nums = [1,2,3,4]
          Output:<\/strong>\u00a0[1,3,6,10]
          Explanation:<\/strong>\u00a0Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].<\/p>\n<\/blockquote>\n
          So we need to iterate over the array, adding the value at the current index to the running sum, and put it to the same index in the result array.<\/p>\n
          Is there something in Kotlin to help us with the running sum? Well, there\u2019s different variations of\u00a0fold()<\/code>\u00a0and\u00a0reduce()<\/code>\u00a0operations. Here\u2019s\u00a0a good explanation<\/u><\/a>\u00a0of those functions. But since Kotlin 1.4 there\u2019s even more:\u00a0runningFold()<\/code>\u00a0and\u00a0runningReduce()<\/code>. As we want to start with the first element and return an array, it looks like\u00a0runningReduce()<\/code>\u00a0is what we need. Let\u2019s check it\u2019s signature.<\/p>\n
          \/**  * Returns a list containing successive accumulation values generated by applying [operation] from left to right  * to each element and current accumulator value that starts with the first element of this array.  *   * @param [operation] function that takes current accumulator value and an element, and calculates the next accumulator value.  *   * @sample samples.collections.Collections.Aggregates.runningReduce  *\/ @SinceKotlin(\"1.4\") @kotlin.internal.InlineOnly public inline fun IntArray.runningReduce(operation: (acc: Int, Int) -> Int): List<Int><\/code><\/pre>\n
          Sounds a bit too complex, but it will make sense when you\u2019ll see an example.<\/p>\n
          fun runningSum(nums: IntArray): IntArray {   return nums.runningReduce { sum, element -> sum + element }.toIntArray() }<\/code><\/pre>\n
          This is the whole solution to the running sum problem using Kotlin\u00a0runningReduce()<\/code>\u00a0function.\u00a0sum<\/code>\u00a0starts with the first element in the array,\u00a0element<\/code>\u00a0represens the current element. In lambda, we calculate the value of the next\u00a0sum<\/code>. Oh\u2026 I guess my explanation isn\u2019t making it more clear that a doc. Let\u2019s just print out the values of the\u00a0sum<\/code>\u00a0and the\u00a0element<\/code>\u00a0at each step:<\/p>\n
          sum: 1; element: 2; sum + element: 3sum: 3; element: 3; sum + element: 6sum: 6; element: 4; sum + element: 10sum: 10; element: 5; sum + element: 15<\/code><\/p>\n
          And the array we return is\u00a0[1, 3, 6, 10, 15]<\/code>. There is no\u00a0sum + element: 1<\/code>, I didn\u2019t miss the line. The thing is that\u00a0runningReduce<\/code>, as we see in the doc, takes the first value as the initial accumulator.<\/p>\n
          Unfortunately, Leetcode doesn\u2019t support Kotlin 1.4 yet, so the code above might not compile.<\/p>\n
          Most Common Word<\/h3>\n
          Easy Leetcode problem, number\u00a0819<\/u><\/a>.<\/p>\n
          \n
          Given a paragraph and a list of banned words, return the most frequent word that is not in the list of banned words. It is guaranteed there is at least one word that isn\u2019t banned, and that the answer is unique.<\/em><\/p>\n
          Input:<\/em><\/strong>
          paragraph = «Bob hit a ball, the hit BALL flew far after it was hit.»
          banned = [«hit»]
          <\/em>Output:<\/em><\/strong>\u00a0«ball»<\/em><\/p>\n<\/blockquote>\n
          What are the steps to solve it?<\/p>\n
            \n
          1. \n
            Convert string to lower case and split by words.<\/p>\n<\/li>\n<\/ol>\n
            [bob, hit, a, ball, the, hit, ball, flew, far, after, it, was, hit]<\/code><\/p>\n
            2. Create a set of banned words.<\/p>\n
            [hit]<\/code><\/p>\n
            3. Create a map of words to their occurrence, excluding the banned words.<\/p>\n
            {bob=1, a=1, ball=2, the=1, flew=1, far=1, after=1, it=1, was=1}<\/code><\/p>\n
            4. Return word with the highest number of occurrences from the map.<\/p>\n
            ball<\/code><\/p>\n
            Let\u2019s implement those 4 steps in Java.<\/p>\n
            public String mostCommonWord(String paragraph, String[] banned) {   \/\/ 1. Covert string to lower case and split by words.   String[] words = paragraph.replaceAll(\"[^a-zA-Z0-9 ]\", \" \").toLowerCase().split(\"\\\\s+\");    \/\/ 2. Create a set of banned words.   Set<String> bannedWords = new HashSet();   for (String word : banned)     bannedWords.add(word);    \/\/ 3. Create a map of words to their occurrence, excluding the banned words   Map<String, Integer> wordCount = new HashMap();   for (String word : words) {     if (!bannedWords.contains(word))       wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);   }    \/\/ 4. Return word with the highest number of occurrences from the map.   return Collections.max(wordCount.entrySet(), Map.Entry.comparingByValue()).getKey(); }<\/code><\/pre>\n
            And the same 4 steps in Kotlin.<\/p>\n
            fun mostCommonWord(paragraph: String, banned: Array<String>): String {   \/\/ 1. Covert string to lower case and split by words.   val words = paragraph.toLowerCase().split(\"\\\\W+|\\\\s+\".toRegex())   \/\/ 2. Create a set of banned words.   val bannedSet = banned.toHashSet()   \/\/ 3. Create a map of words to their occurrence, excluding the banned words   val wordToCount = words.filterNot { it in bannedSet }.groupingBy { it }.eachCount()   \/\/ 4. Return word with the highest number of occurrences from the map.   return wordToCount.maxBy { it.value }!!.key }<\/code><\/pre>\n
            Now let\u2019s go through the functions to see what is happening here.<\/p>\n
              \n
            1. \n
              We split the string into\u00a0words: List<String><\/code>. The type is inferred.<\/p>\n<\/li>\n
            2. \n
              Converting\u00a0banned: Array<String><\/code> to\u00a0HashSet<\/code>\u00a0to make\u00a0in<\/code>\u00a0checks in O(1) time<\/p>\n<\/li>\n
            3. \n
              In this step, we chain 3 function calls. First, we use\u00a0filterNot()<\/code>\u00a0to filter out banned words.\u00a0filterNot { it in banned }<\/code>\u00a0will return a\u00a0List<String><\/code>\u00a0that contains only those strings that are not in the\u00a0banned<\/code>\u00a0array. Unlike\u00a0groupBy()<\/code>\u00a0that returns a map,\u00a0groupingBy()<\/code>\u00a0returns an object of\u00a0Grouping<\/code>\u00a0type, that could be used later with one of group-and-fold operations. We use\u00a0it<\/code>\u00a0in\u00a0groupingBy()<\/code>\u00a0lambda. This means that we are grouping by the current element (word) in the collection. In other words \u2014 we create a map, where the key is a word, and the value is a count of occurrences of the word. To get the number of occurrences we use\u00a0eachCount()<\/code>\u00a0on the\u00a0Grouping.<\/code><\/p>\n<\/li>\n
            4. \n
              We use\u00a0maxBy<\/code>\u00a0function to get the first largest element in the map, by\u00a0value<\/code>. This returns us an object of\u00a0Map.Entry<String, Int>?<\/code>, e.g.\u00a0ball = 2<\/code>. And we return a key, which is the most common word in the sentence.<\/p>\n<\/li>\n<\/ol>\n
              Order of elements<\/h3>\n
              When you create a set setOf(\u201ca\u201d, \u201cb\u201d, \u201cc\u201d)<\/code>\u00a0or converting array to set using\u00a0arrayOf(\u201ca\u201d, \u201cb\u201d, \u201cc\u201d).toSet()<\/code>\u00a0the returned set is\u00a0LinkedHashSet<\/code>\u00a0and therefore element iteration order is preserved.<\/p>\n
              The same is true about maps<\/p>\n
              mapOf(Pair(\u201ca\u201d, 1), Pair(\u201cb\u201d, 2))<\/code><\/p>\n
              arrayOf<\/em>(Pair(\u201ca\u201d,<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-394108","post","type-post","status-publish","format-standard","hentry"],"_links":{"self":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/394108","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=394108"}],"version-history":[{"count":0,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=\/wp\/v2\/posts\/394108\/revisions"}],"wp:attachment":[{"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=394108"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=394108"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/savepearlharbor.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=394108"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}