https://nathannaveen.dev/Recent content on nathan naveenHugo -- gohugo.ioen-us<a href="https://creativecommons.org/licenses/by-nc/4.0/" target="_blank" rel="noopener">CC BY-NC 4.0</a>Thu, 03 Mar 2022 15:29:34 -0600https://nathannaveen.dev/posts/leetcode-2189/Thu, 03 Mar 2022 15:29:34 -0600https://nathannaveen.dev/posts/leetcode-2189/2189. Number of Ways to Build House of Cards I recommend looking at the non-memoized solution instead of the solution with dp to understand the main idea because it is a lot cleaner. In the image below, we can see three different colored triangles and two lines on the side colored yellow. This is to depict how I can place my triangles. I find the number of triangles I can make, and then I use two of my cards to make the yellow lines.https://nathannaveen.dev/posts/leetcode-2178/Thu, 03 Mar 2022 15:29:26 -0600https://nathannaveen.dev/posts/leetcode-2178/2178. Maximum Split of Positive Even Integers The Idea of this Solution: We can subtract multiples of 2 from the number until it is smaller than or equal to 0. Then if it is smaller we can remove the absolute value of the number from the result. For example: input: finalSum = 28 finalSum = 26, res = [2] finalSum = 22, res = [2, 4] finalSum = 16, res = [2, 4, 6]https://nathannaveen.dev/posts/leetcode-2177/Thu, 03 Mar 2022 15:29:20 -0600https://nathannaveen.dev/posts/leetcode-2177/2177. Find Three Consecutive Integers That Sum to a Given Number This solution is small but not the easiest to understand. In Algebra 1, you might have learned how to sum up multiple consecutive numbers to make a result. I came up with this solution because when writing this, I am 15, and I learned about summing up consecutive numbers 2 to 3 years ago. The Explanation of the Solution: x + (x + 1) + (x + 2) = num → We know that we need 3 consecutive numbers, so if x is the first number, x + 1 is the second number, and x + 2 is the third number.https://nathannaveen.dev/posts/leetcode-1861/Thu, 03 Mar 2022 15:29:12 -0600https://nathannaveen.dev/posts/leetcode-1861/1861. Rotating the Box The Base Idea of This Solution: I would say that this solution is like a line sweep solution. This solution uses the fact that if an empty place separates two stones, they will be next to each other when the box is rotated. This is just like in the example input: So this solution just moves all the stones together until we hit the end of the box or an obstacle.https://nathannaveen.dev/posts/leetcode-784/Thu, 03 Mar 2022 15:29:05 -0600https://nathannaveen.dev/posts/leetcode-784/784. Letter Case Permutation The idea of this solution is pretty simple, we can basically construct a tree. func letterCasePermutation(s string) []string { return helper(s, &#34;&#34;) } func helper(s string, a string) []string { if len(s) == 0 { return []string{ a } } res := []string{} letter := s[0] // first letter s = s[1:] if letter &gt;= &#39;a&#39; { // lowercase res = append(res, helper(s, a + string(letter - 32)).https://nathannaveen.dev/posts/leetcode-417/Thu, 03 Mar 2022 15:28:59 -0600https://nathannaveen.dev/posts/leetcode-417/417. Pacific Atlantic Water Flow The idea of this solution is to do DFS from the ocean to the land, not from the land to the ocean. Basically we can do DFS from the water to each point, and we only move from one point to another if the next point has a height greater than the current height. type point struct { i, j int } func pacificAtlantic(heights [][]int) [][]int { n, m := len(heights), len(heights[0]) pacificVisited := make(map[point] bool) atlanticVisited := make(map[point] bool) res := [][]int{} pacific, atlantic := findNextToWater(n, m) add := func(i, j, prevHeight int, pOrA string) { if pOrA == &#34;pacific&#34; { if i &lt; 0 || j &lt; 0 || i &gt;= n || j &gt;= m || pacificVisited[point{i, j}] { return } if heights[i][j] &gt;= prevHeight { pacific = append(pacific, point{i, j}) } } else { // Otherwise it is &#34;atlantic&#34; if i &lt; 0 || j &lt; 0 || i &gt;= n || j &gt;= m || atlanticVisited[point{i, j}] { return } if heights[i][j] &gt;= prevHeight { atlantic = append(atlantic, point{i, j}) } } } for len(pacific) !https://nathannaveen.dev/posts/leetcode-42/Tue, 08 Feb 2022 20:06:54 -0600https://nathannaveen.dev/posts/leetcode-42/42. Trapping Rain Water I got the idea of this solution from qddpx&rsquo;s solution. I thought that it was an ingenious solution, so I decided to explain it. I think that this solution will be easier to understand if you first understand what the code is doing, so I decided to make a GIF about this. We loop through height 3 different times: The first time we loop through height, we loop from 0 to len(height) and make each value in a new array called lToR (left to right) the maximum value that we have reached so far in height.https://nathannaveen.dev/posts/leetcode-2160/Mon, 07 Feb 2022 10:21:59 -0600https://nathannaveen.dev/posts/leetcode-2160/2160. Minimum Sum of Four Digit Number After Splitting Digits How This Solution Works: The idea of this solution is pretty simple and relies on the fact that the minimum number is made by making the biggest number the last digit and the smallest number the first. For example: If we use the digits [4, 6, 1, 3, 0, 9], the minimum number we can make is 013469. If we want the minimum sum, we just have to add the two minimum numbers together and get the minimum sum.https://nathannaveen.dev/posts/leetcode-23/Mon, 07 Feb 2022 10:21:53 -0600https://nathannaveen.dev/posts/leetcode-23/23. Merge k Sorted Lists I think that the idea of this solution can be shown bellow: func mergeKLists(lists []*ListNode) *ListNode { res := &amp;ListNode{} cur := res done := false for !done { done = true min := 10000 for _, list := range lists { if list != nil &amp;&amp; list.Val &lt; min { min = list.Val done = false } } for i := range lists { if lists[i] !https://nathannaveen.dev/posts/leetcode-490/Fri, 04 Feb 2022 12:12:59 -0600https://nathannaveen.dev/posts/leetcode-490/490. The Maze The idea of this solution is to use BFS to find every path. And then if we find a path that leads to the destination we can return true. I made a gif that basicly gives an example of all paths from start. Note that this is the same example as the problem statment. While in the gif we just see the paths, in the code we have to make the path, meaning that we have to make a path one move at a time.https://nathannaveen.dev/posts/leetcode-1102/Fri, 04 Feb 2022 12:12:46 -0600https://nathannaveen.dev/posts/leetcode-1102/1102. Path With Maximum Minimum Value This solution uses a max heap to keep track of all the paths, and which path we can go on to get the maximum minimum value. type key struct { p pos min int } type pos struct { i, j int } type KeyHeap []key func (h KeyHeap) Len() int { return len(h) } func (h KeyHeap) Less(i, j int) bool { return h[i].https://nathannaveen.dev/posts/leetcode-2155/Fri, 04 Feb 2022 12:12:40 -0600https://nathannaveen.dev/posts/leetcode-2155/2155. All Divisions With the Highest Score of a Binary Array The idea of this solution is to loop through nums and add one to a zero count if we have a zero, and subtract one from a one counter if it is a one. This can be shown using an illustration: func maxScoreIndices(nums []int) []int { numZeros := 0 numOnes := 0 for _, n := range nums { numOnes += n } max := numOnes res := []int{0} for i, n := range nums { if n == 0 { numZeros++ } else { numOnes-- } if numZeros + numOnes &gt; max { max = numZeros + numOnes res = []int{ i + 1 } } else if numZeros + numOnes == max { res = append(res, i + 1) } } return res } We can put:https://nathannaveen.dev/posts/leetcode-2154/Fri, 04 Feb 2022 12:12:34 -0600https://nathannaveen.dev/posts/leetcode-2154/2154. Keep Multiplying Found Values by Two The idea of both of these solutions is to add nums elements to a map, and then just keep checking whether original *= 2 is in the map. Instead of original *= 2 I am doing original &lt;&lt;= 1 for better time. In the first solution I am only adding elements that are multiples of original to the map. func findFinalValue(nums []int, original int) int { m := make(map[int] bool) for _, n := range nums { if n % original == 0 { m[n] = true } } for m[original] { original &lt;&lt;= 1 } return original } In the second solution I am adding all elements from nums to the map.https://nathannaveen.dev/posts/leetcode-149/Fri, 04 Feb 2022 12:12:27 -0600https://nathannaveen.dev/posts/leetcode-149/149. Max Points on a Line The idea of this solution is that we start off with a point and then use all the other points to make a line from the start point to one of the other points. Then we can find the slope of the line. Then we can find which slope has the highest number of points. func maxPoints(points [][]int) int { max := 0 for i := 0; i &lt; len(points); i++ { m := make(map[float64] int) // slope : number of points on the slope for j := 0; j &lt; len(points); j++ { x1, x2, y1, y2 := points[i][0], points[j][0], points[i][1], points[j][1] slope := float64(y2 - y1) / float64(x2 - x1) m[slope]++ } for _, b := range m { newB := (b + 1) if newB &gt; max { max = newB } } } if len(points) == 1 { return 1 } return max }https://nathannaveen.dev/posts/leetcode-2144/Fri, 04 Feb 2022 12:12:21 -0600https://nathannaveen.dev/posts/leetcode-2144/2144. Minimum Cost of Buying Candies With Discount We have to get the items with a maximum discount to get the minimum cost we have to pay. For example if we have: input: cost = [3, 7, 1, 5, 9, 11, 15] We know that the maximum discount we can get is 9 because we can buy two candies with costs 11 and 15. Now let us sort cost in non-increasing order.https://nathannaveen.dev/posts/leetcode-520/Fri, 04 Feb 2022 12:12:15 -0600https://nathannaveen.dev/posts/leetcode-520/520. Detect Capital Solution 1: This solution is pretty simple, we can make three strings then compare them to word, and see if any of them match, if they do we can return true. The three strings that we can make are: allCap, this is for the whole word to be upper case (ie. &quot;LEETCODE&quot;) allLower, this is for the whole word to be lower case (ie. &quot;leetcode&quot;) firstCap, this is for the whole word to be lower case except for the first letter which is uppercase (ie.https://nathannaveen.dev/posts/leetcode-2128/Wed, 19 Jan 2022 13:01:56 -0600https://nathannaveen.dev/posts/leetcode-2128/2128. Remove All Ones With Row and Column Flips The idea of this solution can be shown using the following image: As we can see if a row is equal to the inverse of the first row we know that we can flip it to be equal to the first row. And if the row is equal to the first row we don&rsquo;t need to flip it at all. Then if all the rows are equal we can just flip the columns that need flipping.https://nathannaveen.dev/posts/leetcode-1926/Wed, 19 Jan 2022 13:01:49 -0600https://nathannaveen.dev/posts/leetcode-1926/1926. Nearest Exit from Entrance in Maze I decided to try a solution that is similar to Dijkstra&rsquo;s. Even though the positions are not weighted, we can make the distance the weight, so the nodes farther away from the start have a higher weight than the closer ones. All in all, we have to find the node on the edge with the smallest weight. This can be shown using the following image:https://nathannaveen.dev/posts/leetcode-2124/Wed, 19 Jan 2022 13:01:42 -0600https://nathannaveen.dev/posts/leetcode-2124/2124. Check if All A&rsquo;s Appears Before All B&rsquo;s The idea of my solution is pretty simple. If the sorted version of s equals the non sorted version of s we know that every &quot;a&quot; comes before every &quot;b&quot;. Some examples could be: s = &quot;abab&quot;, sortedS = &quot;aabb&quot;, &quot;abab&quot; != &quot;aabb&quot; so return false. s = &quot;aabbb&quot;, sortedS = &quot;aabbb&quot;, &quot;aabbb&quot; == &quot;aabbb&quot; so return true. s = &quot;bba&quot;, sortedS = &quot;abb&quot;, &quot;bba&quot; !https://nathannaveen.dev/posts/leetcode-2095/Wed, 19 Jan 2022 13:01:36 -0600https://nathannaveen.dev/posts/leetcode-2095/2095. Delete the Middle Node of a Linked List The idea of this solution is to use three-pointers, like in the following example: Remember that the hare will always go up two values, while prev and turtle will only go up one. The hare has reached the end, so we can stop moving the hare, turtle, and prev. Now, we have to remove the turtles position by doing prev.Next = prev.https://nathannaveen.dev/posts/leetcode-2119/Wed, 19 Jan 2022 13:01:31 -0600https://nathannaveen.dev/posts/leetcode-2119/The idea of this solution is that any number that has a 0 at the end will result in a different number after reversed twice. This is shown using the numbers: 3210 reversed equals 123 which reversed again equals 321 31000 reversed equals 13 which reversed again equals 31 The only exception for this rule in the number 0. because 0 zero reversed any amount of times equals 0. func isSameAfterReversals(num int) bool { return num == 0 || num % 10 !https://nathannaveen.dev/posts/leetcode-2089/Wed, 19 Jan 2022 13:01:15 -0600https://nathannaveen.dev/posts/leetcode-2089/2089. Find Target Indices After Sorting Array Let us take an example of nums = [1, 2, 5, 2, 3, 1, 2] and target = 2. If we sort nums we get nums = [1, 1, 2, 2, 2, 3, 5]. If we know, there are three twos in nums and two items with values smaller than theirs. We know that the result will be [2, 3, 4]. So basically, this solution makes an array of the number of values that equal target where each value will be one more than the previous value.https://nathannaveen.dev/posts/leetcode-2083/Wed, 19 Jan 2022 13:01:07 -0600https://nathannaveen.dev/posts/leetcode-2083/2083. Substrings That Begin and End With the Same Letter func numberOfSubstrings(s string) int64 { m := make(map[rune] int) res := int64(0) for _, letter := range s { m[letter]++ res += int64(m[letter]) } return res } The second solution is the fun solution. We can find the number of substrings, the beginning, and the end in the same letter. To show how this is done, we can take an example of &quot;aaaaaa&quot;:https://nathannaveen.dev/posts/leetcode-778/Wed, 19 Jan 2022 13:00:51 -0600https://nathannaveen.dev/posts/leetcode-778/778. Swim in Rising Water Time complexity = O(n2log(n)) n2 is for looping through all the elements in grid where n == len(grid). Note that it is n2 instead of n * m because len(grid) == len(grid[0]). log(n) is for the priority queue. Note that this is a computer science log(n) when log(n) == log2(n) instead of math where log(n) == log10(n). type key struct { max int r, c int } type RowAndCol struct { r, c int } type KeyHeap []key func (h KeyHeap) Len() int { return len(h) } func (h KeyHeap) Less(i, j int) bool { return h[i].https://nathannaveen.dev/posts/leetcode-2068/Wed, 19 Jan 2022 13:00:44 -0600https://nathannaveen.dev/posts/leetcode-2068/2068. Check Whether Two Strings are Almost Equivalent The time complexity of the first solution is O(2n + 26) The 2n is for looping through both word1 and word2. They both are the same length, so we get 2n instead of n * m The 26 is for looping through len(letters), because there are 26 letters in the alphabet. func checkAlmostEquivalent(word1 string, word2 string) bool { letters := make([]int, 26) for i := 0; i &lt; len(word1); i++ { letters[int(word1[i] - &#39;a&#39;)]++ letters[int(word2[i] - &#39;a&#39;)]-- } for _, a := range letters { if a &lt; -3 || a &gt; 3 { return false } } return true } The worst time complexity of the following solution is O(2n + 26), but since we are using a map instead of an array the time complexity can range from O(2n + 1) to O(2n + 26).https://nathannaveen.dev/posts/leetcode-2075/Wed, 19 Jan 2022 13:00:38 -0600https://nathannaveen.dev/posts/leetcode-2075/2075. Decode the Slanted Ciphertext The main idea of this solution is to find the number of columns. The solution comes together pretty quickly after that. To explain my thinking to how I found the number of columns we have to take a matrix. We should know the number rows and columns in that matrix. For example: [a][d][g][ ] [ ][b][e][h] [ ][ ][c][f] We have a matrix with 3 rows and 4 columns, and 12 items.https://nathannaveen.dev/posts/leetcode-353/Wed, 19 Jan 2022 13:00:19 -0600https://nathannaveen.dev/posts/leetcode-353/353. Design Snake Game For SnakeGame I have a lot of pramaters, and it might be hard to understand this solution is you don&rsquo;t understand them. So: counter int → The amount of food that the snake has eaten. height int → The height of the matrix. width int → The width of the matrix. food [][]int → The positions of the food. foodCounter int → What food we are on (i.https://nathannaveen.dev/posts/leetcode-2103/Wed, 19 Jan 2022 13:00:08 -0600https://nathannaveen.dev/posts/leetcode-2103/2103. Rings and Rods The idea of this solution is to use the fact that prime numbers can not be divided by any number other than one and itself. So if we relatively multiply 2 , 3, or 5 to each rods value accordingly to 'R', 'G', 'B' we can check whether it is divisible by 2, 3, and 5 to check whether we have all three colored rings on a rod.https://nathannaveen.dev/posts/leetcode-8/Wed, 19 Jan 2022 13:00:00 -0600https://nathannaveen.dev/posts/leetcode-8/8. String to Integer (atoi) I am going to explain this solution while walking through the code: We can first remove the starting spaces because the problem says to &ldquo;Read in and ignore any leading whitespace&rdquo;. Then, my code checks whether the length of s equals 0. If it is, we can return 0, because some of the following code is hardcoded to s having a minimum length of 1. Then, if the first character is negative or positive, we can account for the sign: We can check for a positive or negative sign once throughout this whole code right before the digits because a positive/negative sign should only be there.https://nathannaveen.dev/sink/year-2021/Sat, 08 Jan 2022 16:32:55 -0600https://nathannaveen.dev/sink/year-2021/I am a 15-year-old who has solved over 700 Leetcode problems, and finished up to day 17 in advent of code! Leetcode: https://leetcode.com/nathannaveen/ I write up Leetcode solutions and post them on Leetcode. So far, I have done about a year of Leetcode and have got the Annual Badge. I started doing Leetcode in November 2020 and have kept doing it since. Advent of Code: https://adventofcode.com I have finished almost all of the first 17 days of Advent of Code, with the only exception of day 16 part 2.https://nathannaveen.dev/posts/leetcode-543/Wed, 10 Nov 2021 09:57:49 -0600https://nathannaveen.dev/posts/leetcode-543/I feel that enough people have explained the first type of solution, so I will not explain this. Most People Do This: var maximum = 0 func diameterOfBinaryTree(root *TreeNode) int { maximum = 0 helper(root) return maximum } func helper(root *TreeNode) int { if root == nil { return 0 } leftHeight, rightHeight := helper(root.Left), helper(root.Right) maximum = max(leftHeight + rightHeight, maximum) return 1 + max(leftHeight, rightHeight) } func max(a, b int) int { if a &gt; b { return a } return b } The Second Solution Explanation:https://nathannaveen.dev/posts/leetcode-1807/Thu, 28 Oct 2021 15:59:20 -0500https://nathannaveen.dev/posts/leetcode-1807/1807. Evaluate the Bracket Pairs of a String The idea of this solution is pretty simple: We can first add all the knowledge into a map which I called storedKnowledge Then we can loop through s If s[i] == '(' we can make start = i + 1, so we know where the bracket starts Else if s[i] == ')' we can check whether storedKnowledge contains s[start : i] (For our non-Golang users s[start : i] is basically getting the substring from position start to the position i, if we think mathematically it could be shown as the inequality [start, i)), if it contains we can add the value to res, else add &quot;?https://nathannaveen.dev/posts/leetcode-1991/Thu, 28 Oct 2021 15:59:14 -0500https://nathannaveen.dev/posts/leetcode-1991/1991. Find the Middle Index in Array The idea of this solution is pretty simple: We find the sum of all the numbers in nums (In this solution, I am calling it sum) Then we check whether sum - left - nums[i] == left (I will get back to what left is and what this whole thing means in the following parts). If so, we can return i (The index). The variable called left keeps track of the left sum, so we do left += nums[i].https://nathannaveen.dev/posts/leetcode-1984/Thu, 28 Oct 2021 15:59:09 -0500https://nathannaveen.dev/posts/leetcode-1984/1984. Minimum Difference Between Highest and Lowest of K Scores The idea of this solution is pretty simple: We just sort nums And then we can use a sliding window to check for the min of the last number in the sub-array minus the first number in the sub-array. The reason we sort nums is the minimum distance will always be between the two closest numbers. For example if we have the array nums = [1, 2, 3, 4, 6, 10], and we had k = 3, we can see that the differences would be:https://nathannaveen.dev/posts/leetcode-598/Thu, 28 Oct 2021 15:59:00 -0500https://nathannaveen.dev/posts/leetcode-598/598. Range Addition II The idea of this solution is pretty simple, the positions with the max value will be in the sub-matrix of range 0 to minimum y pos, and 0 to minimum x pos. If you don&rsquo;t understand look at the example bellow: input: m = 6, n = 5, ops = [[4, 3], [2, 6], [3, 5]] (Note: They give the input 1-indexed, instead of 0-indexed) As you can see, all rectangles top left corner is (0, 0) (I added an orange dot at (0, 0)).https://nathannaveen.dev/posts/leetcode-2006/Thu, 28 Oct 2021 15:58:53 -0500https://nathannaveen.dev/posts/leetcode-2006/2006. Count Number of Pairs With Absolute Difference K The main idea of this solution is nums[i] + k = nums[j] and nums[i] - k = nums[j], if you don&rsquo;t understand: |nums[i] - nums[j| = k Now if we took off the absolute value sign we get 2 equations: -(nums[i] - nums[j]) = k and nums[i] - nums[j] = k Let us start with -(nums[i] - nums[j]) = k: -(nums[i] - nums[j]) = k Mulitply both sides by -1 so nums[i] - nums[j] = -k add k to both sides, and add nums[j] to both sides nums[i] + k = nums[j] Now we can do nums[i] - nums[j] = k:https://nathannaveen.dev/posts/leetcode-2016/Thu, 28 Oct 2021 15:58:50 -0500https://nathannaveen.dev/posts/leetcode-2016/2016. Maximum Difference Between Increasing Elements The idea of this solution is we loop through nums, and if a number is greater than min we can check whether to make it max, otherwise if the number is smaller than min we can re-make min. func maximumDifference(nums []int) int { min := nums[0] max := -1 for i := 0; i &lt; len(nums); i++ { if nums[i] &gt; min &amp;&amp; nums[i] - min &gt; max { max = nums[i] - min } else if nums[i] &lt; min { min = nums[i] } } return max }https://nathannaveen.dev/posts/leetcode-1257/Thu, 28 Oct 2021 15:58:40 -0500https://nathannaveen.dev/posts/leetcode-1257/1257. Smallest Common Region A quick idea of this solution is (Note: This solution is not very good if you want a solution that is easy to understand, look after this): To use a map to store every region as the key and the value as the region in which the original region is contained. Then loop through all the regions in the food chain of region1 (I am calling a food chain whenever we start with region1, and then find the region that contains it) and store all the values into another map.https://nathannaveen.dev/posts/leetcode-2027/Thu, 28 Oct 2021 15:58:28 -0500https://nathannaveen.dev/posts/leetcode-2027/2027. Minimum Moves to Convert String The idea of this solution is if we are on a 'X' we can move the index up by three and add one to res. An example could be: input: s = &quot;XXOXXXOOOXOXOXX&quot; (I tried to capture as many edge cases as I could in this test case) We can start with our index i = 0 s[i] == 'X', so we can skip the next two values (Skip the values at indexes 1 and 2 because according to the problem we have made s[0] = 'O', s[1] = 'O', s[2] = 'O'.https://nathannaveen.dev/posts/leetcode-2028/Thu, 28 Oct 2021 15:58:20 -0500https://nathannaveen.dev/posts/leetcode-2028/2028. Find Missing Observations This solution aims to find the missing sum and then distribute it among n values. The idea of the first part (Finding the missing sum) is first to find the sum of the m numbers given to us in rolls. Then since the mean will always be mean = sum / (n + m) (the sum of elements divided by the number of elements), we know that the number of elements will always be n + m.https://nathannaveen.dev/posts/leetcode-200/Thu, 28 Oct 2021 15:58:14 -0500https://nathannaveen.dev/posts/leetcode-200/200. Number of Islands The idea of this solution can be portrayed in its most basic idea by the following image: var doneAlready = make(map[[2]int] bool) func numIslands(grid [][]byte) int { res := 0 doneAlready = make(map[[2]int] bool) for i := 0; i &lt; len(grid); i++ { for j := 0; j &lt; len(grid[0]); j++ { if helper(grid, i, j) { res++ } } } return res } func helper(grid [][]byte, i, j int) bool { temp := [2]int{i, j} if i &lt; 0 || i &gt;= len(grid) || j &lt; 0 || j &gt;= len(grid[0]) || doneAlready[temp] || grid[i][j] == &#39;0&#39; { return false } doneAlready[temp] = true helper(grid, i - 1, j) helper(grid, i + 1, j) helper(grid, i, j - 1) helper(grid, i, j + 1) return true } This is a variation of my Max Area of Island solution:https://nathannaveen.dev/posts/leetcode-1428/Thu, 28 Oct 2021 15:58:02 -0500https://nathannaveen.dev/posts/leetcode-1428/1428. Leftmost Column with at Least a One This solution uses the fact that all rows are sorted. So, all the ones in every row will be at the end. Basically, to not call binaryMatrix.Get(i, j) too many times. We can&rsquo;t loop through all values of the matrix. Since 1 &lt;= rows, cols &lt;= 100 the max number of elements in the matrix is 100 * 100, 10000. And the problem says that the max number of calls to binaryMatrix.https://nathannaveen.dev/posts/leetcode-684/Thu, 28 Oct 2021 15:57:56 -0500https://nathannaveen.dev/posts/leetcode-684/684. Redundant Connection The idea of this solution is to use union find to connect all the edges together, then in the Union() function if edge[0] parent equals edge[1] parent we have a redundant connection. Note that I modified the average union find for this problem. type unionFind struct { parent []int n int } func (this *unionFind) Find(x int) int { if x != this.parent[x] { this.parent[x] = this.Find(this.parent[x]) return this.https://nathannaveen.dev/posts/leetcode-2046/Thu, 28 Oct 2021 15:57:20 -0500https://nathannaveen.dev/posts/leetcode-2046/2046. Sort Linked List Already Sorted Using Absolute Values The idea of this solution is to check whether the current value is smaller than 0. If so, we can remove it from its current position, add it to the beginning of the list, and make that the new beginning. This solution works because the absolute value of -1 will always be smaller than the absolute value of -5, but -1 is greater than -5.https://nathannaveen.dev/posts/leetcode-319/Thu, 28 Oct 2021 15:56:46 -0500https://nathannaveen.dev/posts/leetcode-319/319. Bulb Switcher Note: If you don&rsquo;t understand this problem, think of it as something similar to Seive of Eratosthenes. At first I didn&rsquo;t understand how to go about this problem, so I drew it out. I made a graph that might be easier to understand than my drawing: In this graph the numbers represent what round we are on (Y-axis = what round we are on). And the bulbs represent each bulb (X-axis = what bulb we are on).https://nathannaveen.dev/posts/leetcode-1804/Tue, 17 Aug 2021 12:33:53 -0500https://nathannaveen.dev/posts/leetcode-1804/1804. Implement Trie II (Prefix Tree) The idea of this solution can be shown using the following image: type Node struct { m map[rune] *Node isEndCounter int starts int } type Trie struct { node *Node } func Constructor() Trie { return Trie{node: &amp;Node{make(map[rune] *Node), 0, 0}} } func (this *Trie) Insert(word string) { root := this.node root.starts++ for _, s := range word { if root.m[s] == nil { root.https://nathannaveen.dev/posts/leetcode-1903/Tue, 17 Aug 2021 12:31:35 -0500https://nathannaveen.dev/posts/leetcode-1903/1903. Largest Odd Number in String The idea of this solution is pretty simple, we find the last odd digit, and the number from the beginning of num to that odd digit is the greatest odd number we can get. If you don&rsquo;t understand, think &ldquo;what makes an odd number?&rdquo; An odd number is a number with its last digit being odd (The last digit can be 1, 3, 5, 7, or 9).https://nathannaveen.dev/posts/leetcode-1936/Tue, 17 Aug 2021 12:31:28 -0500https://nathannaveen.dev/posts/leetcode-1936/1936. Add Minimum Number of Rungs func addRungs(rungs []int, dist int) int { prev := 0 res := 0 for i := 0; i &lt; len(rungs); i++ { rung := rungs[i] res += (rung - prev - 1) / dist prev = rung } return res } The idea of both of these solution are pretty much the same except for this solution we pre-pend 0 to the rungs instead of having prev.https://nathannaveen.dev/posts/leetcode-1945/Tue, 17 Aug 2021 12:31:21 -0500https://nathannaveen.dev/posts/leetcode-1945/1945. Sum of Digits of String After Convert The Mathematical Solution: The idea of this solution uses the fact that k will always be 1 &lt;= k &lt;= 10. Since k will always be greater than 1 we can add the first transformation and conversion together, so we don&rsquo;t add numbers that are greater than 9 to the result. For an example let us use: input: s = &quot;hvmhoasabayzzzzzd&quot;, k = 1https://nathannaveen.dev/posts/leetcode-1954/Tue, 17 Aug 2021 12:31:12 -0500https://nathannaveen.dev/posts/leetcode-1954/1954. Minimum Garden Perimeter to Collect Enough Apples For this solution, I will try to explain it with an image. I have drawn a picture to explain how this solution works. I have drawn a 2 x 2 and a 4 x 4 square. I will explain the reason for this later. And I have given each position a letter instead of coordinate so I can give a map with each letter and coordinate.https://nathannaveen.dev/posts/leetcode-1910/Tue, 17 Aug 2021 12:31:06 -0500https://nathannaveen.dev/posts/leetcode-1910/1910. Remove All Occurrences of a Substring Solution One: (Iterative) The idea of this solution is pretty simple: We can loop through s using a counter i Then we check whether s[i : i + len(part)] == part (Is the part of s from i to i + len(part) equal to part). If so, we can re-make s without that part We can also move back the counter (i) by the length of part, so we can see whether removing the part from s makes another part.https://nathannaveen.dev/posts/leetcode-1893/Tue, 17 Aug 2021 12:30:59 -0500https://nathannaveen.dev/posts/leetcode-1893/1893. Check if All the Integers in a Range Are Covered First, a walk-through of the code, and then an explanation. A Walk Through Of the Solution: We can sort ranges by the ranges left value (I think of ranges as ranges = [][]int{ []int{left, right} }). Then I loop through ranges and: If the ranges left value is greater than left, we can return false. If the ranges left value is smaller than or equal to left and the ranges right is smaller than right, we can re-make left.https://nathannaveen.dev/posts/leetcode-1404/Tue, 17 Aug 2021 12:30:51 -0500https://nathannaveen.dev/posts/leetcode-1404/1404. Number of Steps to Reduce a Number in Binary Representation to One The idea of this solution is: When we find a zero at the end of s, we know that s is divisible by 2, so we can remove the end of the string and add one to the result. When we find a 1 at the end of s, we know that s is not divisible by 2, so we can add 1 by keep making all values before the position equal to 0 if they are 1 and 1 if they are 0.https://nathannaveen.dev/posts/leetcode-302/Tue, 17 Aug 2021 12:30:46 -0500https://nathannaveen.dev/posts/leetcode-302/302. Smallest Rectangle Enclosing Black Pixels Note: I think that the x and y coordinates are wrong in the problem because, in a graph, the axis are: y ^ | | | +--------&gt; x The idea of the solution can be shown using the following image: The Code: type key struct { x int y int } func minArea(image [][]byte, x int, y int) int { stack := []key{ key{ y, x } } minX, maxX := 101, 0 minY, maxY := 101, 0 for len(stack) !https://nathannaveen.dev/posts/leetcode-582/Tue, 17 Aug 2021 12:30:39 -0500https://nathannaveen.dev/posts/leetcode-582/582. Kill Process Both of these solutions operate on the same idea: We add all the parents and children to a map in the format of map[parent] []children (map of a parent then an array of children) Then we add the kill value to the result and the kills children (From the map), and then the kill&rsquo;s children&rsquo;s children, and so on (kill, kill children, kills children's children). Iterative If you don&rsquo;t understand stack = append(stack, m[pop].https://nathannaveen.dev/posts/leetcode-888/Tue, 17 Aug 2021 12:30:29 -0500https://nathannaveen.dev/posts/leetcode-888/888. Fair Candy Swap The idea of this solution can be shown using the following image: The Code: func fairCandySwap(A []int, B []int) []int { alice, bob := 0, 0 m := make(map[int] int) for _, i := range A { alice += i } for _, i := range B { bob += i m[i]++ } temp := (alice - bob) / 2 for _, i := range A { if m[i - temp] &gt;= 1 { return []int{i, i - temp} } } return []int{} }https://nathannaveen.dev/posts/leetcode-1940/Sun, 25 Jul 2021 18:33:29 -0500https://nathannaveen.dev/posts/leetcode-1940/1940. Longest Common Subsequence Between Sorted Arrays At first, I thought that this would need a nice algorithm, but then when I read the description, it said that &ldquo;arrays is sorted in strictly increasing order&rdquo; and &ldquo;longest common subsequence&rdquo; The first part, &ldquo;arrays is sorted in strictly increasing order,&rdquo; tells us that each array is sorted and each array has unique numbers. The second part, &ldquo;longest common subsequence&rdquo; says that it is a subsequence and not a subarray.https://nathannaveen.dev/posts/leetcode-199/Sun, 25 Jul 2021 18:33:21 -0500https://nathannaveen.dev/posts/leetcode-199/199. Binary Tree Right Side View The idea of both solutions is pretty simple, we just use BFS to iterate through all the rows and append the last element in the row (The right most element). Iterative: func rightSideView(root *TreeNode) []int { res := []int{} if root != nil { queue := []*TreeNode{ root } for len(queue) != 0 { n := len(queue) res = append(res, queue[n - 1].Val) for i := 0; i &lt; n; i++ { pop := queue[0] queue = queue[1:] if pop.https://nathannaveen.dev/posts/leetcode-495/Sun, 25 Jul 2021 18:33:13 -0500https://nathannaveen.dev/posts/leetcode-495/495. Teemo Attacking The idea of these two solutions is pretty simple, but in the second solution, I didn&rsquo;t want to use a variable to store the result, so I manipulated timeSeries into storing the resulting values (Basically used DP). The First Solution I first did this solution like this: func findPoisonedDuration(timeSeries []int, duration int) int { res := 0 for i := 1; i &lt; len(timeSeries); i++ { if timeSeries[i - 1] + duration - 1 &lt; timeSeries[i] { res += duration } else { res += timeSeries[i] - timeSeries[i - 1] } } if len(timeSeries) !https://nathannaveen.dev/posts/leetcode-50/Sun, 25 Jul 2021 18:33:06 -0500https://nathannaveen.dev/posts/leetcode-50/50. Pow(x, n) This solution is if n &lt; 0 (If n is negative) we can return 1 / (x ^ (-n)) (The -n is for making n positive). Otherwise we can just return math.Pow(x, n). func myPow(x float64, n int) float64 { if n &lt; 0 { return 1 / math.Pow(x, float64(-n)) } return math.Pow(x, float64(n)) } Technically we could do the following code and solve the problem, but that isn&rsquo;t the idea of the problem because Golang takes care of test cases when n is negative.https://nathannaveen.dev/posts/leetcode-1886/Sun, 25 Jul 2021 18:33:01 -0500https://nathannaveen.dev/posts/leetcode-1886/1886. Determine Whether Matrix Can Be Obtained By Rotation The idea of this solution is to loop through every point in mat and check whether it has been rotated 0, 90, 180, or 270 degrees. We don&rsquo;t need to check whether mat has been rotated by 0 degrees the way we are doing the rest of the rotations. All we have to do is check whether mat == target. I am going to explain how we do the rotations using some images.https://nathannaveen.dev/posts/leetcode-590/Sun, 25 Jul 2021 18:32:55 -0500https://nathannaveen.dev/posts/leetcode-590/590. N-ary Tree Postorder Traversal The First Solution: This solution seems pretty self-explanatory. func postorder(root *Node) []int { return helper(root, []int{}) } func helper(r *Node, l []int)[]int{ if r != nil{ for _,item := range r.Children{ l = helper(item,l) } l = append(l,r.Val) } return l } The Second Solution: If you look at the following code and don&rsquo;t understand, it is probably because of: r.Children[len(r.Children) - i - 1], but if you look at it carefully, you will see that it is the same as reversing r.https://nathannaveen.dev/posts/leetcode-987/Sun, 25 Jul 2021 18:32:47 -0500https://nathannaveen.dev/posts/leetcode-987/987. Vertical Order Traversal of a Binary Tree I know that this solution is very cumbersome and annoying, so I am just going to explain what the main idea is: We first use BFS to find every node with its row and column and store those values in an array. Then, we add all the values from the array to a matrix array which stores the nodes value and the row of the node in the position of the column.https://nathannaveen.dev/posts/leetcode-1559/Tue, 06 Jul 2021 18:32:45 -0500https://nathannaveen.dev/posts/leetcode-1559/1559. Detect Cycles in 2D Grid The idea for this solution is to: Find a backward L shape in the matrix. (Don&rsquo;t worry if you don&rsquo;t understand I will come back to it later) Then check whether the cycle all starts from one position. (I will also come back to this later) For this solution, I am going to explain how it works using an example: If you look at the problem, you might see this example already there, I picked this example because we know the answer:https://nathannaveen.dev/posts/leetcode-759/Tue, 06 Jul 2021 18:25:36 -0500https://nathannaveen.dev/posts/leetcode-759/759. Employee Free Time The idea of this solution is pretty simple: We add everyone&rsquo;s intervals into an array of intervals called arr. Then, we sort arr by their start values. Then when we loop through arr: If the end of the current element is smaller than the following elements start, we know that we have no overlap. Else if, the current elements end value is greater than the following elements start and the next elements end value, we know that the current elements time frame surrounds the following elements time frame.https://nathannaveen.dev/posts/leetcode-1913/Tue, 06 Jul 2021 18:25:29 -0500https://nathannaveen.dev/posts/leetcode-1913/1913. Maximum Product Difference Between Two Pairs For this solution, we have to get the maximum Product Difference and to do this, we have to subtract the smallest product from the largest product. So in this solution, I decided to sort nums and return the max product minus the min product. func maxProductDifference(nums []int) int { sort.Ints(nums) return nums[len(nums) - 1] * nums[len(nums) - 2] - nums[0] * nums[1] }https://nathannaveen.dev/posts/leetcode-817/Tue, 06 Jul 2021 18:25:21 -0500https://nathannaveen.dev/posts/leetcode-817/817. Linked List Components The idea of this solution is: We make a map to store all the values in nums because all the values in nums are unordered subsets of our linked list, so finding whether nums contains a value is now done in O(1) time (Note that to get all the values into the map it takes O(n) time). Then all we have to do is loop through our linked list and if m (Our map is called m) contains the current value and it doesn&rsquo;t contain the previous value or the value is the head and m contains the value we know that we have another component.https://nathannaveen.dev/posts/leetcode-933/Tue, 06 Jul 2021 18:25:16 -0500https://nathannaveen.dev/posts/leetcode-933/933. Number of Recent Calls For this solution, we have got to look at something that is said in the problem description: It is guaranteed that every call to ping uses a strictly larger value of t than the previous call. So using that, we can make a variable (Which I called k) and store the position of the last position of the value that is greater than or equal to t - 3000.https://nathannaveen.dev/posts/leetcode-61/Tue, 06 Jul 2021 18:25:10 -0500https://nathannaveen.dev/posts/leetcode-61/61. Rotate List The idea of this solution is pretty simple, and I will explain it using this image below: Note: Before we get into what this picture represents, I want you to know that we already know the length of the linked list because the first loop in the code is for finding the length. The image above is from the problem description and is showing the input and output as: Input: head = [1,2,3,4,5], k = 2 Output: [4,5,1,2,3]https://nathannaveen.dev/posts/leetcode-504/Tue, 06 Jul 2021 18:25:01 -0500https://nathannaveen.dev/posts/leetcode-504/504. Base 7 The main idea of both solutions is to convert the number to base seven. To convert a number to base 7 we can do something similar to converting to base 2, 3, 4 and so on. So if you know how to convert a number to another base you can just scroll down to the code and skip the example image. Using Math, and then returning string(res):https://nathannaveen.dev/posts/leetcode-1669/Tue, 06 Jul 2021 18:24:53 -0500https://nathannaveen.dev/posts/leetcode-1669/1669. Merge In Between Linked Lists The idea of this solution can be explained with a simple image: In image 1 we can see the input of list1 = [0, 1, 2, 3, 4, 5], list2 = [10, 11, 12], a = 3, and b = 4. We can iterate through list2 and store the beginning and end of the list. Then, we can iterate through list1 and find the pos of a - 1.https://nathannaveen.dev/posts/leetcode-55/Tue, 06 Jul 2021 18:24:47 -0500https://nathannaveen.dev/posts/leetcode-55/55. Jump Game The idea of this solution is pretty simple once you understand it. The idea of this solution is: We get the maximum index we can go up to by getting the maximum of i + nums[i] and max. Then, if i has surpassed the maximum index, we can return false. Otherwise return true. If you don&rsquo;t understand why this works, look at the following example: input: [3, 2, 1, 0, 4] expected output: falsehttps://nathannaveen.dev/posts/leetcode-280/Tue, 06 Jul 2021 18:24:43 -0500https://nathannaveen.dev/posts/leetcode-280/280. Wiggle Sort The idea of this solution is pretty simple. We sort nums and then keep switching the numbers, so we get the array wiggled. func wiggleSort(nums []int) { sort.Ints(nums) for i := 1; i &lt; len(nums) - 1; i += 2 { nums[i], nums[i + 1] = nums[i + 1], nums[i] } }https://nathannaveen.dev/posts/leetcode-170/Tue, 06 Jul 2021 18:24:38 -0500https://nathannaveen.dev/posts/leetcode-170/170. Two Sum III - Data structure design I have to admit that this is not the best solution to solve this problem, but I think it is the easiest to understand. For all we do is: Append to this.arr to Add(number). And use a two-pointer approach for Find(value). type TwoSum struct { arr []int } /** Initialize your data structure here. */ func Constructor() TwoSum { return TwoSum{[]int{}} } /** Add the number to an internal data structure.https://nathannaveen.dev/posts/leetcode-1828/Wed, 16 Jun 2021 11:22:53 -0500https://nathannaveen.dev/posts/leetcode-1828/1828. Queries on Number of Points Inside a Circle The idea of this solution is to: loop through the queries and then a nested loop to go through points. After that we check whether squared(point[0] - query[0]) + squared(point[1] - query[1]) &lt;= squared(query[2]). This is bascily checking whether the distance between two points is smaller than or equal to the radius but edited. This image that I have drawn and wrote up explains this part: (Note: point[0] = x1, query[0] = x2, point[1] = y1, query[1] = y2, query[2] = radius)https://nathannaveen.dev/posts/leetcode-1837/Wed, 16 Jun 2021 11:22:46 -0500https://nathannaveen.dev/posts/leetcode-1837/1837. Sum of Digits in Base K Before I explain both solution I just want to say that for me the first solution is not as readable as the second solution but easyer to understand (Note: I wrote the first solution before the second solution so that might be why). The first solution basicly uses the fact that n only goes up to 100 and that k has a range of 2 to 10https://nathannaveen.dev/posts/leetcode-1854/Wed, 16 Jun 2021 11:22:38 -0500https://nathannaveen.dev/posts/leetcode-1854/1854. Maximum Population Year I first did this solution using an O(n^2) approach but then tried to think about how to do it better. I couldn&rsquo;t, so I looked at the discussion and saw votrubac solution. The code below is pretty similar, except I make an array of size 101 instead of 2051 because we only need the years from 2050 to 1950. func maximumPopulation(logs [][]int) int { populationPerYear := make([]int, 101) res := 0 for _, log := range logs { populationPerYear[log[0] - 1950]++ populationPerYear[log[1] - 1950]-- } for i := 1; i &lt; 101; i++ { populationPerYear[i] += populationPerYear[i - 1] if populationPerYear[i] &gt; populationPerYear[res] { res = i } } return res + 1950 }https://nathannaveen.dev/posts/leetcode-1249/Wed, 16 Jun 2021 11:22:30 -0500https://nathannaveen.dev/posts/leetcode-1249/1249. Minimum Remove to Make Valid Parentheses The idea of this solution is: Loop through every character in s, and: If the current character is a '(' add the index of the '(' to a stack If the current character is a ')': If the stack is not empty, we can pop off the stack If the stack is empty, remove the character from the string After looping through every character, if the stack is not empty, we remove the characters at the values in the stack.https://nathannaveen.dev/posts/leetcode-48/Wed, 16 Jun 2021 11:22:22 -0500https://nathannaveen.dev/posts/leetcode-48/48. Rotate Image The idea of this solution is first to flip the matrix, so it is upside down, and then transpose the matrix. If you don&rsquo;t understand, look at the following images: We flip the matrix by fliping the top and bottom len(matrix) / 2 rows, like in this image: And transposing the matrix is basically making matrix[i][j] = matrix[j][i], and the flips should only flip from yellow to the blue, or blue to yellow in the following image:https://nathannaveen.dev/posts/leetcode-484/Wed, 16 Jun 2021 11:22:18 -0500https://nathannaveen.dev/posts/leetcode-484/484. Find Permutation The idea of this solution is to: We get the first n + 1 numbers in order [1, 2, 3, ..., n + 1]. Then we reverse the numbers whenever we find a 'D', and we reverse a whole set of numbers when we find multiple 'D'&rsquo;s together. Then we return the array. You might be wondering why we reverse sets of 'D'&rsquo;s instead of just reversing every 'D', it can be shown using an image:https://nathannaveen.dev/posts/leetcode-1874/Wed, 16 Jun 2021 11:22:12 -0500https://nathannaveen.dev/posts/leetcode-1874/1874. Minimize Product Sum of Two Arrays The idea of both solutions is pretty much the same: The smallest number multiplied by the greatest number always makes the smallest sum. If you don&rsquo;t understand, look at the following image: In the image above, the top array is sorted in non-decreasing order, and the bottom array is sorted in non-increasing order. So when we multiply nums1[i] and nums2[i] together, we get the minimum product, and when we sum the products up, we get the minimum sum.https://nathannaveen.dev/posts/leetcode-1403/Wed, 16 Jun 2021 11:22:07 -0500https://nathannaveen.dev/posts/leetcode-1403/1403. Minimum Subsequence in Non-Increasing Order The idea of this solution is pretty simple, we first sort nums in non-increasing order and then find the sum of nums. After that, we can loop through nums and subtract the greatest numbers in nums from the total sum and add the greatest numbers in nums to a different sum. And then, we append the num to res (the resulting function). If the other sum is greater than the total sum, we can break out of the loop and return res.https://nathannaveen.dev/posts/leetcode-944/Wed, 16 Jun 2021 11:21:55 -0500https://nathannaveen.dev/posts/leetcode-944/944. Delete Columns to Make Sorted This solution loops through every column, and then if the previous letter in the column is greater than the current letter, we know that this column can be removed. func minDeletionSize(strs []string) int { res := 0 for i := 0; i &lt; len(strs[0]); i++ { for j := 1; j &lt; len(strs); j++ { if strs[j][i] &lt; strs[j-1][i] { res++ break } } } return res }https://nathannaveen.dev/posts/leetcode-1689/Wed, 16 Jun 2021 11:21:37 -0500https://nathannaveen.dev/posts/leetcode-1689/1689. Partitioning Into Minimum Number Of Deci-Binary Numbers The idea of this solution is that the max digit in n will be the result. But you might be wondering why this works. This works because the max digit can only be made by adding the max digit number of 1&rsquo;s. If you don&rsquo;t understand, look at the following image: The first image is an example, and the second example is for anyone who doesn&rsquo;t understand the first example.https://nathannaveen.dev/posts/leetcode-1605/Wed, 16 Jun 2021 11:21:28 -0500https://nathannaveen.dev/posts/leetcode-1605/1605. Find Valid Matrix Given Row and Column Sums The idea of this solution is pretty simple: We loop through len(rowSum), and len(colSum). We find the minimum for colSum[j], and rowSum[i], making the resulting matrix have the minimum. After that, we subtract the minimum from both colSum[j], and rowSum[i]. Here is an image example to help with the explanation: func restoreMatrix(rowSum []int, colSum []int) [][]int { res := make([][]int, len(rowSum)) for i := 0; i &lt; len(rowSum); i++ { arr := make([]int, len(colSum)) for j := 0; j &lt; len(colSum); j++ { arr[j] = colSum[j] if colSum[j] &gt; rowSum[i] { arr[j] = rowSum[i] } rowSum[i], colSum[j] = rowSum[i] - arr[j], colSum[j] - arr[j] } res[i] = arr } return res }https://nathannaveen.dev/posts/leetcode-406/Wed, 16 Jun 2021 11:21:17 -0500https://nathannaveen.dev/posts/leetcode-406/406. Queue Reconstruction by Height The idea of this solution is to: sort people&rsquo;s height in non-decreasing order, and when two people have the same height, we sort their kth place in non-increasing order. And then we add the following person to the resulting array in the kth vacant position (zero-indexed), like in this image: As you can see in row 1, k = 4, so we add the person of height 4 into res at position 4.https://nathannaveen.dev/posts/leetcode-1338/Wed, 16 Jun 2021 11:21:07 -0500https://nathannaveen.dev/posts/leetcode-1338/1338. Reduce Array Size to The Half The idea of the first solution is to: Find the frequency of all values in arr using a map called m. Then add all the values of m to an array called h. Then reverse sort h. Then loop through h, and subtract the maximum frequencies to be removing the minimum number of integers. While subtracting check whether n &lt;= len(arr) / 2 if so return i + 1.https://nathannaveen.dev/posts/leetcode-1663/Wed, 16 Jun 2021 11:21:00 -0500https://nathannaveen.dev/posts/leetcode-1663/1663. Smallest String With A Given Numeric Value This solution aims to make all the characters equal 'a' to start with, and then subtract n from k because we have added n amount of 'a'&rsquo;s. After that, we can keep removing 'z'&rsquo;s until k &gt; 25, then we can remove the letter with an ASCII of k + 'a'. func getSmallestString(n int, k int) string { k -= n res := make([]string, n) for i := 0; i &lt; n; i++ { res[i] = &#34;a&#34; } for i := len(res) - 1; i &gt;= 0; i-- { if k &lt;= 25 { res[i] = string(k + &#39;a&#39;) break } else { res[i] = &#34;z&#34; k -= 25 } } return strings.https://nathannaveen.dev/posts/leetcode-1154/Wed, 16 Jun 2021 11:20:54 -0500https://nathannaveen.dev/posts/leetcode-1154/Note: I know that the second solution is pretty un-orthidoxed because we would have to change a lot of stuff if the input changed. 1154. Day of the Year How the first solution works: The first solution is pretty simple: We find the year month and day (Note: We call the day res because the day is only used for adding to the result) We also have an array of the number of days per month Then we check whether it is a leep year, if so add 1 day to the result.https://nathannaveen.dev/posts/leetcode-1880/Wed, 16 Jun 2021 11:19:46 -0500https://nathannaveen.dev/posts/leetcode-1880/1880. Check if Word Equals Summation of Two Words The idea of the first solution is: We loop through every word and add the string(letter - '1') (basically add the string of the letter made into a number). Then we make that string into a number and check whether temp + temp2 == tempRes. The First Code: func isSumEqual(firstWord string, secondWord string, targetWord string) bool { first, second, res := &#34;&#34;, &#34;&#34;, &#34;&#34; for _, letter := range firstWord { first += string(letter - &#39;0&#39;) } for _, letter := range secondWord { second += string(letter - &#39;0&#39;) } for _, letter := range targetWord { res += string(letter - &#39;0&#39;) } temp, _ := strconv.https://nathannaveen.dev/posts/leetcode-1318/Wed, 16 Jun 2021 11:19:38 -0500https://nathannaveen.dev/posts/leetcode-1318/1318. Minimum Flips to Make a OR b Equal to c The idea of this solution is pretty simple because getting a || b == c means that: If the last bit of c is 1: a can be either 1 if b is 1 or b is 0, or 0 if b is 1 Else if the last bit of c is 0: a and b have to be 0 because 0 || 0 == 0 is the only case which == 0.https://nathannaveen.dev/posts/leetcode-1858/Mon, 17 May 2021 09:50:59 -0500https://nathannaveen.dev/posts/leetcode-1858/1858. Longest Word With All Prefixes This solution aims to sort words so we get the previous prefix of the max word before the word. An example of this could be words = [&quot;k&quot;, &quot;kiran&quot;,&quot;ki&quot;,&quot;kira&quot;,&quot;kir&quot;] and when we sort, it becomes words = [&quot;k&quot;,&quot;ki&quot;,&quot;kir&quot;,&quot;kira&quot;, &quot;kiran&quot;]. Then we can use a map to build up the word. If the len(word) is equal to 1, we know that it is a start of a word, or if the map contains word without the last letter, we know that there is the prefix of the word.https://nathannaveen.dev/posts/leetcode-1816/Mon, 17 May 2021 09:50:53 -0500https://nathannaveen.dev/posts/leetcode-1816/1816. Truncate Sentence Since the solution wants us to return the first k words We can split the words Then we can return the the first k words joined together seperated by spaces. The Solution func truncateSentence(s string, k int) string { return strings.Join(strings.Split(s, &#34; &#34;)[:k], &#34; &#34;) } Edited Solution for readability func truncateSentence(s string, k int) string { arr := strings.Split(s, &#34; &#34;) return strings.Join(arr[:k], &#34; &#34;) }https://nathannaveen.dev/posts/leetcode-1252/Mon, 17 May 2021 09:50:46 -0500https://nathannaveen.dev/posts/leetcode-1252/1252. Cells with Odd Values in a Matrix The idea of this solution is to use two maps, x, and y, and we can add all the values of indices to x, and y (index[0] to x, and index[1] to y). Then we can check whether all the x&rsquo;s plus all the y&rsquo;s is odd. If so, we know that we can add one to the result. If you don&rsquo;t understand we can take an example:https://nathannaveen.dev/posts/leetcode-1180/Mon, 17 May 2021 09:50:40 -0500https://nathannaveen.dev/posts/leetcode-1180/1180. Count Substrings with Only One Distinct Letter The idea of this solution is to use the number of consecutive letters. And to use the formula n * (n + 1) / 2 to find the number of valid substrings. We can use the example below to explain: Before the example: n * (n + 1) / 2 is the equation for finding the sum of the first n consecutive elements.https://nathannaveen.dev/posts/leetcode-1833/Mon, 17 May 2021 09:50:14 -0500https://nathannaveen.dev/posts/leetcode-1833/1833. Maximum Ice Cream Bars To be truthful, I think that this problem&rsquo;s difficulty should be easy instead of medium. This solution aims to sort costs because the maximum number of popsicles is obtained with the least price. func maxIceCream(costs []int, coins int) int { sort.Ints(costs) res := 0 for _, cost := range costs { if coins - cost &lt; 0 { break } res++ coins -= cost } return res }https://nathannaveen.dev/posts/leetcode-1827/Mon, 17 May 2021 09:50:09 -0500https://nathannaveen.dev/posts/leetcode-1827/1827. Minimum Operations to Make the Array Increasing The ideas of both of the solutions are similar and simple. We know that an array is strictly increasing if the current element in the array, nums[i], is greater than the previous element nums[i - 1]. So if nums[i - 1] is greater than or equal to nums[i] we know that we have to make nums[i] = nums[i - 1] + 1.https://nathannaveen.dev/posts/leetcode-1331/Mon, 17 May 2021 09:49:56 -0500https://nathannaveen.dev/posts/leetcode-1331/1331. Rank Transform of an Array The idea of this solution is to: Copy arr. Then sort the copy Then loop through the copy and add all the values and indexes of the copy to a map called m. Then loop through 0 to len(arr) - 1, and make arr[i] = m[arr[i]]. Then return arr. func arrayRankTransform(arr []int) []int { g := make([]int, len(arr)) m := make(map[int]int) counter := 1 copy(g, arr) sort.https://nathannaveen.dev/posts/leetcode-36/Mon, 17 May 2021 09:32:30 -0500https://nathannaveen.dev/posts/leetcode-36/36. Valid Sudoku The main idea of this solution is to find the rows, columns, and squares of the numbers. By squares, I mean the nine squares in the board: The code goes through every position, and if the value is not a &quot;.&quot;, we check whether the row, column, or square contains the number. If so, we can return false. How to Calculate The Rows And Columns We check whether the row or column contains the number by using primes.https://nathannaveen.dev/posts/leetcode-958/Wed, 05 May 2021 15:45:43 -0500https://nathannaveen.dev/posts/leetcode-958/958. Check Completeness of a Binary Tree This solution uses the facts that: If there is a next row, we know that the whole row has to be full If there is no next row, all the nodes have to be to the left. If you have already looked at the code, you might have seen that we check whether there is a next row by checking whether queue[0].Left != nil.https://nathannaveen.dev/posts/leetcode-1572/Wed, 05 May 2021 15:45:36 -0500https://nathannaveen.dev/posts/leetcode-1572/1572. Matrix Diagonal Sum The idea of the first solution is to add all the values in the diagonals, and if len(mat) is odd, we can subtract the middle element from res. You might be able to understand this solution a little more with two example images: The idea of the second solution is to find two positions in the array (Where a position is in the format (x, y)) which are on diagonals and are equal.https://nathannaveen.dev/posts/leetcode-103/Mon, 03 May 2021 10:26:05 -0500https://nathannaveen.dev/posts/leetcode-103/103. Binary Tree Zigzag Level Order Traversal The idea of this solution is to use BFS and a variable called fromRight. The fromRight checks whether the current row needs to be traversed from the right. If it does, we prepend all the nodes to temp. func zigzagLevelOrder(root *TreeNode) [][]int { var res [][]int queue := []*TreeNode{root} fromRight := false for len(queue) != 0 { temp := []int{} n := len(queue) for i := 0; i &lt; n; i++ { node := queue[0] queue = queue[1:] if node !https://nathannaveen.dev/posts/leetcode-1609/Mon, 03 May 2021 10:17:57 -0500https://nathannaveen.dev/posts/leetcode-1609/1609. Even Odd Tree The main idea of this solution is to use BFS, but the details are: We have a counter called row to count every row (We use this to check whether it is an even row or an odd row). Then we have a queue that has only the root to start. We loop while len(queue) != 0 Then we make a variable n equal to the len(queue).https://nathannaveen.dev/posts/leetcode-107/Mon, 03 May 2021 10:17:25 -0500https://nathannaveen.dev/posts/leetcode-107/107. Binary Tree Level Order Traversal II First solution: faster than 100% Second solution: faster than 100% I put in the edited for people who don&rsquo;t code in go because people who don&rsquo;t code in go won&rsquo;t understand res = append(res[:0], append([][]int{temp}, res[0:]...)...). So if you don&rsquo;t understand the first solution look at the edited. First solution: func levelOrderBottom(root *TreeNode) [][]int { res := [][]int{} queue := []*TreeNode{root} for len(queue) !https://nathannaveen.dev/posts/leetcode-1602/Mon, 03 May 2021 10:17:00 -0500https://nathannaveen.dev/posts/leetcode-1602/1602. Find Nearest Right Node in Binary Tree The idea of this solution is to use a queue to loop through the tree, and then for every node we loop through, we check whether the node.Val == u.Val, if so, we go through the if statement if i == n - 1. Using this, we know whether the node is the last. If so, we return nil. Else we return the node after the current node.https://nathannaveen.dev/posts/leetcode-1161/Mon, 03 May 2021 10:16:45 -0500https://nathannaveen.dev/posts/leetcode-1161/1161. Maximum Level Sum of a Binary Tree What the Problem is Asking Us: The problem is asking us to go through each level of the binary tree and find the maximum sum and make that the returned level, but if the maximum sum is on two levels, we get the minimum level of those two. The Code: func maxLevelSum(root *TreeNode) int { maximum, minLevel, level := root.Val, 1, 0 queue := []*TreeNode{root} for len(queue) !https://nathannaveen.dev/posts/leetcode-844/Wed, 28 Apr 2021 21:33:02 -0500https://nathannaveen.dev/posts/leetcode-844/844. Backspace String Compare To be truthful I am not sure whether this solution is an O(n) time or a O(2n) time because this code loops through s then t. Could someone tell me which it is? So the idea of this solution is: *Note: I will be explaining only the loop for s because the loop for s is pretty much the same as the loop for t. So the code first loops from 0 to len(s).https://nathannaveen.dev/posts/leetcode-720/Wed, 28 Apr 2021 21:30:47 -0500https://nathannaveen.dev/posts/leetcode-720/720. Longest Word in Dictionary The idea of this solution is pretty simple: The code will sort words, so the minor parts we use to build the biggest words are before the built-up words. Also, since words is sorted, we don&rsquo;t have to worry about the &ldquo;longest word with the smallest lexicographical order&rdquo;; we only have to care about the &ldquo;longest word&rdquo; part. After that, the code will loop through words.https://nathannaveen.dev/posts/leetcode-500/Wed, 28 Apr 2021 21:30:43 -0500https://nathannaveen.dev/posts/leetcode-500/500. Keyboard Row I know that this code is not pretty, but the idea of the solution is pretty simple: We can first make a map of letters where the top rows letters are assigned to the number 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, the middle row&rsquo;s characters are assigned to the numbers 10, 11, 12, 13, 14, 15, 16, 17, 18, and the last rows characters are assigned to the numbers 19, 20, 21, 22, 23, 24, 25.https://nathannaveen.dev/posts/leetcode-1374/Mon, 26 Apr 2021 07:51:50 -0500https://nathannaveen.dev/posts/leetcode-1374/1374. Generate a String With Characters That Have Odd Counts This solution is relatively straightforward. All it does is if n is odd, we can return n numbers of 'a', but if n is even, we can return a count of n - 1, 'a'&rsquo;s plus one 'b'. You might be wondering why we are doing n number of a&rsquo;s for when n is odd and n - 1 number of a&rsquo;s and a b for when n is even.https://nathannaveen.dev/posts/leetcode-1232/Sun, 25 Apr 2021 21:15:52 -0500https://nathannaveen.dev/posts/leetcode-1232/1232. Check If It Is a Straight Line The idea of this solution is we use 3 points to find whether two slopes are equal. We can use the equation: where x0, x1, x2, y0, y1, y2 are all coordinates: You might not understand the equation, so we can multiply divide both sides by (x1 - x0) and (x2 - x1) and we can get: The equation above is based off of a familar slope equation: The reason we are doing the original equation instead of the where we have divided both sides by (x1 - x0) and (x2 - x1) is we don&rsquo;t have to worry about dividing by 0 such as when we divide both sides by (x1 - x0) and (x2 - x1) but (x1 - x0) = 0 or (x2 - x1) = 0 we have to contumplate what to do.https://nathannaveen.dev/posts/leetcode-1564/Sun, 25 Apr 2021 18:43:09 -0500https://nathannaveen.dev/posts/leetcode-1564/1564. Put Boxes Into the Warehouse I The idea of this solution is: We sort boxes. Then, we make an array called minimums, and put the minimum values of warehouse from left to right into the array. If you don&rsquo;t understand, look at the following images: Then we can just look from len(minimums) - 1 to 0 and check whether minimums[i] &gt;= boxes[boxCounter] we can go to the next box, other wise we continue going through the loop until minimums[i] &gt;= boxes[boxCounter].https://nathannaveen.dev/posts/leetcode-1422/Sun, 25 Apr 2021 11:08:11 -0500https://nathannaveen.dev/posts/leetcode-1422/1422. Maximum Score After Splitting a String The idea of the first solution is pretty simple, and the second solution is based on the first solution. The idea of the first solution is: We loop through s and add all the numbers to a counter called numberOfOnes to count the number of ones. We do this by using ASCII. The ASCII of 0 is 48, and the ASCII of 1 is 49, so we can get the int of s[i] and then subtract 48 from it to get 0 or 1.https://nathannaveen.dev/posts/leetcode-748/Sun, 25 Apr 2021 11:08:04 -0500https://nathannaveen.dev/posts/leetcode-748/Shortest Completing Word Here is how I got to this solution. I couldn&rsquo;t think of any way to solve this problem without doing a naive solution, so I looked at the discussion and saw jmcelvenny&rsquo;s solution. The idea of this solution is: we get all the letters in licensePlate and multiply each letter&rsquo;s prime number to a variable called product. We have an array of 26 prime numbers, so each letter has its own prime number (upper case and lower case of the same letter share a prime number), such as a : primes[0], b : primes[1], c : primes[2], and A : primes[0], B : primes[1], C : primes[2].https://nathannaveen.dev/posts/leetcode-1151/Thu, 22 Apr 2021 09:14:35 -0400https://nathannaveen.dev/posts/leetcode-1151/1151. Minimum Swaps to Group All 1&rsquo;s Together The idea of this solution is: We find the number of 1&rsquo;s. Then we know that the 1&rsquo;s have to be in a subarray of the length of all the 1&rsquo;s. We know that this works because the problem statement says that all the 1&rsquo;s should be together in any place. Since we know that all the ones should be in a substring of length the number of ones in data, we just have to find the substring with the maximum number of 1&rsquo;s in it already so, we get the minimum switches.https://nathannaveen.dev/posts/leetcode-859/Thu, 22 Apr 2021 09:14:13 -0400https://nathannaveen.dev/posts/leetcode-859/859. Buddy Strings To check whether two strings are buddy strings we have to check whether: len(a) == len(b) if a == b, and there is a duplicate letter in a if there are a[j] != b[j] and a[i] != b[i] and a[j] == b[i] and a[i] == b[j] func buddyStrings(a string, b string) bool { if len(a) != len(b) { return false } m := make(map[uint8]int) temp := -1 counter := 0 for i := 0; i &lt; len(a); i++ { m[a[i]]++ if a == b &amp;&amp; m[a[i]] == 2 { return true } if a[i] !https://nathannaveen.dev/posts/leetcode-1176/Mon, 19 Apr 2021 10:48:25 -0400https://nathannaveen.dev/posts/leetcode-1176/1176. Diet Plan Performance This is how the code works: We sum up the first k elements. Then compare whether sum is greater than upper or smaller than lower. After comparing we can loop from k to len(calories). Then we can take off the beggining of the subarray by subtracting calories[i - k]. And then we have to add the next element from the end of the subarray to the end to the subarray, we do this by adding calories[i].https://nathannaveen.dev/posts/leetcode-1323/Mon, 19 Apr 2021 10:48:16 -0400https://nathannaveen.dev/posts/leetcode-1323/1323. Maximum 69 Number This solution is pretty simple once you understand it. The idea of this solution is since 9 - 6 = 3, so 6 + 3 = 9. When we add 3 * the current place value to 6 * the current place value we get 9 * the current place value. So if we do 60 + (3 * 10) = 90, 600 + (3 * 100) = 900, 6000 + (3 * 1000) = 9000.https://nathannaveen.dev/posts/leetcode-392/Mon, 19 Apr 2021 10:48:01 -0400https://nathannaveen.dev/posts/leetcode-392/392. Is Subsequence func isSubsequence(s string, t string) bool { sCounter, i := 0, 0 for i &lt; len(t) &amp;&amp; sCounter &lt; len(s) { if t[i] == s[sCounter] { sCounter++ } i++ } return sCounter == len(s) }https://nathannaveen.dev/posts/leetcode-229/Sat, 17 Apr 2021 09:23:24 -0400https://nathannaveen.dev/posts/leetcode-229/229. Majority Element II This solution is pretty simple: We loop through nums We add 1 to a map of integers called m, so we add 1 to m[num] where num is the current number in nums. Then we check whether m[num] == len(nums) / 3 + 1 this is checking whether the element is a majority element. Note: We can&rsquo;t do m[num] &gt;= len(nums) / 3 + 1. This can be shown with an example:https://nathannaveen.dev/posts/leetcode-1100/Fri, 16 Apr 2021 10:48:46 -0400https://nathannaveen.dev/posts/leetcode-1100/1100. Find K-Length Substrings With No Repeated Characters The Idea Of This Solution: This solution aims to use a counter called counter to count the number of duplicates. Also, when counter == 0, the substring has no duplicates. How This Solution Works: First, we make the variables counter, res, and m. counter is the duplicate counter, res is the resulting number of substrings that have unique characters, and m is a map that is used to find out whether a character is a duplicate.https://nathannaveen.dev/posts/leetcode-1822/Thu, 15 Apr 2021 09:40:17 -0400https://nathannaveen.dev/posts/leetcode-1822/1822. Sign of the Product of an Array The idea of this solution is elementary: If the current number in nums is negative, then we can flip the sign If the current number in nums is equal to 0, we can return 0 because any number multiplied by 0 is 0. You might think that we can check for if num == 0 after we have iterated, but that won&rsquo;t work because we only switch the sign and don&rsquo;t multiply by 0, so we will never know whether there is a 0 in the array.https://nathannaveen.dev/posts/leetcode-1800/Thu, 15 Apr 2021 08:50:00 -0400https://nathannaveen.dev/posts/leetcode-1800/1800. Maximum Ascending Subarray Sum The idea of this solution is pretty simple: We need two variables, sum for the current sum of ascending values and maximum for the maximum sum. Then we loop through nums. Inside the loop, we check whether the current number is greater than the previous number. If so, we can add the number to sum. Else the number is smaller than or equal to the previous number, we can make maximum equal to the math.https://nathannaveen.dev/posts/leetcode-119/Thu, 15 Apr 2021 08:49:51 -0400https://nathannaveen.dev/posts/leetcode-119/119. Pascal&rsquo;s Triangle II I will explain the first solution. If you want to understand the second solution click on the link above the code. So the first solution only wants us to return the last row of the triangle. Since we need two rows always for this problem the current row and the previous row. In this problem res is the current row and temp is the previous row.https://nathannaveen.dev/posts/leetcode-118/Wed, 14 Apr 2021 12:29:07 -0400https://nathannaveen.dev/posts/leetcode-118/118. Pascal&rsquo;s Triangle The idea of this solution is pretty simple: We first have a matrix array called res Then we loop through numRows While iterating through numRows we have to make an array called temp. It is going to be our current row. We make temp[0] and temp[len(temp)] equal to 1 so we get the outer 1&rsquo;s. Then we loop through the middle elements (basically excluding the outside 1&rsquo;s) We have to make every temp[j] equal to the previous rows previous rows[j - 1] + previous rows[j].https://nathannaveen.dev/posts/leetcode-56/Wed, 14 Apr 2021 09:58:31 -0400https://nathannaveen.dev/posts/leetcode-56/func merge(intervals [][]int) [][]int { res := [][]int{} for i := 1; i &lt; len(intervals); i++ { if i &gt;= 1 &amp;&amp; intervals[i-1][0] &gt; intervals[i][0] { intervals[i-1], intervals[i] = intervals[i], intervals[i-1] i -= 2 } } res = append(res, intervals[0]) for i := 1; i &lt; len(intervals); i++ { if res[len(res)-1][1] &gt;= intervals[i][0] { res[len(res)-1][1] = max(intervals[i][1], res[len(res)-1][1]) } else { res = append(res, intervals[i]) } } return res } func max(a, b int) int { if a &gt; b { return a } return b }https://nathannaveen.dev/posts/leetcode-824/Wed, 14 Apr 2021 09:58:25 -0400https://nathannaveen.dev/posts/leetcode-824/824. Goat Latin The idea of this solution is actualy pretty simple. We: First add all the vowels to a map. We make a a string where we keep on appending &quot;a&quot; to it per word. Then we split S by spaces so we get all the words in an array called words. Then we loop through words. Inside the iteration we check whether the first letter of the current word is not a vowel we can move the first letter to the end.https://nathannaveen.dev/posts/leetcode-252/Tue, 13 Apr 2021 10:11:45 -0400https://nathannaveen.dev/posts/leetcode-252/252. Meeting Rooms The Idea Of The Solutions: The idea of these two solutions is pretty simple because the second solution is based on the first solution, and the first solution is pretty simple. The idea of the first solution is: First, we sort intervals. Then, we check whether the previous interval&rsquo;s ends intersect with the following interval&rsquo;s beginning. The idea of the second solution is: While sorting, we check for overlaps.https://nathannaveen.dev/posts/leetcode-1551/Sat, 10 Apr 2021 20:14:34 -0500https://nathannaveen.dev/posts/leetcode-1551/1551. Minimum Operations to Make Array Equal This is a pretty simple solution once you understand the concept. What the Problem Is Asking: The problem gives us an array where arr[i] = (2 * i) + 1, you could make an array where every arr[i] = (2 * i) + 1 but I am just going to tell you that this plots a sequence of odd integers. Bascily arr[1, 3, 5 .https://nathannaveen.dev/posts/leetcode-1742/Sat, 10 Apr 2021 09:44:53 -0500https://nathannaveen.dev/posts/leetcode-1742/1742. Maximum Number of Balls in a Box The idea of this solution is pretty simple: We use a map to store all the elements and their frequencies, and we use a variable called maximum to store the maximum frequency. We loop from lowLimit to highLimit. Inside the first loop, we make a nested loop to sum up all the digits of each number between lowLimit and highLimt. After we have got the sum, we do m[sum]++ because we have to add one to the frequency of sum.https://nathannaveen.dev/posts/leetcode-1426/Sat, 10 Apr 2021 09:44:48 -0500https://nathannaveen.dev/posts/leetcode-1426/1426. Counting Elements This solution is straightforward, and the idea of this solution is we add all the values of arr into a map called m. All we do is check whether m contains arr[i] + 1. If it does, we can add one to the resulting counter. So the code: First, makes a map called m and a variable called res. Then we loop through arr and add all the values into m.https://nathannaveen.dev/posts/leetcode-1071/Fri, 09 Apr 2021 10:56:57 -0500https://nathannaveen.dev/posts/leetcode-1071/1071. Greatest Common Divisor of Strings The idea of this solution is actually pretty simple. But before we go into the problem, we have to know that a string with a common factor has a prefix (the definition of a prefix is the beginning characters of a string, a prefix can be any length) that is repeated throughout the string. This can be shown using some examples: &quot;abcdabcdabcd&quot; we know that the repeated substring is &quot;abcd&quot;, and we can see that &quot;abcd&quot; is a prefix.https://nathannaveen.dev/posts/leetcode-892/Fri, 09 Apr 2021 10:56:50 -0500https://nathannaveen.dev/posts/leetcode-892/892. Surface Area of 3D Shapes The Idea Of This Solution: This solution uses the fact that each stack of cubes surface area is the equation 2 + 4 * v. This works because each cube has 6 sides. This can be shown using some images: We can see that each cube has 6 planes. There are 4 sides, 1 top, and 1 bottom. Now, as we can see, there are 10 units of surface area while the other one only had 6, there are 8 sides, 1 top, and 1 bottom.https://nathannaveen.dev/posts/leetcode-1272/Wed, 07 Apr 2021 12:36:27 -0500https://nathannaveen.dev/posts/leetcode-1272/1272. Remove Interval What This Code Is Doing: We make a new resulting array and then loop through intervals. What we need to know for the following if and else statements is when the code loops through intervals, we get interval per iteration. interval is in the format [start, end]. Also, the constraints say -10^9 &lt;= start &lt; end &lt;= 10^9, so we can see that start and end are never on the exact same location and the start is always lesser than end.https://nathannaveen.dev/posts/leetcode-874/Wed, 07 Apr 2021 12:36:17 -0500https://nathannaveen.dev/posts/leetcode-874/874. Walking Robot Simulation Warning: This solution is pretty annoying. What The Problem is Telling Us: The problem description says that they will give an array called commands that tell you to turn right, left, or move forward, and they will also give you a matrix array called obstacles. obstacles is pretty self-explanatory. It is points where an obstacle is at. The points are in the format of (x, y).https://nathannaveen.dev/posts/leetcode-1475/Tue, 06 Apr 2021 09:57:29 -0500https://nathannaveen.dev/posts/leetcode-1475/1475. Final Prices With a Special Discount in a Shop This solution is pretty simple just loop through prices and then find the first price smaller than the current one. After that, remake prices[i] the current price minus the minimum. The Code: func finalPrices(prices []int) []int { for i, price := range prices { minimum := 1001 for j := i + 1; j &lt; len(prices); j++ { if prices[j] &lt;= price { minimum = prices[j] break } } if minimum !https://nathannaveen.dev/posts/leetcode-633/Mon, 05 Apr 2021 12:24:12 -0500https://nathannaveen.dev/posts/leetcode-633/633. Sum of Square Numbers Both solutions use the simple knowledge of: If c = a^2 + b^2 then b^2 = c - a^2 and a^2 = c - b^2. The Idea of the First Solution: The idea of this solution is pretty simple since we know that a^2 = c - b^2 we can store a^2 in a map called m, and then we check whether m contains c - b^2.https://nathannaveen.dev/posts/leetcode-1465/Mon, 05 Apr 2021 12:23:52 -0500https://nathannaveen.dev/posts/leetcode-1465/1465. Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts What The Problem Is Asking: The problem is telling us that there are cuts in a rectangular cake of width w and height h. The cuts are only horizontal and vertical. The problem wants us to find the largest slice of cake. The Main Idea of This Solution: We can find the maximum area slice by finding the maximum vertical length between each horizontal portion and the maximum horizontal length between each slice and then multiplying them together to get the maximum area.https://nathannaveen.dev/posts/leetcode-658/Sun, 04 Apr 2021 16:47:26 -0500https://nathannaveen.dev/posts/leetcode-658/658. Find K Closest Elements What The Problem Is Asking: The problem asks us to find the k closest elements in an array to the value x. We find the distance between elements by doing |value - x| and the k elements with the smallest distances. The Main Idea Of This Solution: Since we have to find the k closest elements, we can sort the array from the smallest distance to the greatest distance.https://nathannaveen.dev/posts/how-the-manual-sort-works/Sun, 04 Apr 2021 16:40:14 -0500https://nathannaveen.dev/posts/how-the-manual-sort-works/The idea of this is pretty simple: We check whether the previous number is greater than the current number. If it is switch the two values in the array around and subtract two from i (i = The current position). After that we subtract 2 from i because we want to go back by one position. We subtract 2 to go back 1 because we add one to i in the for loop.https://nathannaveen.dev/posts/leetcode-734/Fri, 02 Apr 2021 13:08:17 -0500https://nathannaveen.dev/posts/leetcode-734/734. Sentence Similarity The idea of this solution is to: We have to first check whether the lengths of the two sentences are the same. If they aren&rsquo;t, we return false. Then we have to make a map called m. The map is in a format of string, []string where string is the key and []string is the value. We add all the values from the matrix array called similarPairs to m.https://nathannaveen.dev/posts/leetcode-1118/Thu, 01 Apr 2021 13:15:33 -0500https://nathannaveen.dev/posts/leetcode-1118/1118. Number of Days in a Month To start, I wouldn&rsquo;t say that this is a good interview problem because it is not an algorithmic problem. The months and the number of days in each month can be shown in the table below: In February, it can be either 28 days or 29 days. 28 days in a regular year and 29 days in a leap year. We can see that if the month is January, March, May, July, August, October, December, we return 31 days.https://nathannaveen.dev/posts/leetcode-1708/Thu, 01 Apr 2021 11:53:48 -0500https://nathannaveen.dev/posts/leetcode-1708/1708. Largest Subarray Length K The idea of this solution is pretty simple we get every subarray so length k. We get the max subarray, compare it with the current subarray, and then check which array is greater, the current subarray, or the maximum subarray. We compare subarrays by looping through the length of the subarrays (They are both have the same size). Every time we iterate, we check whether the index of the current subarray is greater than the index of the max subarray and the opposite.https://nathannaveen.dev/posts/leetcode-246/Thu, 01 Apr 2021 10:34:39 -0500https://nathannaveen.dev/posts/leetcode-246/246. Strobogrammatic Number This solution is pretty simple and pretty similar to Leetcode 163. The problem asks us to flip a number by 180 degrees and then return true if the fliped number is equal to the non-fliped number. You might think that just flipping every digit and then check whether the following fliped number is equal to the non fliped number, but there is a problem with just flipping. Here is an example to show that just flipping doesn&rsquo;t work:https://nathannaveen.dev/posts/leetcode-1427/Tue, 30 Mar 2021 13:23:55 -0500https://nathannaveen.dev/posts/leetcode-1427/1427. Perform String Shifts The idea of this solution is pretty simple. Since there are only two directions, we can shift the strings in one direction. The reason we can shift in only one direction is when the input tells us to shift First left and then right: The right might cancel out the left and will end up with no shift. The right might be greater than the left, so we shift right.https://nathannaveen.dev/posts/leetcode-163/Fri, 26 Mar 2021 10:27:54 -0400https://nathannaveen.dev/posts/leetcode-163/1427. Perform String Shifts The idea of this solution is pretty simple. Since there are only two directions, we can shift the strings in one direction. The reason we can shift in only one direction is when the input tells us to shift First left and then right: The right might cancel out the left and will end up with no shift. The right might be greater than the left, so we shift right.https://nathannaveen.dev/posts/leetcode-1791/Wed, 24 Mar 2021 12:35:49 -0400https://nathannaveen.dev/posts/leetcode-1791/1791. Find Center of Star Graph This solution is straightforward. We first make an array called nodes with edges + 1 values. We need edges + 1 values because len(edges) is the number of edge nodes, and the + 1 is for the center node. We only need edges + 1 nodes because the nodes are from 1...n. Then we loop through edges and get each edge. edge[0] and edge[1] are the two values given per edge.https://nathannaveen.dev/posts/leetcode-1213/Wed, 24 Mar 2021 10:44:39 -0400https://nathannaveen.dev/posts/leetcode-1213/1213. Intersection of Three Sorted Arrays What The Problem Asks: The problem statement is: Given three integer arrays arr1, arr2 and arr3 sorted in strictly increasing order, return a sorted array of only the integers that appeared in all three arrays. They are giving us an input of three strictly increasing arrays, and we have to find all the numbers that repeat in all three arrays. This problem statement&rsquo;s critical thing is strictly increasing because strictly increasing is different from Non-decreasing.https://nathannaveen.dev/posts/leetcode-360/Tue, 23 Mar 2021 12:20:59 -0400https://nathannaveen.dev/posts/leetcode-360/360. Sort Transformed Array The idea of this solution is to loop through nums and do the quadratic equation f(x) = ax^2 + bx + c where x = nums[i] and then make nums[i] the result of the ax^2 + bx + c. After that we can sort and return nums. Solution Using Manual Sort func sortTransformedArray(nums []int, a int, b int, c int) []int { for i := 0; i &lt; len(nums); i++ { nums[i] = a*nums[i]*nums[i] + b*nums[i] + c } for i := 1; i &lt; len(nums); i++ { if i &gt;= 1 &amp;&amp; nums[i] &lt; nums[i-1] { nums[i], nums[i-1] = nums[i-1], nums[i] i -= 2 } } return nums } The Same Solution But Using a Built In Sort:https://nathannaveen.dev/posts/leetcode-1198/Mon, 22 Mar 2021 12:57:36 -0400https://nathannaveen.dev/posts/leetcode-1198/1198. Find Smallest Common Element in All Rows m = len(mat), n = len(mat[0]) speed = O(mn) space = O(number of unique numbers) What The Problem Is Asking: The problem description is Given a matrix mat where every row is sorted in strictly increasing order, return the smallest common element in all rows. If there is no common element, return -1. The problem is asking us to return an element that appears in every array of the matrix array, and if there are multiple, we should return the smallest.https://nathannaveen.dev/posts/leetcode-296/Mon, 22 Mar 2021 11:57:20 -0400https://nathannaveen.dev/posts/leetcode-296/296. Best Meeting Point What the Problem Is Asking: The problem gives us an input binary matrix array called grid. If grid[i][j] = 1 then it is a house of a friend, and if grid[i][j] = 0 then there is no house there. The problem asks us to find a point on the grid that is the smallest distance to walk from all the houses. Note that the point on the grid with the smallest distance can be on a house or an empty space.https://nathannaveen.dev/posts/leetcode-1121/Sun, 21 Mar 2021 22:01:48 -0400https://nathannaveen.dev/posts/leetcode-1121/1121. Divide Array Into Increasing Sequences What the Problem is Asking Us To Do: The problem statement is: Given a non-decreasing array of positive integers nums and an integer K, find out if this array can be divided into one or more disjoint increasing subsequences of length at least K. What this is saying is: We are first given a sorted array of positive integers called nums and an integer K for our input.https://nathannaveen.dev/posts/leetcode-1214/Sun, 21 Mar 2021 11:36:17 -0400https://nathannaveen.dev/posts/leetcode-1214/1214. Two Sum BSTs Quick Run-Down On The Solutions The first solution is the easiest of the three solutions and the worst-time complexity solution. The second solution has a different approach from the first solution and a little better time but still not that great. The third solution has a lot better time than the first two solutions and has a similar approach to the second solution. The Ideas of These Solutions:https://nathannaveen.dev/posts/leetcode-272/Fri, 19 Mar 2021 09:50:42 -0400https://nathannaveen.dev/posts/leetcode-272/272. Closest Binary Search Tree Value II The idea of this solution is pretty simple, we just iterate through the tree and append the absolute difference between the popped value and target to an array called differences, then we append the popped value to an array called eachNumber. After we have iterated through the whole array we can sort the difference array while sorting the eachNumber array. After that we return the first k numbers from eachNumber.https://nathannaveen.dev/posts/leetcode-1762/Fri, 19 Mar 2021 09:39:06 -0400https://nathannaveen.dev/posts/leetcode-1762/1762. Buildings With an Ocean View The idea of the solution: The idea of this solution is to loop through the array heights backwards. Then we just have to find if a height that is greater that the curent height. After that we can reverse the resulting array because the problem asks us to give us the sorted array of indexes that have an ocean view. If you don&rsquo;t understand the explaination just look at the following images:https://nathannaveen.dev/posts/leetcode-1134/Thu, 18 Mar 2021 17:44:12 -0400https://nathannaveen.dev/posts/leetcode-1134/1134. Armstrong Number The idea of this solution is to just loop through every digit of n then add the n^(lengthOfNumber) to a variable called sum, then we return sum == n. func isArmstrong(n int) bool { lengthOfNumber := len(strconv.Itoa(n)) sum := 0 newN := n for newN &gt; 0 { sum += powerOfK(lengthOfNumber, newN%10) newN /= 10 } return sum == n } func powerOfK(lengthOfNumber, n int) int { res := 1 for i := 0; i &lt; lengthOfNumber; i++ { res *= n } return res }https://nathannaveen.dev/posts/leetcode-1085/Thu, 18 Mar 2021 17:43:55 -0400https://nathannaveen.dev/posts/leetcode-1085/1085. Sum of Digits in the Minimum Number The idea of the first two solutions is pretty simple. We sort the array A and then we just find the sum of the digits of the smallest number. The idea of the second solution is pretty simple as well. We loop through A and find the minimum value, and the find the sum of the digits of the smallest number. Solution: (Using a manual sort).https://nathannaveen.dev/posts/leetcode-1133/Thu, 18 Mar 2021 17:43:48 -0400https://nathannaveen.dev/posts/leetcode-1133/1133. Largest Unique Number Here are two ways to solve this solution: One way is to use an array of size 1001 which we call h (1001 because in the notes it says 0 &lt;= A[i] &lt;= 1000) and add one to h[A[i]]. Now we can see that the array will be sorted because we add the number of numbers to h. So all we have to do is iterate through h backward and check whether the value of h[i] == 1.https://nathannaveen.dev/posts/leetcode-1469/Thu, 18 Mar 2021 14:11:02 -0400https://nathannaveen.dev/posts/leetcode-1469/1469. Find All The Lonely Nodes The idea of this solution is pretty simple, there are just four conditions: if there is a left node but not a right node if there is a right node but not a left node if there is both a left and a right node if there are neither a left or a right node We can ignore the part where there is neither a left or a right node.https://nathannaveen.dev/posts/leetcode-270/Thu, 18 Mar 2021 14:10:52 -0400https://nathannaveen.dev/posts/leetcode-270/270. Closest Binary Search Tree Value The idea of this solution is pretty simple. We have to iterate through the tree and then find the absolute minimum difference between the target and the value from the tree. (Keep in mind that we want everything to be a float64, so then we get proper comparisons). This can be shown with the equation: The Code: func closestValue(root *TreeNode, target float64) int { stack := []*TreeNode{root} minimum := float64(1000000000) number := 0 for len(stack) !https://nathannaveen.dev/posts/leetcode-266/Thu, 18 Mar 2021 14:10:37 -0400https://nathannaveen.dev/posts/leetcode-266/266. Palindrome Permutation The idea of this solution is pretty simple. We add all the letters to a map, and then if there is a extra letter that does not have a partner for the other end of the palindrome add it to the numberOfOnes counter, if the counter is greater than 1 we know that it is not a palindrome. We can explain this with some examples: There are three main examples that are going to be shown:https://nathannaveen.dev/posts/leetcode-292/Thu, 18 Mar 2021 12:19:52 -0400https://nathannaveen.dev/posts/leetcode-292/292. Nim Game func canWinNim(n int) bool { return n%4 != 0 } This is all the code we need to solve this problem. We have to return n % 4 != 0 because we are asked to pick from 1 to 3 stones, and if we pick; If we pick one stone, the other player can choose three stones If we pick two stones, the other player can select two stones If we pick three stones, the other player can choose one stone As you can see, when we add the stones together in the examples above, they all equal 4 stones.https://nathannaveen.dev/posts/leetcode-1119/Thu, 18 Mar 2021 11:32:48 -0400https://nathannaveen.dev/posts/leetcode-1119/1119. Remove Vowels from a String The first approach is pretty simple. If the letter is not a vowel, add it to a resulting string. The second approach is better because we keep on using the same string. We remake the string every time there is a vowel by going around the vowel. This can be shown with some images: We can have: input: &#34;leetcode&#34; expected output: &#34;ltcd&#34; We can fast forward to our first vowel, 'e'.https://nathannaveen.dev/posts/leetcode-1138/Thu, 18 Mar 2021 11:32:42 -0400https://nathannaveen.dev/posts/leetcode-1138/1138. Alphabet Board Path I have to admit the code might look daunting but it is actualy not that complicated after I explain it to you. What the Problem is asking: The problem asks us to make a board of letters: [ [a, b, c, d, e] [f, g, h, i, j] [k, l, m, n, o] [p, q, r, s, t] [u, v, w, x, y] [z] ] Then it gives us a word target.https://nathannaveen.dev/posts/leetcode-1041/Tue, 16 Mar 2021 12:41:13 -0400https://nathannaveen.dev/posts/leetcode-1041/1041. Robot Bounded In Circle What the problem is asking: The problem says that it will give a string with the letters &quot;L&quot;, &quot;R&quot; and &quot;G&quot; to command a robot. &quot;L&quot; means to turn left 90 degrees, &quot;R&quot; means to turn right 90 degrees, and &quot;G&quot; means to go forward one unit. The problem says to return true if the robot can continue in that pattern forever and keep going in a circle.https://nathannaveen.dev/posts/leetcode-692/Mon, 15 Mar 2021 11:52:46 -0400https://nathannaveen.dev/posts/leetcode-692/692. Top K Frequent Words The Main Idea: This solution first adds the words to an array called frequency and sorts frequency after that, return the k most frequency words. Adding to the array Frequency: You might be confused when we do this part: for _, ints := range frequency { if words[ints[0]] == word { contains = true ints[1]++ break } } We can simplify the if statement into if words[frequency[i][0]] = word.https://nathannaveen.dev/posts/leetcode-1721/Sun, 14 Mar 2021 15:57:58 -0400https://nathannaveen.dev/posts/leetcode-1721/1721. Swapping Nodes in a Linked List The idea of this solution is pretty simple. First, we find the length of the linked list Next, we iterate through the linked list up until the ending kth node And then we iterate through the linked list to to kth node Then, last of all, switch the value of the kth node with the value of the kth node from the end. Finding the length of the linked list is pretty simple.https://nathannaveen.dev/posts/leetcode-1329/Sat, 13 Mar 2021 10:42:03 -0500https://nathannaveen.dev/posts/leetcode-1329/1329. Sort the Matrix Diagonally The idea of this solution is kind of hard to explain so I will show it with the following images: i = len(mat), and j = len(mat[0]) The yellow part is every where i and j will iterate the diagonal lines are in red Before we continue you might be confused about why we switch 2 and 1 even though i = 1 and j = 1.https://nathannaveen.dev/posts/leetcode-1461/Fri, 12 Mar 2021 12:03:46 -0500https://nathannaveen.dev/posts/leetcode-1461/1461. Check If a String Contains All Binary Codes of Size K The idea of this solution is to make a sliding window and add all the substrings os size k to a map, if the maps length is equal to 2^k return true. We do 2^k because we have to acount for all posibilitys of 0 and 1. func hasAllCodes(s string, k int) bool { m := make(map[string]int) for i := 0; i &lt; len(s)-k+1; i++ { m[s[i:i+k]]++ } return len(m) == twoPow(k) } func twoPow(k int) int { res := 1 for i := 0; i &lt; k; i++ { res *= 2 } return res } By using bit maniplation we can simplify the code, left shifting is basicly multiplying by 2.https://nathannaveen.dev/posts/leetcode-1401/Fri, 12 Mar 2021 11:01:21 -0500https://nathannaveen.dev/posts/leetcode-1401/1401. Circle and Rectangle Overlapping The Main Idea The idea of this solution is to find the distance from the middle of the circle to the edge of a rectangle, and if the distance is smaller than or equal to the radius, we know that the rectangle overlaps with the circle. If you don&rsquo;t understand, look at the following images: As you can see, the circle and the rectangle do not overlap, and this can be shown by the distance between the center of the circle and the closest edge of the rectangle.https://nathannaveen.dev/posts/leetcode-836/Wed, 10 Mar 2021 12:10:01 -0500https://nathannaveen.dev/posts/leetcode-836/836. Rectangle Overlap This solution is pretty similar to my other solution Leetcode: 223 This is the part in the other solution which I based this solution on: // A = rec1[0], B = rec1[1], C = rec1[2], D = rec1[3] // E = rec2[0], F = rec2[1], G = rec2[2], H = rec2[3] left, right := max(A, E), min(G, C) up, down := min(D, H), max(F, B) if right &gt; left &amp;&amp; up &gt; down { sum -= (right - left) * (up - down) // overlap } The idea of this solution can be shown using some images:https://nathannaveen.dev/posts/leetcode-1750/Tue, 09 Mar 2021 21:04:18 -0500https://nathannaveen.dev/posts/leetcode-1750/1750. Minimum Length of String After Deleting Similar Ends The idea of this solution is pretty simple, so it can be shown with this image: func minimumLength(s string) int { for len(s) &gt; 1 &amp;&amp; s[0] == s[len(s)-1] { end := s[len(s)-1] lenS := len(s) for i := 0; i &lt; lenS; i++ { if s[len(s)-1] != s[0] { s = s[:len(s)-i-1] break } } lenS = len(s) for i := 0; i &lt; lenS; i++ { if s[0] !https://nathannaveen.dev/posts/leetcode-1752/Tue, 09 Mar 2021 21:04:13 -0500https://nathannaveen.dev/posts/leetcode-1752/1752. Check if Array Is Sorted and Rotated The idea of this solution is to loop through the array, and then check whether there is a nums[i] which is greater than nums[(i+1) % len(nums)] (By the way (i+1) % len(nums) is for getting the next number) if nums[i] &gt; nums[(i+1)%len(nums)] then add one to a counter called counter. Then we check whether counter is greater than or equal to 2.https://nathannaveen.dev/posts/leetcode-1784/Mon, 08 Mar 2021 14:31:01 -0500https://nathannaveen.dev/posts/leetcode-1784/1784. Check if Binary String Has at Most One Segment of Ones The problem description is: Given a binary string s without leading zeros, return true if s contains at most one contiguous segment of ones. Otherwise, return false. This is kind of hard to understand, so I am going to explain it. A contiguous segment of ones looks like: 111000 100 10 1 11110000 And some of the ones that are not contiguous are:https://nathannaveen.dev/posts/leetcode-1332/Mon, 08 Mar 2021 09:42:56 -0500https://nathannaveen.dev/posts/leetcode-1332/1332. Remove Palindromic Subsequences This problem asks us to find all the subsequences in a string called s. s only contains the letters a and b. When we are doing this problem, the main thing to look at is that it says &ldquo;subsequences,&rdquo; not &ldquo;substrings,&rdquo; and that there are only two letters a and b. The difference between &ldquo;substrings&rdquo; and &ldquo;subsequences&rdquo; is substrings are consecutive letters, while subsequences doesn&rsquo;t have to be consecutive.https://nathannaveen.dev/posts/leetcode-915/Mon, 08 Mar 2021 08:20:50 -0500https://nathannaveen.dev/posts/leetcode-915/The idea of this solution is to find the max of the left and then check whether the max is always smaller than all the rights. If it is smaller than all of them return the index (1 indexed). This can be shown with a picture: func partitionDisjoint(A []int) int { max := A[0] for i := 0; i &lt; len(A); i++ { shouldReturn := true if max &lt; A[i] { max = A[i] } for j := i + 1; j &lt; len(A); j++ { if A[j] &lt; max { shouldReturn = false break } } if shouldReturn { return i + 1 } } return -1 }https://nathannaveen.dev/posts/leetcode-973/Sun, 07 Mar 2021 10:43:03 -0500https://nathannaveen.dev/posts/leetcode-973/973. K Closest Points to Origin The New Distance Formula: The Euclidean Distance Formula equals (I have drawn this in a picture because the symbols don&rsquo;t aline up when writen up in text) This can be simplifyed by taking out the square root. We can take out the square root because we are not finding the minimum distance but the point with the minimum distance, and the distance doesn&rsquo;t need to be square rooted.https://nathannaveen.dev/posts/leetcode-1773/Sat, 06 Mar 2021 19:06:10 -0500https://nathannaveen.dev/posts/leetcode-1773/1773. Count Items Matching a Rule The idea of this solution is pretty simple. We know that the array items has only 3 items. The first one is the ruleKey = &quot;type&quot; the next one is ruleKey = &quot;color&quot;, and the next one is ruleKey = &quot;name&quot;. We just have to set a index of each item to either 0, 1 or 2. Then just loop over each item and check whether the item[index] == ruleValue.https://nathannaveen.dev/posts/leetcode-1779/Sat, 06 Mar 2021 19:05:54 -0500https://nathannaveen.dev/posts/leetcode-1779/1779. Find Nearest Point That Has the Same X or Y Coordinate What The Problem Is Asking: This problem asks you to find the smallest Manhattan distance from a given point to a matrix array of points called points. The problem also asks you to only find the Manhattan distance of the points that have the same x value as the first given point, or the same y value as the given point.https://nathannaveen.dev/posts/leetcode-223/Fri, 05 Mar 2021 11:04:23 -0500https://nathannaveen.dev/posts/leetcode-223/223. Rectangle Area The main idea of this solution is to find the area of each indivigual rectangle and then add them together. After that subtract the overlap of both of them. If you don&rsquo;t understand the ABCDRectangle and the EFGHRectangle then look at the following images: We can have the example: Let us start of with the ABCDRectangle: When we do the equation (D - B) * (C - A) we are basicly doing width * length.https://nathannaveen.dev/posts/leetcode-908/Thu, 04 Mar 2021 15:47:37 -0500https://nathannaveen.dev/posts/leetcode-908/908. Smallest Range I func smallestRangeI(A []int, K int) int { max, min := A[0], A[0] for _, i := range A { if i &gt; max {max = i} if i &lt; min {min = i} } if max-min-2*K &gt; 0 { return max - min - 2 * K } return 0 }https://nathannaveen.dev/posts/leetcode-347/Thu, 04 Mar 2021 15:47:24 -0500https://nathannaveen.dev/posts/leetcode-347/347. Top K Frequent Elements The idea of this solution is pretty simple. First, add all the numbers to a matrix array with the size [number of different elements][2]. Then sort the array, and then add the values to a regular array of size K. The matrix array has a size of [number of different elemtnets][2] because we need to add every element to its corresponding place in the array and then update the frequency by adding one to it.https://nathannaveen.dev/posts/leetcode-833/Thu, 04 Mar 2021 10:24:54 -0500https://nathannaveen.dev/posts/leetcode-833/833. Find And Replace in String func findReplaceString(S string, indexes []int, sources []string, targets []string) string { res := &#34;&#34; for i := 0; i &lt; len(S); i++ { index := 0 // this is the index that is used for indexes, sources, and targets for i2, i3 := range indexes { if i3 == i { index = i2 // we do this because the indexes are not sorted } } if index &lt; len(indexes) &amp;&amp; i == indexes[index] { currentString := sources[index] isSubstring := true for i2 := range currentString { // checking whether the whole substring is equal if string(S[i+i2]) !https://nathannaveen.dev/posts/leetcode-1636/Wed, 03 Mar 2021 16:02:55 -0500https://nathannaveen.dev/posts/leetcode-1636/1636. Sort Array by Increasing Frequency The main idea of both the solutions is to add all the numbers to a matrix of lengths [len(nums)][2] and then sort each frequency of numbers by the max frequency. Suppose two values have the same frequency sort them by the value in descending order. After they are sorted, add all the values back to nums and return nums. This is the sort: for i := 1; i &lt; len(arr); i++ { if i &gt;= 1 &amp;&amp; ((arr[i-1][0] &gt; arr[i][0]) || (arr[i-1][0] == arr[i][0] &amp;&amp; arr[i-1][1] &lt; arr[i][1])) { arr[i], arr[i-1] = arr[i-1], arr[i] i -= 2 } } The idea of it is to start at the second item (first if 0 indexed) and then check whether the frequency of the number before the current is greater than the frequency of the current number.https://nathannaveen.dev/posts/leetcode-1385/Wed, 03 Mar 2021 13:25:26 -0500https://nathannaveen.dev/posts/leetcode-1385/1385. Find the Distance Value Between Two Arrays The idea of this solution is to iterate through arr1 and then inside each iteration iterate through arr2. If the absolute value of arr1[i] - arr2[j] is smaller than or equal to d, we know that arr1[i] can&rsquo;t be added to the resulting counter, so we can just break from the loop. There is a abs function because math.Abs takes longer. When using math.https://nathannaveen.dev/posts/leetcode-645/Tue, 02 Mar 2021 11:27:21 -0500https://nathannaveen.dev/posts/leetcode-645/645. Set Mismatch The idea of this solution is to add every number in the array nums to another array called temp. Next we go through the array temp and check whether the number of a certain number is equal to 2, if it is then we know that it is the repeated number. If it is not 2 but it is 0 we know that it is the skiped number.https://nathannaveen.dev/posts/leetcode-34/Tue, 02 Mar 2021 11:27:12 -0500https://nathannaveen.dev/posts/leetcode-34/34. Find First and Last Position of Element in Sorted Array Both of the solutions use a two pointer approche. The first solution is slower than the second solution because it checks an extra if statment inside the loop, while the second solution checks it outside of the loop. func searchRange(nums []int, target int) []int { left := 0 right := len(nums) - 1 for left &lt; right { if nums[left] !https://nathannaveen.dev/posts/leetcode-4/Mon, 01 Mar 2021 14:20:15 -0500https://nathannaveen.dev/posts/leetcode-4/4. Median of Two Sorted Arrays The idea of this solution is pretty simple, first append all the nums2 values to nums1. Then sort nums1. If there are a even number of values then the median is the middle two numbers added together and divided by 2. An example could be: input: nums1 = [1,2], nums2 = [3,4] expected output: 2.5 When the two arrays are combined the new array would be [1, 2, 3, 4] and the two middle numbers are 2, and 3.https://nathannaveen.dev/posts/leetcode-647/Mon, 01 Mar 2021 09:27:16 -0500https://nathannaveen.dev/posts/leetcode-647/647. Palindromic Substrings func countSubstrings(s string) int { res := 0 for i := 0; i &lt; len(s); i++ { for j := 0; j &lt;= len(s)-i; j++ { if s[j:j+i] != &#34;&#34; &amp;&amp; isPalindromic(s[j:j+i]) { res++ } } } if isPalindromic(s) { res++ } return res } func isPalindromic(s string) bool { left, right := 0, len(s)-1 for left &lt;= right { if s[left] != s[right] { return false } left++ right-- } return true }https://nathannaveen.dev/posts/leetcode-459/Sun, 28 Feb 2021 14:46:05 -0500https://nathannaveen.dev/posts/leetcode-459/459. Repeated Substring Pattern The idea of this solution is any substring that is repeated throughout the string s has to start at the 0&lsquo;th index and end at another index, such as the 3&lsquo;ed. This can be shown by using a image. In both the examples the substrings that are repeated are green. In the first example the substring abc starts at the 0&lsquo;th index and ends at the 2&rsquo;d index.https://nathannaveen.dev/posts/leetcode-5/Sun, 28 Feb 2021 11:41:58 -0500https://nathannaveen.dev/posts/leetcode-5/5. Longest Palindromic Substring In this solution we dont have to check whether the palindrome substring is greater than the max length substring because the length of the substring will always be greater than or equal to the length of the current max substring. This can be show in an image: func longestPalindrome(s string) string { max := &#34;&#34; for i := 0; i &lt; len(s); i++ { for j := 0; j &lt;= len(s)-i; j++ { if isPalindromic(s[j : j + i]) { max = s[j : j + i] // getting the substring } } } if isPalindromic(s) { max = s } return max } func isPalindromic(s string) bool { left, right := 0, len(s) - 1 for left &lt; right { if s[left] !https://nathannaveen.dev/posts/leetcode-1016/Fri, 26 Feb 2021 13:58:32 -0500https://nathannaveen.dev/posts/leetcode-1016/1016. Binary String With Substrings Representing 1 To N The idea of this solution is to loop through 1...N and then make the string by adding the bytes to a string called s. Then check if S contains the reversed string of the bytes. The string s is reversed by a helper function. func queryString(S string, N int) bool { for i := 1; i &lt;= N; i++ { s := &#34;&#34; n := i for n &gt; 0 { if n &amp; 1 == 1 { s += &#34;1&#34; } else { s += &#34;0&#34; } n &gt;&gt;= 1 } if !https://nathannaveen.dev/posts/leetcode-946/Fri, 26 Feb 2021 10:59:38 -0500https://nathannaveen.dev/posts/leetcode-946/The idea of this solution is to append the pushed value to the stack. If peeked value is equal to the poped value then pop it off the stack, keep poping off the peeked value if it is equal to the poped value. This can be show in an image func validateStackSequences(pushed []int, popped []int) bool { stack := []int{} popCounter := 0 for i := 0; i &lt; len(pushed); i++ { stack = append(stack, pushed[i]) for len(stack) !https://nathannaveen.dev/posts/leetcode-448/Fri, 26 Feb 2021 10:28:29 -0500https://nathannaveen.dev/posts/leetcode-448/448. Find All Numbers Disappeared in an Array The idea of this solution is to add all the numbers to a map and then check whether the map doesn&rsquo;t contain a number. If it doesn&rsquo;t contain then add it to the array arr. We return the array from the first position to the end because when we make the array it comes out with a 0 at the zeroth index. For example a input array could be [4,3,2,7,8,2,3,1].https://nathannaveen.dev/posts/leetcode-1704/Thu, 25 Feb 2021 20:22:25 -0500https://nathannaveen.dev/posts/leetcode-1704/The idea of this solution is to first make the input string lowercase, and then add 1 to an integer array at the index of every letter, a = 0, b = 1, c = 2.... First we add to the array called first, then starting at a certain index start adding it to second. After that, add the number of vowel that have occured. The code does this by doinghttps://nathannaveen.dev/posts/leetcode-1592/Thu, 25 Feb 2021 15:48:58 -0500https://nathannaveen.dev/posts/leetcode-1592/1592. Rearrange Spaces Between Words The idea of this solution is pretty simple, first split text by space. We have to split it manualy and not use a inbuild function because the text can contain multiple spaces inbetween words, and we have to count spaces. This can be show in an example: input = &#34; this is a sentence &#34; inbuiltSplit = [&#34;&#34;, &#34;&#34;, &#34;this&#34;, &#34;&#34;, &#34;&#34;, &#34;is&#34;, &#34;&#34;, &#34;a&#34;, &#34;sentence&#34;, &#34;&#34;] The Code:https://nathannaveen.dev/posts/leetcode-501/Thu, 25 Feb 2021 15:48:23 -0500https://nathannaveen.dev/posts/leetcode-501/501. Find Mode in Binary Search Tree The idea of this solution is to iterate through the tree, and add all the values to a map. Then get all the max values of the map and add them to the result array. func findMode(root *TreeNode) []int { max := 0 m := make(map[int]int) res := []int{} stack := []*TreeNode{} stack = append(stack, root) for len(stack) != 0 { pop := stack[len(stack)-1] stack = stack[:len(stack)-1] if pop !https://nathannaveen.dev/posts/leetcode-1768/Thu, 25 Feb 2021 15:48:01 -0500https://nathannaveen.dev/posts/leetcode-1768/1768. Merge Strings Alternately The idea of this solution is pretty simple. First loop through the word with the greater length. Then check whether the length of the word is greater than the current characters index, if so then add the character to the result. func mergeAlternately(word1 string, word2 string) string { res := &#34;&#34; for i := 0; i &lt; int(math.Max(float64(len(word1)), float64(len(word2)))); i++ { if i &lt; len(word1) { res += string(word1[i]) } if i &lt; len(word2) { res += string(word2[i]) } } return res }https://nathannaveen.dev/posts/leetcode-1296/Thu, 25 Feb 2021 15:47:35 -0500https://nathannaveen.dev/posts/leetcode-1296/Divide array in sets of k consecutive numbers The idea of this solution is to loop over the nums array until all the values are -1. The reason they all will become negative one is, whenever a item is used the value will become -1 so the code knows to not use that number again. If you didn&rsquo;t understand the explanation this can be shown using the code on the bottom, an example and some pictures: By the way sorry if my handwriting is messyhttps://nathannaveen.dev/posts/leetcode-1566/Thu, 25 Feb 2021 15:46:57 -0500https://nathannaveen.dev/posts/leetcode-1566/1566. Detect Pattern of Length M Repeated K or More Times The idea of this can be show by this image func containsPattern(arr []int, m int, k int) bool { counter := 0 for i := 0; i &lt; len(arr) - m; i++ { if arr[i] != arr[i+m] { counter = 0 } else { counter++ } if counter == (k-1)*m { return true } } return false }https://nathannaveen.dev/posts/leetcode-976/Thu, 25 Feb 2021 13:50:15 -0500https://nathannaveen.dev/posts/leetcode-976/976. Largest Perimeter Triangle The idea of this solution is to sort the array and then keep on checking the largest three side lengths. In the problem it asks us to &ldquo;return the largest perimeter of a triangle with non-zero area.&rdquo; Non-zero area means a triangle with the two smaller side lengths that add up to be greater than the greatest side length. This can be show in a couple imageshttps://nathannaveen.dev/posts/leetcode-1523/Wed, 24 Feb 2021 17:03:24 -0500https://nathannaveen.dev/posts/leetcode-1523/1523. Count Odd Numbers in an Interval Range The idea of this solution is to get the number odd numbers from 0 to high, and then subtract the number of odd numbers from 0 to low - 1. The idea can be shown by an example: high: 7 low : 3 The odd numbers from 0 to high (7). There are 4 odd numbers from 0 to 7. The odd numbers from 0 to low - 1 (2).https://nathannaveen.dev/posts/leetcode-1637/Wed, 24 Feb 2021 16:52:08 -0500https://nathannaveen.dev/posts/leetcode-1637/1637. Widest Vertical Area Between Two Points Containing No Points points = {x, y} The idea of this solution is to ignore the y part of points because the vertical area is the made of vertical lines. Vertical lines are made up off one x value for every y value. An example could be the line x = 3, this is a vertical line at the x value 3. The code first puts all the x points in the array xPoints.https://nathannaveen.dev/sink/advent-of-code-day-10/Mon, 01 Jan 0001 00:00:00 +0000https://nathannaveen.dev/sink/advent-of-code-day-10/Day 10 puzzle The idea of both solutions is to just use a stack. For the first part we just have to detect whether we have an incorrect line. func oneDay10() int { input, _ := ioutil.ReadFile(&#34;input10.txt&#34;) var arr = strings.Split(string(input), &#34;\n&#34;) res := 0 for _, line := range arr { stack := []string{} for i := 0; i &lt; len(line); i++ { char := string(line[i]) if char == &#34;(&#34; || char == &#34;[&#34; || char == &#34;{&#34; || char == &#34;&lt;&#34; { stack = append(stack, char) } else { pop := stack[len(stack)-1] stack = stack[:len(stack)-1] if char == &#34;)&#34; &amp;&amp; pop !https://nathannaveen.dev/sink/advent-of-code-day-11/Mon, 01 Jan 0001 00:00:00 +0000https://nathannaveen.dev/sink/advent-of-code-day-11/Day 11 puzzle For day 11, part 1 was pretty easy. For part two I tried all types of different solutions, but all I could get working is the brute force approach. I by mistake wrote my part 2 code over my part one code, so here it is: type p struct { i, j int } var arr = [][]int{} func twoDay11() int { input, _ := ioutil.ReadFile(&#34;input11.txt&#34;) var arr2 = strings.https://nathannaveen.dev/sink/advent-of-code-day-12/Mon, 01 Jan 0001 00:00:00 +0000https://nathannaveen.dev/sink/advent-of-code-day-12/Day 12 puzzle I got to both of my solutions by thing of them as a tree. For part one we can use a DFS approach. Basically find every path from &quot;start&quot; to &quot;end&quot;. And if we find a lowercase word we can add it to a map, so we know we have visited that position. Part two is pretty similar, we can pretty much the same thing, but we have to check if only one of the lowercase letters has been looped over twice, so I made a variable called hasDoneTwice.https://nathannaveen.dev/sink/advent-of-code-day-3/Mon, 01 Jan 0001 00:00:00 +0000https://nathannaveen.dev/sink/advent-of-code-day-3/Advent Of Code Day 3 2021 Part One The first solution is pretty simple, so I just brute forced it. func oneDay3() { file, err := os.Open(&#34;input3.txt&#34;) if err != nil { panic(err) } defer file.Close() scanner := bufio.NewScanner(file) arr := make([]int, 12) gamma := 0 epsilon := 0 pos := 1 for scanner.Scan() { temp := scanner.Text() for i := 0; i &lt; len(temp); i++ { if temp[i] == &#39;1&#39; { arr[i]++ } else { arr[i]-- } } } for i := len(arr) - 1; i &gt;= 0; i-- { if arr[i] &gt; 0 { gamma += pos } else { epsilon += pos } pos *= 2 } fmt.https://nathannaveen.dev/sink/advent-of-code-day-8/Mon, 01 Jan 0001 00:00:00 +0000https://nathannaveen.dev/sink/advent-of-code-day-8/Day 8 Puzzle func oneDay8() { file, err := os.Open(&#34;input8.txt&#34;) // opening the file if err != nil { panic(err) } defer file.Close() scanner := bufio.NewScanner(file) res := 0 for scanner.Scan() { temp := scanner.Text() // getting the line arr := strings.Split(temp, &#34; | &#34;) words := strings.Split(arr[1], &#34; &#34;) for _, s := range words { if len(s) == 2 || len(s) == 4 || len(s) == 3 || len(s) == 7 { res++ } } } fmt.https://nathannaveen.dev/sink/advent-of-code-day-9/Mon, 01 Jan 0001 00:00:00 +0000https://nathannaveen.dev/sink/advent-of-code-day-9/Day 9 puzzle Part One I think that the first part of day 9 was pretty easy, just check every values and whether it is smaller than all the adjacent values. If so add that value plus 1 to res. func oneDay9() { input, _ := ioutil.ReadFile(&#34;input9.txt&#34;) var arr = strings.Split(string(input), &#34;\n&#34;) res := 0 i, j := 0, 0 isLow := func(y, x int) bool { // I put this function inside twoDay9() // because then I wouldn&#39;t have to parse i, j, and arr which would make it really messy.