In the town of Digitville, there was a list of numbers called nums containing integers from 0 to n - 1. Each number was supposed to appear exactly once in the list, however, two mischievous numbers sneaked in an additional time, making the list longer than usual.

As the town detective, your task is to find these two sneaky numbers. Return an array of size two containing the two numbers (in any order), so peace can return to Digitville.

Thoughts

• seems pretty simple, i think i’ll just use a hashset or something

Solution

class Solution {
    public int[] getSneakyNumbers(int[] nums) {
        HashSet<Integer> hs = new HashSet();
        int[] ans = new int[2];
        int ansNum = 0;

        for (int i : nums) {
            if (!hs.add(i)) {
                ans[ansNum] = i;
                ansNum++;
                if (ansNum == 2) return ans;
            } 
        }
        return ans;
    }
}

Time Complexity: O(n)
Space Complexity: O(n)

Conclusion

ezpz hashset solution. I think there may be a better way though.

Q2: Maximum Multiplication Score

You are given an integer array a of size 4 and another integer array b of size at least 4.

You need to choose 4 indices i<sub>0</sub>, i<sub>1</sub>, i<sub>2</sub>, and i<sub>3</sub> from the array b such that i<sub>0</sub> < i<sub>1</sub> < i<sub>2</sub> < i<sub>3</sub>. Your score will be equal to the value a[0] * b[i<sub>0</sub>] + a[1] * b[i<sub>1</sub>] + a[2] * b[i<sub>2</sub>] + a[3] * b[i<sub>3</sub>].

Return the maximum score you can achieve.

Thoughts

• best solution i could come up with was a brute force, I’m almost certain there is a way to do this with dynamic programming

Solution

class Solution {
    public long maxScore(int[] a, int[] b) {
        long ans = Long.MIN_VALUE;
        for (int i = 0; i < b.length - 3; i++) {
            for (int j = i + 1; j < b.length - 2; j++) {
                for (int k = j + 1; k < b.length - 1; k++) {
                    for (int l = k + 1; l < b.length; l++) {
                        long temp = a[0] * b[i] + a[1] * b[j] + a[2] * b[k] + a[3] * b[l];
                        if (Long.compare(temp,ans) > 0) ans = temp;
                    }
                }
            }
        }

        return ans;
    }
}

Time Complexity: O(n^4)
Space Complexity: O(1)

Conclusion

Definitely should learn some more dynamic programming because this is (I think) a dynamic programming problem and my brute force solution is too slow to complete all of the test cases.

Overall Conclusion

Yea I really need to work on my DP knowledge, otherwise I am going to keep hitting performance walls like this.

Thoughts

• This one is basically identical to 2220 kekw

Solution

class Solution {
    public int hammingWeight(int n) {
        return Integer.bitCount(n);
    }
}

Time Complexity: O(1)
Space Complexity: O(1)

Conclusion

umm, these bit manipulation ones are pretty easy. I suppose I should find a way to calculate this myself and not use a built in function to do it. I can see providing this answer in an interview and being asked to provide a correct answer to it.

• For example, for x = 7, the binary representation is 111 and we may choose any bit (including any leading zeros not shown) and flip it. We can flip the first bit from the right to get 110, flip the second bit from the right to get 101, flip the fifth bit from the right (a leading zero) to get 10111, etc.

Given two integers start and goal, return the minimum number of bit flips to convert start to goal.

Thoughts

• I accidentally solved this one before I even had a chance to write down my thoughts about it 💀

Solution

class Solution {
    public int minBitFlips(int start, int goal) {
        return Integer.bitCount(start ^ goal);
    }
}

Time Complexity: O(1)
Space Complexity: O(1)

Conclusion

Idek what to say about this one it was so simple 💀

A binary tree's maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

Thoughts

• As with a lot of tree algorithms I think the best solution here is to use a recursive algorithm to count while traversing down the tree

Solution

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;

        return Math.max(maxDepth(root.left) + 1, maxDepth(root.right) + 1);
    }
}

Time Complexity: O(n)
Space Complexity: O(1)

Conclusion

Wow. This was much easier than I was thinking it would be lmao. I forgot just how easy this was. Still good review and gets me in a tree-thinking mindset.

Thoughts

• Seems like a pretty simple problem, I would imagine that doing this recursively would be the easiest way to go about it

  • Simply swap the left and right nodes, then recursively swap the child node's left and right nodes

