Merge branch 'neetcode-gh:main' into main

README.md

@@ -1,4 +1,8 @@
-# Leetcode solutions for [NeetCode](https://www.youtube.com/c/neetcode)
+# Leetcode solutions for [NeetCode.io](https://neetcode.io)
+
+### Updates
+
+I will periodically update the neetcode.io site with new solutions for this repo!
 
 ### Contributing
 

java/1155-Number-of-Dice-Rolls-With-Target-Sum.java

@@ -0,0 +1,26 @@
+class Solution {
+ int mod = 1000000007;
+ public int numRollsToTarget(int n, int k, int target) {
+ if (target>n*k || target<n)
+ return 0;
+ if (n==1) 
+ return target<n?0:1;
+ int[][] dp = new int[n+1][target+1];
+ return helper(n, k, target, dp);
+ }
+
+ public int helper(int n, int k , int target, int[][] dp) {
+ if (target>n*k || target<n)
+ return 0;
+ if (target==0 && n==0)
+ return 1;
+ if (dp[n][target]!=0)
+ return dp[n][target];
+ int sum = 0;
+ for (int i =1; i<=k; i++) {
+ sum = (sum+helper(n-1, k, target-i, dp))%mod;
+ }
+ return dp[n][target]=sum;
+ }
+
+}

java/1160-Find-Words-That-Can-Be-Formed-by-Characters.java

@@ -0,0 +1,24 @@
+//Intuitive approach
+
+class Solution {
+ public int countCharacters(String[] words, String chars) {
+ int[] arrChars = new int[26];
+ for (int i = 0; i<chars.length(); i++) {
+ arrChars[chars.charAt(i)-'a']++;
+ }
+ int ans = 0;
+ for (String s: words) {
+ boolean flag = true;
+ int[] arrS = new int[26];
+ for (int i= 0; i<s.length(); i++) {
+ arrS[s.charAt(i)-'a']++;
+ }
+ for (int i =0; i<26; i++) {
+ if (arrS[i]>arrChars[i])
+ flag = false;
+ }
+ if (flag) ans += s.length();
+ }
+ return ans;
+ }
+}

java/49-Group-Anagrams.java

@@ -2,15 +2,15 @@ class Solution {
  public List<List<String>> groupAnagrams(String[] strs) {
  List<List<String>> res = new ArrayList<>();
  if(strs.length==0) return res;
- HashMap<String, List<String>> map = new HashMap();
+ HashMap<String, List<String>> map = new HashMap<>();
  for(String s: strs){
  char[] hash = new char[26];
  for(char c: s.toCharArray()){
  hash[c-'a']++;
  }
- String str=new String(hash);
- map.computeIfAbsent(str, k -> new ArrayList<>());
- map.get(str).add(s);
+ String key = new String(hash);
+ map.computeIfAbsent(key, k -> new ArrayList<>());
+ map.get(key).add(s);
  }
  res.addAll(map.values());
  return res;

java/63-Unique-Paths-II.java

@@ -0,0 +1,23 @@
+//Same as unique paths 1 just one extra condition to return 0 if grid[i][j] == 1
+
+class Solution {
+ public int uniquePathsWithObstacles(int[][] grid) {
+ return dfs(grid, 0, 0, grid.length, grid[0].length, new int[grid.length][grid[0].length]);
+ }
+
+ public int dfs(int[][] grid, int i, int j, int m, int n, int[][] dp) {
+ if (i<0 || j<0 || i>=m || j>=n || grid[i][j]==1) {
+ return 0;
+ }
+ if (i==m-1 && j==n-1) {
+ dp[i][j] = 1;
+ return dp[i][j];
+ }
+ if (dp[i][j]!=0) return dp[i][j];
+ int right = dfs(grid, i, j+1, m, n, dp);
+ int left = dfs(grid, i+1, j, m, n, dp);
+ dp[i][j] = right+left;
+ return dp[i][j];
+ }
+
+}

javascript/332-Reconstruct-Itinerary.js

@@ -0,0 +1,44 @@
+/**
+ * @param {string[][]} tickets
+ * @return {string[]}
+ */
+var findItinerary = function (tickets) {
+ const flight_paths = new Map();
+ const flight_path_order = ["JFK"];
+
+ tickets = tickets.sort();
+
+ for (const [source, dest] of tickets) {
+ let edges = [];
+ if (flight_paths.has(source)) {
+ edges = flight_paths.get(source);
+ }
+ edges.push(dest);
+ flight_paths.set(source, edges);
+ }
+
+ const depth_first_search = (city) => {
+ if (flight_path_order.length === tickets.length + 1) return true;
+
+ const cities_to_go_to = flight_paths.get(city) || [];
+ if (!cities_to_go_to.length) return false;
+
+ const cities_copied = Array.from(cities_to_go_to);
+
+ for (const other_city of cities_copied) {
+ flight_path_order.push(other_city);
+ cities_to_go_to.shift();
+
+ if (depth_first_search(other_city)) {
+ return flight_path_order;
+ } else {
+ flight_path_order.pop();
+ cities_to_go_to.push(other_city);
+ }
+ }
+
+ return false;
+ };
+
+ return depth_first_search("JFK");
+};