Completed '3. Longest Substring With No Repeating Characters'

Author: OmnicWolf

README.md

@@ -23,6 +23,7 @@ TypeScript Solutions – [Ryo112358/leetcode-typescript](https://github.com/Ryo1
 
 ### Medium
 - <span title="Runtime Percentile: 67.95%">2. Add Two Numbers</span>
+- <span title="Runtime Percentile: 91.22%">3. Longest Substring Without Repeating Characters</span>
 - <span title="Runtime Percentile: 99.95%">6. ZigZag Conversion</span>
 - <span title="Runtime Percentile: 98.48%">11. Container With Most Water</span>
 - <span title="Runtime Percentile: 81.17%">12. Integer To Roman</span>

src/main/java/io/coffeelessprogrammer/leetcode/hard/TrappingRainWater.java

@@ -47,32 +47,43 @@ public static int calcVolume(int[] walls) {
         return totalTrappedWater;
     }
 
-    /** In progress */
+    // #region BruteForce
+
     public static int calcVolumeBF(int[] walls) {
         int totalTrappedWater = 0;
 
-        List<Integer> waterTrappedPerLevel;
+        for(int i=0; i < walls.length; ++i) {
+            int maxLeft = findHeightTallestLeftWall(walls, i);
+            int maxRight = findHeightTallestRightWall(walls, i);
 
-        for(int i=1; i < walls.length; ++i) {
-            if(walls[i] > 0) {
-                waterTrappedPerLevel = new ArrayList<>();
+            int currentWater = Math.min(maxLeft, maxRight) - walls[i];
 
-                for(int j=i+1; j < walls.length && walls[j] < walls[i]; ++j) {
+            if(currentWater > 0)
+                totalTrappedWater += currentWater;
+        }
 
-                    System.out.println(waterTrappedPerLevel.size());
-                    for(int k=1; k < walls[i]; ++k) {
-                        waterTrappedPerLevel.add(walls[i] - walls[j]);
-                    }
-                }
+        return totalTrappedWater;
+    }
 
-                System.out.println(Arrays.toString(waterTrappedPerLevel.toArray()));
+    private static int findHeightTallestLeftWall(int[] walls, int startingIndex) {
+        int tallestWall = 0;
 
-                for(int volumeAtDepth: waterTrappedPerLevel) {
-                    totalTrappedWater += volumeAtDepth;
-                }
-            }
+        for(int i=startingIndex; i > -1; --i) {
+            tallestWall = Math.max(walls[i], tallestWall);
         }
 
-        return totalTrappedWater;
+        return tallestWall;
     }
+
+    private static int findHeightTallestRightWall(int[] walls, int startingIndex) {
+        int tallestWall = 0;
+
+        for(int i=startingIndex; i < walls.length; ++i) {
+            tallestWall = Math.max(walls[i], tallestWall);
+        }
+
+        return tallestWall;
+    }
+
+    // #endRegion
 }

src/main/java/io/coffeelessprogrammer/leetcode/medium/LongestSubstringNoRepeatingChar.java

@@ -0,0 +1,101 @@
+package io.coffeelessprogrammer.leetcode.medium;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/*
+ * Problem: 3. Longest Substring Without Repeating Characters
+ * Acceptance Rate: 32.2%
+ * URL: https://leetcode.com/problems/longest-substring-without-repeating-characters/
+ *
+ * Runtime: 83 ms, faster than 14.91% of Java online submissions for Longest Substring Without Repeating Characters.
+ * Memory Usage: 39.6 MB, less than 47.86% of Java online submissions for Longest Substring Without Repeating Characters.
+ *
+ *   ↓ Post Optimization
+ *
+ * 4 ms, faster than 91.22% of Java online submissions for Longest Substring Without Repeating Characters.
+ * Memory Usage: 38.6 MB, less than 98.29% of Java online submissions for Longest Substring Without Repeating Characters.
+ */
+
+public class LongestSubstringNoRepeatingChar {
+
+    public static int getLength(String str) {
+        Map<Character, Integer> found = new HashMap<>();
+
+        int lengthOfLongestSubstring = 0, windowStart=0;
+
+        for(int i=0; i < str.length(); ++i) {
+            // System.out.println("substringStart=" + windowStart + ", i=" + i + ", char=" + str.charAt(i));
+
+            if(found.containsKey(str.charAt(i))) {
+                int repeatedCharIndex = found.get(str.charAt(i));
+                if(repeatedCharIndex >= windowStart) {
+                    windowStart = repeatedCharIndex + 1;
+                }
+            }
+            found.put(str.charAt(i), i);
+            lengthOfLongestSubstring = Math.max(lengthOfLongestSubstring, i-windowStart+1);
+        }
+
+        // System.out.println("Result for '" + str + "' = " + lengthOfLongestSubstring + "\n\n");
+
+        return lengthOfLongestSubstring;
+    }
+
+    // #region BruteForce
+
+    public static int getLengthBF(String str) {
+        Map<Character, Integer> found = new HashMap<>();
+
+        int i=0, j=0;
+
+        int lengthOfLongestSubstring = 0;
+
+        while(i < str.length()) {
+            System.out.println("substringStart=" + j + ", i=" + i + ", char=" + str.charAt(i));
+
+            if(found.containsKey(str.charAt(i))) {
+                System.out.println("  Repeat found X_X");
+                if(i-j > lengthOfLongestSubstring) lengthOfLongestSubstring = i-j;
+
+                j = found.get(str.charAt(i)) + 1;
+                i = j-1;
+
+                found.clear();
+            } else {
+                System.out.println("  Adding :)");
+                found.put(str.charAt(i), i);
+            }
+
+            ++i;
+
+            if(i == str.length()) {
+                if(i-j > lengthOfLongestSubstring) lengthOfLongestSubstring = i-j;
+            }
+        }
+
+        System.out.println("Result for '" + str + "' = " + lengthOfLongestSubstring + "\n\n");
+
+        return lengthOfLongestSubstring;
+    }
+
+    // #endRegion
+
+    public static int jeantimax(String s) {
+        int i = 0, j = 0, max = 0;
+        Set<Character> set = new HashSet<>();
+
+        while (j < s.length()) {
+            if (!set.contains(s.charAt(j))) {
+                set.add(s.charAt(j++));
+                max = Math.max(max, set.size());
+            } else {
+                set.remove(s.charAt(i++));
+            }
+        }
+
+        return max;
+    }
+}

src/main/java/io/coffeelessprogrammer/leetcode/medium/ZigZagConversion.java

@@ -11,7 +11,7 @@
  * Runtime: 8 ms, faster than 54.57% of Java online submissions for ZigZag Conversion.
  * Memory Usage: 39.4 MB, less than 77.06% of Java online submissions for ZigZag Conversion.
  *
- *   ↓ After Optimization
+ *   ↓ Post Optimization
  *
  * Runtime: 2 ms, faster than 99.95% of Java online submissions for ZigZag Conversion.
  * Memory Usage: 38.9 MB, less than 97.86% of Java online submissions for ZigZag Conversion.

src/test/java/io/coffeelessprogrammer/leetcode/medium/LongestSubstringNoRepeatingCharTests.java

@@ -0,0 +1,32 @@
+package io.coffeelessprogrammer.leetcode.medium;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Assertions;
+
+public class LongestSubstringNoRepeatingCharTests {
+
+    @Test
+    final void HappyPath() {
+        Assertions.assertEquals(3, LongestSubstringNoRepeatingChar.getLength("abccabb"));
+    }
+
+    @Test
+    final void Overlap() {
+        Assertions.assertEquals(4, LongestSubstringNoRepeatingChar.getLength("abcbda"));
+    }
+
+    @Test
+    final void EmptyString() {
+        Assertions.assertEquals(0, LongestSubstringNoRepeatingChar.getLength(""));
+    }
+
+    @Test
+    final void OneRepeatedChar() {
+        Assertions.assertEquals(1, LongestSubstringNoRepeatingChar.getLength("ccccccc"));
+    }
+
+    @Test
+    final void TrickyOverlap() {
+        Assertions.assertEquals(5, LongestSubstringNoRepeatingChar.getLength("anviaj"));
+    }
+}