Solution

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        // Handle null case
        if (root == null) return null;

        // Recursively swap the left and right nodes
        if (root.left != null && root.right != null) {
            TreeNode temp = root.right;
            root.right = root.left;
            root.left = temp;
            invertTree(root.left);
            invertTree(root.right);
        } else if (root.left == null) {
            root.left = root.right;
            root.right = null;
            invertTree(root.left);
        } else {
            root.right = root.left;
            root.left = null;
            invertTree(root.right);
        }

        return root;
    }
}

Time Complexity: O(n)
Space Complexity: O(n)

Conclusion

Pretty simple algorithm to implement and understand, good refresher on tree stuff. My space complexity is O(n) and I feel like there is a more space efficient algorithm to complete the task. I will revisit this problem in the future and try to devise a better algorithm.

Thoughts

• Pretty easy, simple as iterating through the list and building the list in reverse order

Solution

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode cur = head;
        ListNode newList = null;
        while (cur != null) {
            if (newList == null) {
                newList = new ListNode(cur.val);
            } else {
                ListNode newNode = new ListNode(cur.val, newList);
                newList = newNode;
            }
            cur = cur.next;
        }
        return newList;
    }
}

Time Complexity: O(n)
Space Complexity: O(n)

Conclusion

Pretty simple, but its good to brush up on concepts I haven't used in a while. I honestly can't remember the last time I had to manipulate a linked list so this was a nice refresher on that. Definitely need to work on some of the more complex linked list topics though.

• Each row is sorted in non-decreasing order.

• The first integer of each row is greater than the last integer of the previous row.

Given an integer target, return true if target is in matrix or false otherwise.

You must write a solution in O(log(m * n)) time complexity.

Thoughts

• I think this should be as simple as performing a binary search on the last index of each row, and then binary searching within the correct row from there

  • This should cut down on the number of searches made and achieve O(log m*n)

  • yea just two consecutive while loops seems to be the play here

Solution

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int rowLow = 0, rowHigh = matrix.length - 1;
        int colLow = 0, colHigh = matrix[0].length - 1;
        int row = 0;

        // Binary search by the last element of the rows to find which row the target would be in
        while (rowLow <= rowHigh) {
            int rowMid = ((rowHigh - rowLow) / 2) + rowLow;
            if (matrix[rowMid][matrix[rowMid].length - 1] >= target) {
                if (matrix[rowMid][matrix[rowMid].length - 1] == target) {
                    return true;
                }
                row = rowMid;
            }

            if (matrix[rowMid][matrix[rowMid].length - 1] > target) {
                rowHigh = rowMid - 1;
            } else {
                rowLow = rowMid + 1;
            }
        }

        // Binary search within the rows to find (or not find) the target
        while (colLow <= colHigh) {
            int colMid = ((colHigh - colLow) / 2) + colLow;
            if (matrix[row][colMid] == target) {
                return true;
            }

            if (matrix[row][colMid] > target) {
                colHigh = colMid - 1;
            } else {
                colLow = colMid + 1;
            }
        } 

        return false;
    }
}

Time Complexity: O(log m * n)
Space Complexity: O(1)

Conclusion

This one was much easier since I had just reviewed my binary search knowledge by doing 704. Binary Search. This was much more fun and interesting than just a regular binary search problem. I felt like my brain was more stimulated by this than 704. Overall though, I definitely still need to brush up on my data structures and algorithms knowledge. I can feel some of my knowledge there slipping away and I really would like to prevent that from happening.

You must write an algorithm with O(log n) runtime complexity.

Thoughts

• I mean, this is just a binary search....... idk that I have many other thoughts on this :sob:

Solution

class Solution {
    public int search(int[] nums, int target) {
        // Declare variables
        int h = nums.length - 1, l = 0;

        while (l <= h) {
            // Calculate the midpoint given the previous highs and lows
            int curIndex = ((h - l) / 2) + l;

            if (nums[curIndex] == target) {
                return curIndex;
            }

            // Set the highs and lows, excludes half of the data at a time for each iteration
            if (nums[curIndex] > target) {
                h = curIndex - 1;
            } else {
                l = curIndex + 1;
            }
        }

        return -1;
    }
}

Time Complexity: O(log n)
Space Complexity: O(1)

Conclusion

