Merge pull request neetcode-gh#387 from MarinaPotovichenko/feature/add-js-solutions

Ahmad-A0 · web-flow · commit f255c74cde0c · 2022-07-09T12:54:59.000+01:00
feat: added JS solutions of 57, 139, 269, 435
diff --git a/javascript/139-Word-Break.js b/javascript/139-Word-Break.js
@@ -0,0 +1,19 @@
+let wordBreak = function(s, wordDict) {
+   let dp = new Array(s.length + 1);
+    dp.fill(false);
+    dp[s.length] = true;
+
+    let word = '';
+    for(let i = s.length - 1; i >= 0; i--) {
+        word = s[i] + word;
+
+        if(wordDict.includes(word) && i + word.length < dp.length) {
+            dp[i] = dp[i + word.length];
+            word = '';
+        } else {
+            dp[i] = false;
+        }
+    }
+
+    return dp[0];
+};
diff --git a/javascript/269-Alien-Dictionary.js b/javascript/269-Alien-Dictionary.js
@@ -0,0 +1,55 @@
+let alienOrder = function (words) {
+    let graph = {};
+
+    for (let i = 0; i < words.length; i++) {
+        for (let j = 0; j < words[i].length; j++) {
+            graph[words[i][j]] = new Set();
+        }
+    }
+
+    for (let i = 0; i < words.length - 1; i++) {
+        let word1 = words[i];
+        let word2 = words[i + 1];
+
+        if (word1.length > word2.length && (word1 + '').startsWith(word2)) {
+            return "";
+        }
+
+        for (let j = 0; j < Math.min(word1.length, word2.length); j++) {
+            let c1 = word1[j];
+            let c2 = word2[j];
+
+            if (c1 !== c2) {
+                graph[c1].add(c2);
+                break;
+            }
+        }
+    }
+
+    let visited = {}; // 'false' = visited, 'true' = current path
+    let res = [];
+
+    function dfs(c) {
+        if (visited[c]) {
+            return Boolean(visited[c]);
+        }
+
+        visited[c] = 'true';
+        for (let nei of graph[c]) {
+            if (dfs(nei)) {
+                return true;
+            }
+        }
+
+        visited[c] = 'false';
+        res.push(c);
+    }
+
+    Object.keys(graph).forEach(c => {
+        if (dfs(c)) {
+            return '';
+        }
+    })
+
+    return res.reverse().join('');
+}
diff --git a/javascript/435-Non-overlapping-Intervals.js b/javascript/435-Non-overlapping-Intervals.js
@@ -0,0 +1,17 @@
+let eraseOverlapIntervals = function(intervals) {
+    intervals = intervals.sort((a, b) => a[0] - b[1]);
+
+    let currentEnd = intervals[0][1];
+    let res = 0;
+
+    for(let i = 1; i < intervals.length; i++) {
+        if(currentEnd > intervals[i][0]) {
+            res += 1;
+            currentEnd = Math.min(intervals[i][1], currentEnd);
+        } else {
+            currentEnd = intervals[i][1];
+        }
+    }
+
+    return res;
+};
diff --git a/javascript/57-Insert-Interval.js b/javascript/57-Insert-Interval.js
@@ -0,0 +1,26 @@
+let insert = function(intervals, newInterval) {
+    let res = [];
+    let isAdded = false;
+
+    intervals.forEach(int => {
+        if (int[0] > newInterval[1]) {
+            if (!isAdded) {
+                res.push(newInterval);
+                isAdded = true;
+            }
+
+            res.push(int);
+        } else if (int[1] < newInterval[0]) {
+            res.push(int);
+        } else {
+            newInterval[0] = Math.min(newInterval[0], int[0]);
+            newInterval[1] = Math.max(newInterval[1], int[1]);
+        }
+    });
+
+    if (!isAdded) {
+        res.push(newInterval);
+    }
+
+    return res;
+};
