[mintheon] Week 1

contains-duplicate/mintheon.java

@@ -0,0 +1,13 @@
+import java.util.Arrays;
+
+class Solution {
+  public boolean containsDuplicate(int[] nums) {
+    Arrays.sort(nums);
+    for(int i = 1; i < nums.length; i++) {
+      if(nums[i] == nums[i - 1]) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

house-robber/mintheon.java

@@ -0,0 +1,28 @@
+class Solution {
+  public int rob(int[] nums) {
+    int[] sums = new int[nums.length];
+
+    sums[0] = nums[0];
+
+    if (nums.length > 1) {
+      sums[1] = nums[1];
+    }
+
+    if (nums.length > 2) {
+      sums[2] = nums[0] + nums[2];
+    }
+
+    if (nums.length > 3) {
+      for (int i = 3; i < nums.length; i++) {
+        sums[i] = Math.max(nums[i] + sums[i - 2], nums[i] + sums[i - 3]);
+      }
+    }
+
+    int max = 0;
+    for(int sum : sums) {
+      max = Math.max(sum, max);
+    }
+
+    return max;
+  }
+}

longest-common-subsequence/mintheon.java

@@ -0,0 +1,30 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+  public int longestConsecutive(int[] nums) {
+    Set<Integer> numSet = new HashSet<>();
+
+    for(int num : nums) {
+      numSet.add(num);
+    }
+
+    int longestSize = 0;
+
+    for(int num : numSet) {
+      if(!numSet.contains(num - 1)) {
+        int current = num;
+        int count = 1;
+
+        while(numSet.contains(current + 1)) {
+          count++;
+          current++;
+        }
+
+        longestSize = Math.max(count, longestSize);
+      }
+    }
+
+    return longestSize;
+  }
+}

top-k-frequent-elements/mintheon.java

@@ -0,0 +1,24 @@
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.PriorityQueue;
+
+class Solution {
+  public int[] topKFrequent(int[] nums, int k) {
+    int[] answer = new int[k];
+    Map<Integer, Integer> frequent = new HashMap<>();
+
+    for(int num: nums) {
+      frequent.put(num, frequent.getOrDefault(num, 1) + 1);
+    }
+
+    PriorityQueue<Entry<Integer, Integer>> pq = new PriorityQueue<>((a, b) -> b.getValue().compareTo(a.getValue()));
+    pq.addAll(frequent.entrySet());
+
+    for(int i = 0; i < k; i++) {
+      answer[i] = pq.poll().getKey();
+    }
+
+    return answer;
+  }
+}

valid-palindrome/mintheon.java

@@ -0,0 +1,27 @@
+class Solution {
+  public boolean isPalindrome(String s) {
+    int start = 0;
+    int end = s.length() - 1;
+
+    while(start < end) {
+      if(!Character.isLetterOrDigit(s.charAt(start))) {
+        start++;
+        continue;
+      }
+
+      if(!Character.isLetterOrDigit(s.charAt(end))){
+        end--;
+        continue;
+      }
+
+      if(Character.toLowerCase(s.charAt(start)) != Character.toLowerCase(s.charAt(end))) {
+        return false;
+      }
+
+      start++;
+      end--;
+    }
+
+    return true;
+  }
+}