This one took me embarrassingly long to get. It has been a long time since I have had to use binary search, so it took me a while to remember how to do it. (Clearly I should've done more thinking about the question before I actually started!) Now that I have refreshed on it though, I feel way better about my understanding of it now, so perhaps this wasn't a complete wash.

An input string is valid if:

1. Open brackets must be closed by the same type of brackets.

2. Open brackets must be closed in the correct order.

3. Every close bracket has a corresponding open bracket of the same type.

Thoughts

• My immediate thought is that this problem is possible with some weird recursion-y thing

  • Although I imagine that this isn't super efficient as you have to perform many substring operations

  • nvm recursion is dumb for this

• I think a stack works better here

Solution

class Solution {
    public boolean isValid(String s) {
        if (s.length() <= 1) return false;
        Stack<Character> stack = new Stack();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '(' || c == '{' || c == '[') {
                stack.push(c);
            } else {
                if (stack.size() != 0) {
                    char c2 = stack.peek();
                    if (c == ')' && c2 == '(') stack.pop();
                    else if (c == '}' && c2 == '{') stack.pop();
                    else if (c == ']' && c2 == '[') stack.pop();
                    else return false;
                } else return false;

            }
        }

        if (stack.size() == 0) return true;
        return false;
    }
}

Time Complexity: O(n)
Space Complexity: O(n)

Conclusion

This took embarrassingly long for me to figure out for some reason. I definitely need to do more of these types of questions because the amount of time I just sank into this problem is simply ridiculous. Really the biggest part was actually accounting for the invalid cases, such as a string starting with a closing parenthesis or a string being only one parenthesis. Basically I need to work on better edge case detection when I am reading these questions and doing more thinking before I actually get started on writing my solutions.

You will walk in a clockwise spiral shape to visit every position in this grid. Whenever you move outside the grid's boundary, we continue our walk outside the grid (but may return to the grid boundary later.). Eventually, we reach all rows * cols spaces of the grid.

Return an array of coordinates representing the positions of the grid in the order you visited them.

Thoughts

• Immediately I wanted to create a 2D array for some reason, but I don't think that is necessary to actually solve this problem

• this seems relatively straight forward, just have to keep track of which cells are actually part of the grid

• testing for completion is probably as simple as checking that you have visited rows * cols cells

• i think using placeholder variables that keep track of the last horizontal and vertical distances traveled before turning would be the way to go, and then just checking along the way that the current indices are within the bounds of the rows and columns of the grid

Solution

class Solution {
    public int[][] spiralMatrixIII(int rows, int cols, int rStart, int cStart) {
        int[][] coords = new int[rows * cols][2];
        int curRow = rStart;
        int curCol = cStart;
        int lastHorizontal = 0;
        int lastVertical = 0;
        int curCoord = 0;

        coords[curCoord] = new int[]{rStart, cStart};
        curCoord++;

        while (curCoord < rows * cols) {
            // Right
            lastHorizontal++;
            for (int i = 0; i < lastHorizontal; i++) {
                curCol++;
                if ((curRow < rows && curRow >= 0) && (curCol < cols && curCol >= 0)) {
                    coords[curCoord] = new int[]{curRow, curCol};
                    curCoord++;
                }
            }

            // Down
            lastVertical++;
            for (int i = 0; i < lastVertical; i++) {
                curRow++;
                if ((curRow < rows && curRow >= 0) && (curCol < cols && curCol >= 0)) {
                    coords[curCoord] = new int[]{curRow, curCol};
                    curCoord++;
                }
            }

            // Left
            lastHorizontal++;
            for (int i = 0; i < lastHorizontal; i++) {
                curCol--;
                if ((curRow < rows && curRow >= 0) && (curCol < cols && curCol >= 0)) {
                    coords[curCoord] = new int[]{curRow, curCol};
                    curCoord++;
                }
            }

            // Up
            lastVertical++;
            for (int i = 0; i < lastVertical; i++) {
                curRow--;
                if ((curRow < rows && curRow >= 0) && (curCol < cols && curCol >= 0)) {
                    coords[curCoord] = new int[]{curRow, curCol};
                    curCoord++;
                }
            }
        }

        return coords;
    }
}

Time Complexity: O(rows * columns) == O(n)
Space Complexity: O(rows * columns)

Conclusion

This was actually a really fun problem in my opinion. The solution was pretty straightforward and I was able to get it implemented fairly quickly, it just took some debugging because of some silly errors. Like for when I was traversing left/right I was actually moving up/down, and vice-versa, and it took a while for me to figure that out. Overall though this problem was actually really fun.

An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Thoughts

• Probably can reuse at least part of my solution to 242: Valid Anagram

  • I think there would be a way to use a HashMap as the key and a String list as the value

  • Use my solution for 242: Valid Anagram to gather keys on each word of the input, gradually adding them to the map, if the same character array exists, then add it to that list, otherwise its a new anagram

    • SO turns out you can't use primitive arrays as keys because, since they are primitives, they don't refer to the same information if they were non-primitive. Primitive arrays with the same values are actually distinct memory from each other instead of how non-primitive objects function in that objects of the same type and value point to the same physical location in memory

      • Because of this I had to figure out how to do some weird streaming stuff to convert the frequency array into a list

