Added tasks 410, 412, 413, 414.

Author: ThanhNIT

README.md

@@ -112,6 +112,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0413 |[Arithmetic Slices](src/main/kotlin/g0401_0500/s0413_arithmetic_slices/Solution.kt)| Medium | Array, Dynamic_Programming | 156 | 100.00
 | 0091 |[Decode Ways](src.save/main/kotlin/g0001_0100/s0091_decode_ways/Solution.kt)| Medium | Top_Interview_Questions, String, Dynamic_Programming | 237 | 76.88
 
 #### Day 11
@@ -757,6 +758,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0412 |[Fizz Buzz](src/main/kotlin/g0401_0500/s0412_fizz_buzz/Solution.kt)| Easy | Top_Interview_Questions, String, Math, Simulation | 307 | 71.81
 | 0136 |[Single Number](src.save/main/kotlin/g0101_0200/s0136_single_number/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation | 344 | 83.63
 | 0007 |[Reverse Integer](src.save/main/kotlin/g0001_0100/s0007_reverse_integer/Solution.kt)| Medium | Top_Interview_Questions, Math | 245 | 60.32
 | 0009 |[Palindrome Number](src.save/main/kotlin/g0001_0100/s0009_palindrome_number/Solution.kt)| Easy | Math | 238 | 96.24
@@ -1374,6 +1376,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0005 |[Longest Palindromic Substring](src.save/main/kotlin/g0001_0100/s0005_longest_palindromic_substring/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Dynamic_Programming | 323 | 75.48
+| 0413 |[Arithmetic Slices](src/main/kotlin/g0401_0500/s0413_arithmetic_slices/Solution.kt)| Medium | Array, Dynamic_Programming | 156 | 100.00
 
 #### Day 15 Dynamic Programming
 
@@ -1621,6 +1624,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer | 561 | 54.68
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
 | 0416 |[Partition Equal Subset Sum](src/main/kotlin/g0401_0500/s0416_partition_equal_subset_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Level_2_Day_13_Dynamic_Programming | 509 | 57.56
+| 0414 |[Third Maximum Number](src/main/kotlin/g0401_0500/s0414_third_maximum_number/Solution.kt)| Easy | Array, Sorting | 317 | 73.00
+| 0413 |[Arithmetic Slices](src/main/kotlin/g0401_0500/s0413_arithmetic_slices/Solution.kt)| Medium | Array, Dynamic_Programming, Algorithm_II_Day_14_Dynamic_Programming, Dynamic_Programming_I_Day_10 | 156 | 100.00
+| 0412 |[Fizz Buzz](src/main/kotlin/g0401_0500/s0412_fizz_buzz/Solution.kt)| Easy | Top_Interview_Questions, String, Math, Simulation, Udemy_Integers | 307 | 71.81
+| 0410 |[Split Array Largest Sum](src/main/kotlin/g0401_0500/s0410_split_array_largest_sum/Solution.kt)| Hard | Array, Dynamic_Programming, Greedy, Binary_Search | 165 | 100.00
 | 0409 |[Longest Palindrome](src/main/kotlin/g0401_0500/s0409_longest_palindrome/Solution.kt)| Easy | String, Hash_Table, Greedy, Data_Structure_II_Day_6_String, Level_1_Day_5_Greedy | 259 | 60.71
 | 0407 |[Trapping Rain Water II](src/main/kotlin/g0401_0500/s0407_trapping_rain_water_ii/Solution.kt)| Hard | Array, Breadth_First_Search, Matrix, Heap_Priority_Queue | 500 | 100.00
 | 0406 |[Queue Reconstruction by Height](src/main/kotlin/g0401_0500/s0406_queue_reconstruction_by_height/Solution.kt)| Medium | Array, Sorting, Greedy, Segment_Tree, Binary_Indexed_Tree | 306 | 100.00

src/main/kotlin/g0401_0500/s0410_split_array_largest_sum/Solution.kt

@@ -0,0 +1,44 @@
+package g0401_0500.s0410_split_array_largest_sum
+
+// #Hard #Array #Dynamic_Programming #Greedy #Binary_Search
+// #2022_12_03_Time_165_ms_(100.00%)_Space_33.9_MB_(100.00%)
+
+class Solution {
+    fun splitArray(nums: IntArray, m: Int): Int {
+        var maxVal = 0
+        var minVal = nums[0]
+        for (num in nums) {
+            maxVal += num
+            minVal = Math.max(minVal, num)
+        }
+        while (minVal < maxVal) {
+            val midVal = minVal + (maxVal - minVal) / 2
+            // if we can split, try to reduce the midVal so decrease maxVal
+            if (canSplit(midVal, nums, m)) {
+                maxVal = midVal
+            } else {
+                // if we can't split, then try to increase midVal by increasing minVal
+                minVal = midVal + 1
+            }
+        }
+        return minVal
+    }
+
+    private fun canSplit(maxSubArrSum: Int, nums: IntArray, m: Int): Boolean {
+        var currSum = 0
+        var currSplits = 1
+        for (num in nums) {
+            currSum += num
+            if (currSum > maxSubArrSum) {
+                currSum = num
+                currSplits++
+                // if maxSubArrSum was TOO high that we can split the array into more that 'm' parts
+                // then its not ideal
+                if (currSplits > m) {
+                    return false
+                }
+            }
+        }
+        return true
+    }
+}

src/main/kotlin/g0401_0500/s0410_split_array_largest_sum/readme.md

@@ -0,0 +1,31 @@
+410\. Split Array Largest Sum
+
+Hard
+
+Given an integer array `nums` and an integer `k`, split `nums` into `k` non-empty subarrays such that the largest sum of any subarray is **minimized**.
+
+Return _the minimized largest sum of the split_.
+
+A **subarray** is a contiguous part of the array.
+
+**Example 1:**
+
+**Input:** nums = [7,2,5,10,8], k = 2
+
+**Output:** 18
+
+**Explanation:** There are four ways to split nums into two subarrays. The best way is to split it into [7,2,5] and [10,8], where the largest sum among the two subarrays is only 18.
+
+**Example 2:**
+
+**Input:** nums = [1,2,3,4,5], k = 2
+
+**Output:** 9
+
+**Explanation:** There are four ways to split nums into two subarrays. The best way is to split it into [1,2,3] and [4,5], where the largest sum among the two subarrays is only 9.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>0 <= nums[i] <= 10<sup>6</sup></code>
+*   `1 <= k <= min(50, nums.length)`

src/main/kotlin/g0401_0500/s0412_fizz_buzz/Solution.kt

@@ -0,0 +1,16 @@
+package g0401_0500.s0412_fizz_buzz
+
+// #Easy #Top_Interview_Questions #String #Math #Simulation #Udemy_Integers
+// #2022_12_03_Time_307_ms_(71.81%)_Space_41.9_MB_(71.97%)
+
+class Solution {
+    fun fizzBuzz(n: Int): Array<String> = Array<String>(n) { index ->
+        val value = index + 1
+        when {
+            (value % 3 == 0 && value % 5 == 0) -> "FizzBuzz"
+            (value % 3 == 0) -> "Fizz"
+            (value % 5 == 0) -> "Buzz"
+            else -> "$value"
+        }
+    }
+}

src/main/kotlin/g0401_0500/s0412_fizz_buzz/readme.md

@@ -0,0 +1,32 @@
+412\. Fizz Buzz
+
+Easy
+
+Given an integer `n`, return _a string array_ `answer` _(**1-indexed**) where_:
+
+*   `answer[i] == "FizzBuzz"` if `i` is divisible by `3` and `5`.
+*   `answer[i] == "Fizz"` if `i` is divisible by `3`.
+*   `answer[i] == "Buzz"` if `i` is divisible by `5`.
+*   `answer[i] == i` (as a string) if none of the above conditions are true.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** ["1","2","Fizz"]
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** ["1","2","Fizz","4","Buzz"]
+
+**Example 3:**
+
+**Input:** n = 15
+
+**Output:** ["1","2","Fizz","4","Buzz","Fizz","7","8","Fizz","Buzz","11","Fizz","13","14","FizzBuzz"]
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>4</sup></code>

src/main/kotlin/g0401_0500/s0413_arithmetic_slices/Solution.kt

@@ -0,0 +1,20 @@
+package g0401_0500.s0413_arithmetic_slices
+
+// #Medium #Array #Dynamic_Programming #Algorithm_II_Day_14_Dynamic_Programming
+// #Dynamic_Programming_I_Day_10 #2022_12_03_Time_156_ms_(100.00%)_Space_36_MB_(41.03%)
+
+class Solution {
+    fun numberOfArithmeticSlices(nums: IntArray): Int {
+        var sum = 0
+        var curr = 0
+        for (i in 2 until nums.size) {
+            if (nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]) {
+                curr++
+                sum += curr
+            } else {
+                curr = 0
+            }
+        }
+        return sum
+    }
+}

src/main/kotlin/g0401_0500/s0413_arithmetic_slices/readme.md

@@ -0,0 +1,30 @@
+413\. Arithmetic Slices
+
+Medium
+
+An integer array is called arithmetic if it consists of **at least three elements** and if the difference between any two consecutive elements is the same.
+
+*   For example, `[1,3,5,7,9]`, `[7,7,7,7]`, and `[3,-1,-5,-9]` are arithmetic sequences.
+
+Given an integer array `nums`, return _the number of arithmetic **subarrays** of_ `nums`.
+
+A **subarray** is a contiguous subsequence of the array.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4]
+
+**Output:** 3
+
+**Explanation:** We have 3 arithmetic slices in nums: [1, 2, 3], [2, 3, 4] and [1,2,3,4] itself.
+
+**Example 2:**
+
+**Input:** nums = [1]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `1 <= nums.length <= 5000`
+*   `-1000 <= nums[i] <= 1000`

src/main/kotlin/g0401_0500/s0414_third_maximum_number/Solution.kt

@@ -0,0 +1,27 @@
+package g0401_0500.s0414_third_maximum_number
+
+// #Easy #Array #Sorting #2022_12_06_Time_317_ms_(73.00%)_Space_36.9_MB_(94.00%)
+
+class Solution {
+    fun thirdMax(nums: IntArray): Int {
+        var max1 = Long.MIN_VALUE
+        var max2 = Long.MIN_VALUE
+        var max3 = Long.MIN_VALUE
+        for (i in nums) {
+            max1 = Math.max(max1, i.toLong())
+        }
+        for (i in nums) {
+            if (i.toLong() == max1) {
+                continue
+            }
+            max2 = Math.max(max2, i.toLong())
+        }
+        for (i in nums) {
+            if (i.toLong() == max1 || i.toLong() == max2) {
+                continue
+            }
+            max3 = Math.max(max3, i.toLong())
+        }
+        return (if (max3 == Long.MIN_VALUE) max1 else max3).toInt()
+    }
+}

src/main/kotlin/g0401_0500/s0414_third_maximum_number/readme.md

@@ -0,0 +1,36 @@
+414\. Third Maximum Number
+
+Easy
+
+Given an integer array `nums`, return _the **third distinct maximum** number in this array. If the third maximum does not exist, return the **maximum** number_.
+
+**Example 1:**
+
+**Input:** nums = [3,2,1]
+
+**Output:** 1
+
+**Explanation:** The first distinct maximum is 3. The second distinct maximum is 2. The third distinct maximum is 1.
+
+**Example 2:**
+
+**Input:** nums = [1,2]
+
+**Output:** 2
+
+**Explanation:** The first distinct maximum is 2. The second distinct maximum is 1. The third distinct maximum does not exist, so the maximum (2) is returned instead.
+
+**Example 3:**
+
+**Input:** nums = [2,2,3,1]
+
+**Output:** 1
+
+**Explanation:** The first distinct maximum is 3. The second distinct maximum is 2 (both 2's are counted together since they have the same value). The third distinct maximum is 1.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+
+**Follow up:** Can you find an `O(n)` solution?

src/test/kotlin/g0401_0500/s0410_split_array_largest_sum/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0401_0500.s0410_split_array_largest_sum
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun splitArray() {
+        assertThat(Solution().splitArray(intArrayOf(7, 2, 5, 10, 8), 2), equalTo(18))
+    }
+
+    @Test
+    fun splitArray2() {
+        assertThat(Solution().splitArray(intArrayOf(1, 2, 3, 4, 5), 2), equalTo(9))
+    }
+
+    @Test
+    fun splitArray3() {
+        assertThat(Solution().splitArray(intArrayOf(1, 4, 4), 3), equalTo(4))
+    }
+}