Solution

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<List<Integer>, ArrayList<String>> anas = new HashMap<List<Integer>, ArrayList<String>>();

        for (String s : strs) {
            // Calculate letter frequency
            int[] freq = new int[26];
            for (char i : s.toCharArray()) {
                freq[i - 97]++;
            }
            // Do some weird Stream stuff because int[]'s with the same values are not actually the same
            List<Integer> t = IntStream.of(freq).boxed().collect(Collectors.toList());

            // If the frequency table doesn't exist, create it, otherwise add to the existing table.
            if (!anas.containsKey(t)) {
                ArrayList<String> temp = new ArrayList<String>();
                temp.add(s);
                anas.put(t, temp);
            } else {
                ArrayList<String> temp = anas.get(t);
                temp.add(s);
                anas.put(t, temp);
            }
        }

        List<List<String>> ans = new ArrayList<List<String>>();
        for (ArrayList<String> a : anas.values()) {
            ans.add(a);
        }

        return ans;
    }
}

Time Complexity: O(n * k), where k is the average number of characters per string in the input
Space Complexity: O(n)

Conclusion

My solution was not fast, likely due in part to the weird streaming stuff I did to convert from an integer array to a List. I think there is definitely a better way to approach this problem considering that my solution is amount the slowest submissions. Overall not terrible for a problem though, it led to me reviewing some of the internal workings of Java as how it relates to arrays and primitives.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Thoughts

• Immediately I know that this is possible using nested for-loops, but that isn't an efficient solution as it achieves an O(n²) runtime complexity

  • I will implement it like this anyway before trying to optimize

    •   class Solution {
            public int[] twoSum(int[] nums, int target) {
                int[] ans = new int[2];
                for (int i = 0; i < nums.length; i++) {
                    for (int j = 0; j < nums.length; j++) {
                        if (j == i) continue;
                        if (nums[i] + nums[j] == target) {
                            ans[0] = i;
                            ans[1] = j;
                        }
                    }
                }
                return ans;
            }
        }
      

    • Almost certain there is a faster way

• I think using a Map would potentially be a good way to do this

  • It would take O(n) to add all of the numbers to a Map, then another O(n) to find the correct other term, so overall O(n)

Solution

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> newNums = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i++) {
            newNums.put(nums[i], i);
        }

        for (int i = 0; i < nums.length; i++) {
            if (newNums.getOrDefault(target - nums[i], -1) != -1) {
                if (i == newNums.get(target - nums[i])) continue;
                return new int[]{i, newNums.get(target - nums[i])};
            }
        }

        return new int[2];
    }
}

Time Complexity: O(n)
Space Complexity: O(n)

Conclusion

Finally completed the infamous Two Sum. These are the types of problems that I like, where there is a really simple solution that is immediately obvious, but there are more complex solutions that are much better in a variety of ways.

Telephone keypads have keys mapped with distinct collections of lowercase English letters, which can be used to form words by pushing them. For example, the key 2 is mapped with ["a","b","c"], we need to push the key one time to type "a", two times to type "b", and three times to type "c" .

It is allowed to remap the keys numbered 2 to 9 to distinct collections of letters. The keys can be remapped to any amount of letters, but each letter must be mapped to exactly one key. You need to find the minimum number of times the keys will be pushed to type the string word.

Return the minimum number of pushes needed to type ​word ​after remapping the keys.

Thoughts

• Immediately before I even finished reading I am thinking this may involve a greedy algorithm

  • definitely a greedy problem

• need to represent the keypad, an array would work

• if there are less than 8 unique letters in the word, the obvious solution is to just remap all of the keys to have one of the less than 8 letters

  • the harder solution is when there is more than 8 characters that need to be mapped, in this case looking at the character frequency matters (I think) because you don't want to have to make multiple presses for a character you need a lot

    • like in example 3: the word is aabbccddeeffgghhiiiiii, so obviously you want i to be the first letter on a key so that you don't have to double push to get to i every time

  • I think that the best solution would be to sort the characters by their frequency within the word, and then just remap the keys with those characters in descending order

• was stumped for a while, but I think the solution is to disregard what the letters actually are after calculating the frequencies. I was getting too bogged down with trying to associate the specific letters with their specific frequencies, when really the specific letters don't matter, what matters is a letter has that frequency

  • the solution now seems to be to calculate the frequencies using a map, and then sorting the values in a separate data structure, then iterating through them in descending order to remap the characters

Solution

class Solution {
    public int minimumPushes(String word) {
        HashMap<Character, Integer> map = new HashMap();
        int pushes = 0;

        // Add all characters to the map with their frequencies
        for (char c : word.toCharArray()) {
            map.put(c, (map.containsKey(c) ? map.get(c) + 1 : 1));
        }

        // Sort the frequencies by descending order
        ArrayList<Integer> arr = new ArrayList(map.values());
        Collections.sort(arr, Collections.reverseOrder());

        // Iterate through the frequencies, and sum the pushes
        for (int i = 0; i < arr.size(); i++) {
            int key = (i / 8) + 1;
            pushes += key * arr.get(i);
        }

        return pushes;
    }
}

Time Complexity: O(n log n)
Space Complexity: O(n)

Conclusion

This one definitely took me a lot longer than it should have. I got too focused on the individual letters and their frequencies instead of just thinking about the frequencies as a whole. Because the specific frequency of j or q or a doesn't matter, what matters is the frequencies together since this problem is only asking about the number of pushes, not exactly how you would remap the keys. I should continue to work on similar problems to this so that I get more used to thinking in the correct way to see the answer.

Given an array of strings arr, and an integer k, return the kᵗʰ distinct string present in arr. If there are fewer than k distinct strings, return an empty string "".

Note that the strings are considered in the order in which they appear in the array.

Thoughts

• Definitely something with a hash table or map

• ordering is important here to get the kth distinct

• java's LinkedHashMap might be a good solution here as it is a hash map which allows for faster checking of duplicates via contains() while also maintaining the ordering of the elements

  • googled and found that there is a LinkedHashSet as well, which is more applicable here since there is no need for storing any value

  • Problem with this solution is actually getting the kth entry, neither of these classes provide methods allowing for getting arbitrary indices

    • LinkedHashSet has forEach() which could be hacked together to get the correct entry I think

      • can't break out of a lambda function, so forEach() might not be the solution here

      • can just set a temp variable equal to the correct index, the problem is that there is the problem of atomicity due to it being a lambda, although an AtomicReference would fix this

      • I make my life unnecessarily hard sometimes by doing things in silly ways

        • (Also had to use AtomicInteger so that my temp variable worked)

  • First solution:

    •         class Solution {
                  public String kthDistinct(String[] arr, int k) {
                      LinkedHashSet<String> lhs = new LinkedHashSet();
                      for (String s : arr) {
                          if (!lhs.add(s)) {
                              lhs.remove(s);
                          }
                      }
      
                      AtomicInteger i = new AtomicInteger(1);
                      AtomicReference<String> temp = new AtomicReference("");
                      lhs.forEach(s -> {
                          System.out.println(s);
                          if (i.intValue() == k) {
                              temp.set(s);
                          }
                          i.set(i.get() + 1);
                      });
      
                      return temp.toString();
                  }
              }
      

    • turns out this solution is flawed, as it allows for readding of duplicate entries back to the LinkedHashSet (ty ceru <3)

      • Ended up just adding another LinkedHashSet to it to contain duplicates, which I am pretty sure is not the optimal solution

Solution

class Solution {
    public String kthDistinct(String[] arr, int k) {
        LinkedHashSet<String> lhs = new LinkedHashSet();
        LinkedHashSet<String> olhs = new LinkedHashSet();

        // Iterate through arr, adding them to lhs if not a duplicate, olhs if they are        
        for (String s : arr) {
            if (olhs.contains(s) || !lhs.add(s)) {
                lhs.remove(s);
                olhs.add(s);
            }
        }

        // Using AtomicReferences here because of the lambda
        AtomicInteger i = new AtomicInteger(1);
        AtomicReference<String> temp = new AtomicReference("");
        lhs.forEach(s -> {
            // Iterate through all of the distinct values until finding the correct index
            if (i.intValue() == k) {
                temp.set(s);
            }
            i.set(i.get() + 1);
        });

        return temp.toString();
    }
}

Time Complexity: O(n)
Space Complexity: O(n)

Conclusion

Overall this one was relatively easy once I determined how I wanted to go about it. I had to reference the Javadocs for both LinkedHashSet and AtomicReference/AtomicInteger as I had forgotten the specifics of how they worked. I am also pretty sure that there is a better solution than using two LinkedHashSet, perhaps using just a LinkedHashMap instead and using the values to keep track of duplicates. It also took me a while to figure out exactly how I wanted to go about this solving this problem, I think with more practice though, this should get better.