[ { "path": ".github/ISSUE_TEMPLATE/custom.md", "content": "---\nname: Custom issue template\nabout: Describe this issue template's purpose here.\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n\n" }, { "path": ".github/pull_request_template.md", "content": "**Please fill the details before contributing.**\n\n\n\n\n# ⚠️Important!!\n\n\n- [ ] Done reading [CONTRIBUTING.md](https://github.com/Sagar0-0/DsA/blob/main/CONTRIBUTING.md)?\n\n# Adding Code PRs?🔥\n⚠️Do not add multiple files for the same solution!!!\n- [ ] Added problem statement(Readme.md) with solution?\n\n- [ ] Contributing new file?\n- [ ] Appending your code in already existing file?\n\n### From Platform:\n\n- [ ] Leetcode \n- [ ] GFG \n- [ ] Interviewbit\n- [ ] Others(only acceptable after DISCUSSIONS)\n\n# Migration PRs?🤝\n\n- [ ] Done deleteing file from home directory?\n- [ ] Added file with correct name and correct directory?\n\n" }, { "path": "0012-integer-to-roman/0012-integer-to-roman.java", "content": "class Solution {\n \n \n public String intToRoman(int num) {\n \n int[] val = { 1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1 };\n String[] code = { \"M\", \"CM\", \"D\", \"CD\", \"C\", \"XC\", \"L\", \"XL\", \"X\", \"IX\", \"V\", \"IV\", \"I\" };\n\n \n StringBuilder sb = new StringBuilder();\n\n while (num > 0) {\n\n for (int i = 0; i < 13; i++) {\n\n if (num >= val[i]) {\n\n num -= val[i];\n sb.append(code[i]);\n break;\n }\n }\n }\n\n return sb.toString();\n\n }\n}" }, { "path": "0012-integer-to-roman/0012-integer-to-roman.py", "content": "class Solution:\n def intToRoman(self, num: int) -> str:\n d = {1000: 'M', 900: 'CM', 500: 'D', 400: 'CD', 100: 'C', 90: 'XC', 50: 'L', 40: 'XL', 10: 'X', 9: 'IX', 5: 'V', 4: 'IV', 1: 'I'}\n res = ''\n for k in d:\n while num >= k:\n res += d[k]\n num -= k\n return res" }, { "path": "0012-integer-to-roman/NOTES.md", "content": "​" }, { "path": "0012-integer-to-roman/README.md", "content": "

12. Integer to Roman

Medium

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

\n\n
Symbol       Value\nI             1\nV             5\nX             10\nL             50\nC             100\nD             500\nM             1000
\n\n

For example, 2 is written as II in Roman numeral, just two one's added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

\n\n

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

\n\n\n\n

Given an integer, convert it to a roman numeral.

\n\n

 

\n

Example 1:

\n\n
Input: num = 3\nOutput: \"III\"\nExplanation: 3 is represented as 3 ones.\n
\n\n

Example 2:

\n\n
Input: num = 58\nOutput: \"LVIII\"\nExplanation: L = 50, V = 5, III = 3.\n
\n\n

Example 3:

\n\n
Input: num = 1994\nOutput: \"MCMXCIV\"\nExplanation: M = 1000, CM = 900, XC = 90 and IV = 4.\n
\n\n

 

\n

Constraints:

\n\n\n
" }, { "path": "0026-remove-duplicates-from-sorted-array/0026-remove-duplicates-from-sorted-array.java", "content": "class Solution {\n public int removeDuplicates(int[] nums) {\n int idx=0;\n int i=0;\n while(i26. Remove Duplicates from Sorted Array

Easy

Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.

\n\n

Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result. It does not matter what you leave beyond the first k elements.

\n\n

Return k after placing the final result in the first k slots of nums.

\n\n

Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.

\n\n

Custom Judge:

\n\n

The judge will test your solution with the following code:

\n\n
int[] nums = [...]; // Input array\nint[] expectedNums = [...]; // The expected answer with correct length\n\nint k = removeDuplicates(nums); // Calls your implementation\n\nassert k == expectedNums.length;\nfor (int i = 0; i < k; i++) {\n    assert nums[i] == expectedNums[i];\n}\n
\n\n

If all assertions pass, then your solution will be accepted.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,1,2]\nOutput: 2, nums = [1,2,_]\nExplanation: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively.\nIt does not matter what you leave beyond the returned k (hence they are underscores).\n
\n\n

Example 2:

\n\n
Input: nums = [0,0,1,1,1,2,2,3,3,4]\nOutput: 5, nums = [0,1,2,3,4,_,_,_,_,_]\nExplanation: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.\nIt does not matter what you leave beyond the returned k (hence they are underscores).\n
\n\n

 

\n

Constraints:

\n\n\n
" }, { "path": "0036-valid-sudoku/0036-valid-sudoku.java", "content": "class Solution {\n public static boolean isCorrect(char[][] board,int x,int y){\n for(int i=0;i bool:\n seen = sum(([(c, i), (j, c), (i//3, j//3, c)]\n for i in range(9) for j in range(9)\n for c in [board[i][j]] if c != '.'), [])\n return len(seen) == len(set(seen))" }, { "path": "0036-valid-sudoku/NOTES.md", "content": "​" }, { "path": "0036-valid-sudoku/README.md", "content": "

36. Valid Sudoku

Medium

Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

\n\n
    \n\t
  1. Each row must contain the digits 1-9 without repetition.
    2. \n\t
  2. Each column must contain the digits 1-9 without repetition.
    3. \n\t
  3. Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9 without repetition.
    4. \n
\n\n

Note:

\n\n
    \n\t
  • A Sudoku board (partially filled) could be valid but is not necessarily solvable.
    • \n\t
  • Only the filled cells need to be validated according to the mentioned rules.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input: board = \n[[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"]\n,[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"]\n,[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"]\n,[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"]\n,[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"]\n,[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"]\n,[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"]\n,[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"]\n,[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\nOutput: true\n
\n\n

Example 2:

\n\n
Input: board = \n[[\"8\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"]\n,[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"]\n,[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"]\n,[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"]\n,[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"]\n,[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"]\n,[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"]\n,[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"]\n,[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\nOutput: false\nExplanation: Same as Example 1, except with the 5 in the top left corner being modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • board.length == 9
    • \n\t
  • board[i].length == 9
    • \n\t
  • board[i][j] is a digit 1-9 or '.'.
    • \n
\n
" }, { "path": "0037-sudoku-solver/0037-sudoku-solver.java", "content": "class Solution {\n public void solveSudoku(char[][] board) {\n dfs(0,0,board);\n }\n boolean dfs(int i,int j,char[][]board){\n if(i==9)return true;\n if(board[i][j]!='.'){\n if(j==8){\n return dfs(i+1,0,board);\n }else{\n return dfs(i,j+1,board);\n }\n }\n \n for(int num=1;num<=9;num++){\n board[i][j]=(char)(num+'0');\n if(safe(board,i,j)){\n boolean ans;\n if(j==8){\n ans=dfs(i+1,0,board);\n }else{\n ans=dfs(i,j+1,board);\n }\n if(ans)return true;\n }\n board[i][j]='.';\n }\n \n return false;\n }\n boolean notInRow(char arr[][], int row)\n {\n HashSet st = new HashSet<>();\n for (int i = 0; i < 9; i++) {\n if (st.contains(arr[row][i]))\n return false;\n \n if (arr[row][i] != '.')\n st.add(arr[row][i]);\n }\n return true;\n }\n boolean notInCol(char arr[][], int col)\n {\n HashSet st = new HashSet<>();\n for (int i = 0; i < 9; i++) {\n if (st.contains(arr[i][col]))\n return false;\n if (arr[i][col] != '.')\n st.add(arr[i][col]);\n }\n return true;\n }\n boolean notInBox(char arr[][], int startRow, int startCol)\n {\n HashSet st = new HashSet<>();\n \n for (int row = 0; row < 3; row++) {\n for (int col = 0; col < 3; col++) {\n char curr = arr[row + startRow][col + startCol];\n if (st.contains(curr))\n return false;\n \n if (curr != '.')\n st.add(curr);\n }\n }\n return true;\n }\n boolean safe(char arr[][], int row,\n int col)\n {\n return notInRow(arr, row) && notInCol(arr, col)\n && notInBox(arr, row - row % 3, col - col % 3);\n }\n}" }, { "path": "0037-sudoku-solver/NOTES.md", "content": "​" }, { "path": "0037-sudoku-solver/README.md", "content": "

37. Sudoku Solver

Hard

Write a program to solve a Sudoku puzzle by filling the empty cells.

\n\n

A sudoku solution must satisfy all of the following rules:

\n\n
    \n\t
  1. Each of the digits 1-9 must occur exactly once in each row.
    2. \n\t
  2. Each of the digits 1-9 must occur exactly once in each column.
    3. \n\t
  3. Each of the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.
    4. \n
\n\n

The '.' character indicates empty cells.

\n\n

 

\n

Example 1:

\n\n
Input: board = [[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"],[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"],[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"],[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"],[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"],[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"],[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"],[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"],[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\nOutput: [[\"5\",\"3\",\"4\",\"6\",\"7\",\"8\",\"9\",\"1\",\"2\"],[\"6\",\"7\",\"2\",\"1\",\"9\",\"5\",\"3\",\"4\",\"8\"],[\"1\",\"9\",\"8\",\"3\",\"4\",\"2\",\"5\",\"6\",\"7\"],[\"8\",\"5\",\"9\",\"7\",\"6\",\"1\",\"4\",\"2\",\"3\"],[\"4\",\"2\",\"6\",\"8\",\"5\",\"3\",\"7\",\"9\",\"1\"],[\"7\",\"1\",\"3\",\"9\",\"2\",\"4\",\"8\",\"5\",\"6\"],[\"9\",\"6\",\"1\",\"5\",\"3\",\"7\",\"2\",\"8\",\"4\"],[\"2\",\"8\",\"7\",\"4\",\"1\",\"9\",\"6\",\"3\",\"5\"],[\"3\",\"4\",\"5\",\"2\",\"8\",\"6\",\"1\",\"7\",\"9\"]]\nExplanation: The input board is shown above and the only valid solution is shown below:\n\n\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • board.length == 9
    • \n\t
  • board[i].length == 9
    • \n\t
  • board[i][j] is a digit or '.'.
    • \n\t
  • It is guaranteed that the input board has only one solution.
    • \n
\n
" }, { "path": "0038-count-and-say/0038-count-and-say.java", "content": "class Solution {\n public String countAndSay(int n) {\n StringBuilder sb = new StringBuilder(\"1\");\n for (int i = 2; i <= n; i++) {\n sb = getNextState(sb);\n }\n return sb.toString();\n }\n\n private StringBuilder getNextState(StringBuilder curSb) {\n StringBuilder nextSb = new StringBuilder();\n int len = curSb.length();\n int i = 0;\n\t\t\n while (i < len) {\n char c = curSb.charAt(i++);\n int count = 1;\n while (i < len && c == curSb.charAt(i)) {\n count++;\n i++;\n }\n nextSb.append(count).append(c);\n }\n\t\t\n return nextSb;\n }\n}" }, { "path": "0038-count-and-say/0038-count-and-say.py", "content": "import re\nclass Solution:\n def countAndSay(self, n: int) -> str:\n s = '1'\n for _ in range(n - 1):\n s = re.sub(r'(.)\\1*', lambda m: str(len(m.group(0))) + m.group(1), s)\n return s" }, { "path": "0038-count-and-say/README.md", "content": "

38. Count and Say

Medium

The count-and-say sequence is a sequence of digit strings defined by the recursive formula:

\n\n
    \n\t
  • countAndSay(1) = \"1\"
    • \n\t
  • countAndSay(n) is the way you would \"say\" the digit string from countAndSay(n-1), which is then converted into a different digit string.
    • \n
\n\n

To determine how you \"say\" a digit string, split it into the minimal number of substrings such that each substring contains exactly one unique digit. Then for each substring, say the number of digits, then say the digit. Finally, concatenate every said digit.

\n\n

For example, the saying and conversion for digit string \"3322251\":

\n\"\"\n

Given a positive integer n, return the nth term of the count-and-say sequence.

\n\n

 

\n

Example 1:

\n\n
Input: n = 1\nOutput: \"1\"\nExplanation: This is the base case.\n
\n\n

Example 2:

\n\n
Input: n = 4\nOutput: \"1211\"\nExplanation:\ncountAndSay(1) = \"1\"\ncountAndSay(2) = say \"1\" = one 1 = \"11\"\ncountAndSay(3) = say \"11\" = two 1's = \"21\"\ncountAndSay(4) = say \"21\" = one 2 + one 1 = \"12\" + \"11\" = \"1211\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 30
    • \n
\n
" }, { "path": "0049-group-anagrams/0049-group-anagrams.java", "content": "class Solution {\n public List> groupAnagrams(String[] strs) {\n Set> set=new HashSet<>();\n Map,Integer>map=new HashMap<>();\n List> ans=new ArrayList<>();\n for(String s:strs){\n Map curr=new HashMap<>();\n for(char c:s.toCharArray()){\n curr.put(c,curr.getOrDefault(c,0)+1);\n }\n if(set.contains(curr)){\n int idx=map.get(curr);\n ans.get(idx).add(s);\n }else{\n set.add(curr);\n ans.add(new ArrayList<>());\n ans.get(ans.size()-1).add(s);\n map.put(curr,ans.size()-1);\n }\n }\n return ans;\n }\n}" }, { "path": "0049-group-anagrams/0049-group-anagrams.py", "content": "from collections import defaultdict\n\nclass Solution:\n def groupAnagrams(self, strs):\n letters_to_words = defaultdict(list)\n for word in strs:\n letters_to_words[tuple(sorted(word))].append(word)\n return list(letters_to_words.values())" }, { "path": "0049-group-anagrams/README.md", "content": "

49. Group Anagrams

Medium

Given an array of strings strs, group the anagrams together. You can return the answer in any order.

\n\n

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.

\n\n

 

\n

Example 1:

\n
Input: strs = [\"eat\",\"tea\",\"tan\",\"ate\",\"nat\",\"bat\"]\nOutput: [[\"bat\"],[\"nat\",\"tan\"],[\"ate\",\"eat\",\"tea\"]]\n

Example 2:

\n
Input: strs = [\"\"]\nOutput: [[\"\"]]\n

Example 3:

\n
Input: strs = [\"a\"]\nOutput: [[\"a\"]]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= strs.length <= 104
    • \n\t
  • 0 <= strs[i].length <= 100
    • \n\t
  • strs[i] consists of lowercase English letters.
    • \n
\n
" }, { "path": "0055-jump-game/0055-jump-game.java", "content": "class Solution {\n public boolean canJump(int[] nums) {\n int maxReachableDistance=nums[0];\n int i=1;\n while(maxReachableDistance>=i && i=nums.length-1;\n \n }\n}" }, { "path": "0055-jump-game/0055-jump-game.py", "content": "class Solution:\n def canJump(self, nums: List[int]) -> bool:\n if len(nums) <= 1:\n return True\n j = len(nums) - 2\n i = len(nums) - 1 \n while j > -1:\n if j + nums[j] >= i:\n i = j\n j -= 1\n \n else:\n j -= 1\n #print('i', i, 'j', j)\n if i <= 0:\n return True\n else:\n return False" }, { "path": "0055-jump-game/NOTES.md", "content": "​" }, { "path": "0055-jump-game/README.md", "content": "

55. Jump Game

Medium

You are given an integer array nums. You are initially positioned at the array's first index, and each element in the array represents your maximum jump length at that position.

\n\n

Return true if you can reach the last index, or false otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [2,3,1,1,4]\nOutput: true\nExplanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.\n
\n\n

Example 2:

\n\n
Input: nums = [3,2,1,0,4]\nOutput: false\nExplanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 104
    • \n\t
  • 0 <= nums[i] <= 105
    • \n
\n
" }, { "path": "0057-insert-interval/0057-insert-interval.java", "content": "class Solution {\n public int[][] insert(int[][] intervals, int[] newInterval) {\n List inter = new ArrayList<>(intervals.length);\n\n for(int[] curr : intervals){\n if(curr[0] > newInterval[1]){\n inter.add(newInterval);\n newInterval = curr;\n }\n else if(curr[1] < newInterval[0]){\n inter.add(curr);\n }\n else{\n int st = Math.min(curr[0],newInterval[0]);\n int end = Math.max(curr[1],newInterval[1]);\n newInterval[0] = st;\n newInterval[1] = end;\n }\n }\n inter.add(newInterval);\n\n int[][] retu = new int[inter.size()][];\n for(int i=0;i57. Insert Interval

Medium

You are given an array of non-overlapping intervals intervals where intervals[i] = [starti, endi] represent the start and the end of the ith interval and intervals is sorted in ascending order by starti. You are also given an interval newInterval = [start, end] that represents the start and end of another interval.

\n\n

Insert newInterval into intervals such that intervals is still sorted in ascending order by starti and intervals still does not have any overlapping intervals (merge overlapping intervals if necessary).

\n\n

Return intervals after the insertion.

\n\n

 

\n

Example 1:

\n\n
Input: intervals = [[1,3],[6,9]], newInterval = [2,5]\nOutput: [[1,5],[6,9]]\n
\n\n

Example 2:

\n\n
Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]\nOutput: [[1,2],[3,10],[12,16]]\nExplanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= intervals.length <= 104
    • \n\t
  • intervals[i].length == 2
    • \n\t
  • 0 <= starti <= endi <= 105
    • \n\t
  • intervals is sorted by starti in ascending order.
    • \n\t
  • newInterval.length == 2
    • \n\t
  • 0 <= start <= end <= 105
    • \n
\n
" }, { "path": "0070-climbing-stairs/0070-climbing-stairs.java", "content": "class Solution {\n public int climbStairs(int n) {\n if (n < 3) return n;\n int oneStep = 1, twoStep = 2;\n for (int i = 3; i <= n; i++) {\n int count = oneStep + twoStep;\n oneStep = twoStep;\n twoStep = count;\n }\n return twoStep;\n }\n}" }, { "path": "0070-climbing-stairs/NOTES.md", "content": "​" }, { "path": "0070-climbing-stairs/README.md", "content": "

70. Climbing Stairs

Easy

You are climbing a staircase. It takes n steps to reach the top.

\n\n

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

\n\n

 

\n

Example 1:

\n\n
Input: n = 2\nOutput: 2\nExplanation: There are two ways to climb to the top.\n1. 1 step + 1 step\n2. 2 steps\n
\n\n

Example 2:

\n\n
Input: n = 3\nOutput: 3\nExplanation: There are three ways to climb to the top.\n1. 1 step + 1 step + 1 step\n2. 1 step + 2 steps\n3. 2 steps + 1 step\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 45
    • \n
\n
" }, { "path": "0076-minimum-window-substring/0076-minimum-window-substring.java", "content": "class Solution {\n public String minWindow(String s, String t) {\n int[] cs = new int[256];\n for (char ch : t.toCharArray()) {\n cs[ch]++;\n }\n int l = 0, r = 0, cnt = t.length();\n int start = -1, end = s.length(); // substring [start, end)\n while (r < s.length()) {\n if (cs[s.charAt(r++)]-- > 0) {\n cnt--;\n }\n while (cnt == 0) {\n if (cs[s.charAt(l++)]++ == 0) {\n cnt++;\n }\n if (r - l + 1 < end - start) {\n start = l - 1;\n end = r;\n }\n }\n }\n return end - start > s.length() ? \"\" : s.substring(start, end);\n }\n}" }, { "path": "0076-minimum-window-substring/NOTES.md", "content": "​" }, { "path": "0076-minimum-window-substring/README.md", "content": "

76. Minimum Window Substring

Hard

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string \"\".

\n\n

The testcases will be generated such that the answer is unique.

\n\n

A substring is a contiguous sequence of characters within the string.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"ADOBECODEBANC\", t = \"ABC\"\nOutput: \"BANC\"\nExplanation: The minimum window substring \"BANC\" includes 'A', 'B', and 'C' from string t.\n
\n\n

Example 2:

\n\n
Input: s = \"a\", t = \"a\"\nOutput: \"a\"\nExplanation: The entire string s is the minimum window.\n
\n\n

Example 3:

\n\n
Input: s = \"a\", t = \"aa\"\nOutput: \"\"\nExplanation: Both 'a's from t must be included in the window.\nSince the largest window of s only has one 'a', return empty string.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == s.length
    • \n\t
  • n == t.length
    • \n\t
  • 1 <= m, n <= 105
    • \n\t
  • s and t consist of uppercase and lowercase English letters.
    • \n
\n\n

 

\n

Follow up: Could you find an algorithm that runs in O(m + n) time?

\n
" }, { "path": "0079-word-search/0079-word-search.java", "content": "class Solution {\n int[][] dirs = new int[][] {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n \n public boolean exist(char[][] board, String word) {\n int[] alphFreqForBoard = new int[26]; \n int[] alphFreqForWord = new int[26]; \n \n for (char cc : word.toCharArray()) {\n alphFreqForWord[cc - 'A']++; \n }\n \n for (char[] row : board) {\n for (char c : row) {\n alphFreqForBoard[c - 'A']++; \n }\n }\n \n for (char cc : word.toCharArray()) {\n if (alphFreqForBoard[cc - 'A'] < alphFreqForWord[cc - 'A']) {\n return false; \n }\n }\n \n if (alphFreqForBoard[word.charAt(0) - 'A'] > alphFreqForWord[word.charAt(word.length() - 1) - 'A']) {\n word = new StringBuilder(word).reverse().toString();\n }\n \n for(int i = 0; i < board.length; i++) {\n for(int j = 0; j < board[i].length; j++) {\n if(dfs(board, word, i, j, 0)) {\n return true;\n }\n }\n }\n \n return false;\n }\n \n private boolean dfs(char[][] board, String word, int i, int j, int ci) {\n if(ci == word.length()) {\n return true;\n }\n \n if(i < 0 || i >= board.length || j < 0 || j >= board[0].length) {\n return false;\n }\n \n char c = board[i][j];\n \n if(c != word.charAt(ci) || c == '#') {\n return false;\n }\n \n board[i][j] = '#';\n \n for(int[] dir : dirs) {\n if(dfs(board, word, i + dir[0], j + dir[1], ci + 1)) {\n board[i][j] = c; // Restore the original character\n return true;\n }\n }\n \n board[i][j] = c; // Restore the original character\n \n return false;\n }\n}\n" }, { "path": "0079-word-search/NOTES.md", "content": "​" }, { "path": "0079-word-search/README.md", "content": "

79. Word Search

Medium

Given an m x n grid of characters board and a string word, return true if word exists in the grid.

\n\n

The word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCCED\"\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"SEE\"\nOutput: true\n
\n\n

Example 3:

\n\"\"\n
Input: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCB\"\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == board.length
    • \n\t
  • n = board[i].length
    • \n\t
  • 1 <= m, n <= 6
    • \n\t
  • 1 <= word.length <= 15
    • \n\t
  • board and word consists of only lowercase and uppercase English letters.
    • \n
\n\n

 

\n

Follow up: Could you use search pruning to make your solution faster with a larger board?

\n
" }, { "path": "0093-restore-ip-addresses/0093-restore-ip-addresses.java", "content": "class Solution {\n private boolean valid(String s, int start, int length) {\n return length == 1 || \n (s.charAt(start) != '0' && \n (length < 3 || \n s.substring(start, start + length).compareTo(\"255\") <= 0));\n }\n \n private void helper(String s, int startIndex, List dots, List ans) {\n final int remainingLength = s.length() - startIndex;\n final int remainingNumberOfIntegers = 4 - dots.size();\n if (remainingLength > remainingNumberOfIntegers * 3 || \n remainingLength < remainingNumberOfIntegers) {\n return;\n }\n if (dots.size() == 3) {\n if (valid(s, startIndex, remainingLength)) {\n StringBuilder sb = new StringBuilder();\n int last = 0;\n for (Integer dot : dots) {\n sb.append(s.substring(last, last + dot));\n last += dot;\n sb.append('.');\n }\n sb.append(s.substring(startIndex));\n ans.add(sb.toString());\n }\n return;\n }\n for (int curPos = 1; curPos <= 3 && curPos <= remainingLength; ++curPos) {\n // Append a dot at the current position.\n dots.add(curPos);\n // Try making all combinations with the remaining string.\n if (valid(s, startIndex, curPos)) {\n helper(s, startIndex + curPos, dots, ans);\n }\n // Backtrack, i.e. remove the dot to try placing it at the next position.\n dots.remove(dots.size() - 1);\n }\n }\n \n public List restoreIpAddresses(String s) {\n List ans = new ArrayList<>();\n helper(s, 0, new ArrayList<>(), ans);\n return ans; \n }\n}" }, { "path": "0093-restore-ip-addresses/README.md", "content": "

93. Restore IP Addresses

Medium

A valid IP address consists of exactly four integers separated by single dots. Each integer is between 0 and 255 (inclusive) and cannot have leading zeros.

\n\n
    \n\t
  • For example, \"0.1.2.201\" and \"192.168.1.1\" are valid IP addresses, but \"0.011.255.245\", \"192.168.1.312\" and \"192.168@1.1\" are invalid IP addresses.
    • \n
\n\n

Given a string s containing only digits, return all possible valid IP addresses that can be formed by inserting dots into s. You are not allowed to reorder or remove any digits in s. You may return the valid IP addresses in any order.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"25525511135\"\nOutput: [\"255.255.11.135\",\"255.255.111.35\"]\n
\n\n

Example 2:

\n\n
Input: s = \"0000\"\nOutput: [\"0.0.0.0\"]\n
\n\n

Example 3:

\n\n
Input: s = \"101023\"\nOutput: [\"1.0.10.23\",\"1.0.102.3\",\"10.1.0.23\",\"10.10.2.3\",\"101.0.2.3\"]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 20
    • \n\t
  • s consists of digits only.
    • \n
\n
" }, { "path": "0100-same-tree/0100-same-tree.java", "content": "class Solution {\n public boolean isSameTree(TreeNode p, TreeNode q) {\n // return recursive traversal of tree\n return inOrderTraversal(q,p);\n \n }\n \n public boolean inOrderTraversal(TreeNode node1, TreeNode node2) {\n // initialize boolean result as true\n boolean result = true;\n \n // if one of the nodes is null and the other isn't, result is false\n if( (node1 == null && node2 != null) || (node2 == null && node1 != null) ) {\n result = false;\n }\n // else determine if node1 isn't null (if so, assumes both nodes aren't null)\n else if( node1 != null ) {\n // determine if node1 shares don't value with node2\n if( node1.val != node2.val ) {\n // if so, result is false\n result = false;\n }\n // else (assume node1 and node2 share value)\n else {\n // recursively call on left nodes\n result = inOrderTraversal(node1.left, node2.left);\n \n // if result is true for recursive call\n if( result == true ) {\n // recursively call on right nodes\n result = inOrderTraversal(node1.right, node2.right);\n }\n }\n }\n // return result\n return result;\n }\n}" }, { "path": "0100-same-tree/NOTES.md", "content": "​" }, { "path": "0100-same-tree/README.md", "content": "

100. Same Tree

Easy

Given the roots of two binary trees p and q, write a function to check if they are the same or not.

\n\n

Two binary trees are considered the same if they are structurally identical, and the nodes have the same value.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: p = [1,2,3], q = [1,2,3]\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: p = [1,2], q = [1,null,2]\nOutput: false\n
\n\n

Example 3:

\n\"\"\n
Input: p = [1,2,1], q = [1,1,2]\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in both trees is in the range [0, 100].
    • \n\t
  • -104 <= Node.val <= 104
    • \n
\n
" }, { "path": "0124-binary-tree-maximum-path-sum/0124-binary-tree-maximum-path-sum.java", "content": "\nclass Solution {\n public int maxPathSum(TreeNode root) {\n maxSum = Integer.MIN_VALUE;\n gainFromSubtree(root);\n return maxSum;\n }\n\n private int maxSum;\n\n // post order traversal of subtree rooted at `root`\n private int gainFromSubtree(TreeNode root) {\n if (root == null) {\n return 0;\n }\n\n // add the path sum from left subtree. Note that if the path\n // sum is negative, we can ignore it, or count it as 0.\n // This is the reason we use `Math.max` here.\n int gainFromLeft = Math.max(gainFromSubtree(root.left), 0);\n\n // add the path sum from right subtree. 0 if negative\n int gainFromRight = Math.max(gainFromSubtree(root.right), 0);\n\n // if left or right path sum are negative, they are counted\n // as 0, so this statement takes care of all four scenarios\n maxSum = Math.max(maxSum, gainFromLeft + gainFromRight + root.val);\n\n // return the max sum for a path starting at the root of subtree\n return Math.max(gainFromLeft + root.val, gainFromRight + root.val);\n }\n}\n" }, { "path": "0124-binary-tree-maximum-path-sum/NOTES.md", "content": "​" }, { "path": "0124-binary-tree-maximum-path-sum/README.md", "content": "

124. Binary Tree Maximum Path Sum

Hard

A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.

\n\n

The path sum of a path is the sum of the node's values in the path.

\n\n

Given the root of a binary tree, return the maximum path sum of any non-empty path.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,3]\nOutput: 6\nExplanation: The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [-10,9,20,null,null,15,7]\nOutput: 42\nExplanation: The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 3 * 104].
    • \n\t
  • -1000 <= Node.val <= 1000
    • \n
\n
" }, { "path": "0125-valid-palindrome/0125-valid-palindrome.java", "content": "class Solution {\n public boolean isPalindrome(String s) {\n int i=0;\n int j= s.length()-1;\n while(i125. Valid Palindrome

Easy

A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.

\n\n

Given a string s, return true if it is a palindrome, or false otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"A man, a plan, a canal: Panama\"\nOutput: true\nExplanation: \"amanaplanacanalpanama\" is a palindrome.\n
\n\n

Example 2:

\n\n
Input: s = \"race a car\"\nOutput: false\nExplanation: \"raceacar\" is not a palindrome.\n
\n\n

Example 3:

\n\n
Input: s = \" \"\nOutput: true\nExplanation: s is an empty string \"\" after removing non-alphanumeric characters.\nSince an empty string reads the same forward and backward, it is a palindrome.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 2 * 105
    • \n\t
  • s consists only of printable ASCII characters.
    • \n
\n
" }, { "path": "0131-palindrome-partitioning/0131-palindrome-partitioning.java", "content": "class Solution {\n public List> partition(String s) {\n List> Al1 = new ArrayList<>();\n List Al2 = new ArrayList<>();\n String[][] dp = new String[s.length()][s.length()]; \n palPart(Al1,Al2,s,0,dp);\n return Al1;\n }\n \n public void palPart(List> Al1, List Al2,String s, int start,String[][] dp){\n if (start == s.length())\n Al1.add(new ArrayList<>(Al2));\n \n for (int i=start;i131. Palindrome Partitioning

Medium

Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of s.

\n\n

 

\n

Example 1:

\n
Input: s = \"aab\"\nOutput: [[\"a\",\"a\",\"b\"],[\"aa\",\"b\"]]\n

Example 2:

\n
Input: s = \"a\"\nOutput: [[\"a\"]]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 16
    • \n\t
  • s contains only lowercase English letters.
    • \n
\n
" }, { "path": "0134-gas-station/0134-gas-station.java", "content": "class Solution {\n public int canCompleteCircuit(int[] gas, int[] cost) {\n int sum = 0, n = gas.length;\n int gasInTank = 0, start = 0;\n for(int i=0;i= 0 ? start : -1;\n }\n}" }, { "path": "0134-gas-station/NOTES.md", "content": "​" }, { "path": "0134-gas-station/README.md", "content": "

134. Gas Station

Medium

There are n gas stations along a circular route, where the amount of gas at the ith station is gas[i].

\n\n

You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from the ith station to its next (i + 1)th station. You begin the journey with an empty tank at one of the gas stations.

\n\n

Given two integer arrays gas and cost, return the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return -1. If there exists a solution, it is guaranteed to be unique

\n\n

 

\n

Example 1:

\n\n
Input: gas = [1,2,3,4,5], cost = [3,4,5,1,2]\nOutput: 3\nExplanation:\nStart at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4\nTravel to station 4. Your tank = 4 - 1 + 5 = 8\nTravel to station 0. Your tank = 8 - 2 + 1 = 7\nTravel to station 1. Your tank = 7 - 3 + 2 = 6\nTravel to station 2. Your tank = 6 - 4 + 3 = 5\nTravel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.\nTherefore, return 3 as the starting index.\n
\n\n

Example 2:

\n\n
Input: gas = [2,3,4], cost = [3,4,3]\nOutput: -1\nExplanation:\nYou can't start at station 0 or 1, as there is not enough gas to travel to the next station.\nLet's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4\nTravel to station 0. Your tank = 4 - 3 + 2 = 3\nTravel to station 1. Your tank = 3 - 3 + 3 = 3\nYou cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.\nTherefore, you can't travel around the circuit once no matter where you start.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == gas.length == cost.length
    • \n\t
  • 1 <= n <= 105
    • \n\t
  • 0 <= gas[i], cost[i] <= 104
    • \n
\n
" }, { "path": "0144-binary-tree-preorder-traversal/0144-binary-tree-preorder-traversal.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public List preorderTraversal(TreeNode root) {\n List list = new ArrayList<>();\n preOrder(root,list);\n return list;\n }\n void preOrder(TreeNode root, List list){\n if(root==null)return;\n list.add(root.val);\n preOrder(root.left,list);\n preOrder(root.right,list);\n }\n}" }, { "path": "0144-binary-tree-preorder-traversal/NOTES.md", "content": "​" }, { "path": "0144-binary-tree-preorder-traversal/README.md", "content": "

144. Binary Tree Preorder Traversal

Easy

Given the root of a binary tree, return the preorder traversal of its nodes' values.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,null,2,3]\nOutput: [1,2,3]\n
\n\n

Example 2:

\n\n
Input: root = []\nOutput: []\n
\n\n

Example 3:

\n\n
Input: root = [1]\nOutput: [1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 100].
    • \n\t
  • -100 <= Node.val <= 100
    • \n
\n\n

 

\n

Follow up: Recursive solution is trivial, could you do it iteratively?

\n
" }, { "path": "0149-max-points-on-a-line/0149-max-points-on-a-line.java", "content": "class Solution {\n public int maxPoints(int[][] points) {\n int n = points.length;\n if (n == 1) {\n return 1;\n }\n int result = 2;\n for (int i = 0; i < n; i++) {\n Map cnt = new HashMap<>();\n for (int j = 0; j < n; j++) {\n if (j != i) {\n cnt.merge(Math.atan2(points[j][1] - points[i][1],\n \tpoints[j][0] - points[i][0]), 1, Integer::sum);\n }\n }\n result = Math.max(result, Collections.max(cnt.values()) + 1);\n }\n return result;\n }\n}" }, { "path": "0149-max-points-on-a-line/NOTES.md", "content": "​" }, { "path": "0149-max-points-on-a-line/README.md", "content": "

149. Max Points on a Line

Hard

Given an array of points where points[i] = [xi, yi] represents a point on the X-Y plane, return the maximum number of points that lie on the same straight line.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: points = [[1,1],[2,2],[3,3]]\nOutput: 3\n
\n\n

Example 2:

\n\"\"\n
Input: points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]\nOutput: 4\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= points.length <= 300
    • \n\t
  • points[i].length == 2
    • \n\t
  • -104 <= xi, yi <= 104
    • \n\t
  • All the points are unique.
    • \n
\n
" }, { "path": "0150-evaluate-reverse-polish-notation/0150-evaluate-reverse-polish-notation.java", "content": "class Solution {\n public int evalRPN(String[] tokens) {\n int[] nxtPos = new int[1];\n\n return eval(tokens, tokens.length - 1, nxtPos);\n }\n\n private int eval(String[] tokens, int pos, int[] nxtPos) {\n\n char ac = tokens[pos].charAt(0);\n\n if (tokens[pos].length() == 1 && (ac == '+' || ac == '-' || ac == '*' || ac == '/')) {\n\n // get operands\n int a = eval(tokens, pos - 1, nxtPos);\n int b = eval(tokens, nxtPos[0], nxtPos);\n\n // perform operation\n if (ac == '+') {\n \n return b + a;\n } else if (ac == '-') {\n\n return b - a;\n } else if (ac == '*') {\n\n return b * a;\n } else {\n\n return b / a;\n }\n } else {\n\n nxtPos[0] = pos - 1;\n return Integer.parseInt(tokens[pos]);\n }\n }\n}" }, { "path": "0150-evaluate-reverse-polish-notation/NOTES.md", "content": "​" }, { "path": "0150-evaluate-reverse-polish-notation/README.md", "content": "

150. Evaluate Reverse Polish Notation

Medium

Evaluate the value of an arithmetic expression in Reverse Polish Notation.

\n\n

Valid operators are +, -, *, and /. Each operand may be an integer or another expression.

\n\n

Note that division between two integers should truncate toward zero.

\n\n

It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result, and there will not be any division by zero operation.

\n\n

 

\n

Example 1:

\n\n
Input: tokens = [\"2\",\"1\",\"+\",\"3\",\"*\"]\nOutput: 9\nExplanation: ((2 + 1) * 3) = 9\n
\n\n

Example 2:

\n\n
Input: tokens = [\"4\",\"13\",\"5\",\"/\",\"+\"]\nOutput: 6\nExplanation: (4 + (13 / 5)) = 6\n
\n\n

Example 3:

\n\n
Input: tokens = [\"10\",\"6\",\"9\",\"3\",\"+\",\"-11\",\"*\",\"/\",\"*\",\"17\",\"+\",\"5\",\"+\"]\nOutput: 22\nExplanation: ((10 * (6 / ((9 + 3) * -11))) + 17) + 5\n= ((10 * (6 / (12 * -11))) + 17) + 5\n= ((10 * (6 / -132)) + 17) + 5\n= ((10 * 0) + 17) + 5\n= (0 + 17) + 5\n= 17 + 5\n= 22\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= tokens.length <= 104
    • \n\t
  • tokens[i] is either an operator: \"+\", \"-\", \"*\", or \"/\", or an integer in the range [-200, 200].
    • \n
\n
" }, { "path": "0151-reverse-words-in-a-string/0151-reverse-words-in-a-string.java", "content": "class Solution {\n public String reverseWords(String s) {\n List arr=new ArrayList<>();\n StringBuilder sb=new StringBuilder();\n boolean word=false;\n for(int i=0;i0)arr.add(sb);\n sb=new StringBuilder();\n for(int i=arr.size()-1;i>=0;i--){\n sb.append(arr.get(i));\n if(i!=0){\n sb.append(\" \");\n }\n }\n return sb.toString();\n }\n}" }, { "path": "0151-reverse-words-in-a-string/NOTES.md", "content": "​" }, { "path": "0151-reverse-words-in-a-string/README.md", "content": "

151. Reverse Words in a String

Medium

Given an input string s, reverse the order of the words.

\n\n

A word is defined as a sequence of non-space characters. The words in s will be separated by at least one space.

\n\n

Return a string of the words in reverse order concatenated by a single space.

\n\n

Note that s may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"the sky is blue\"\nOutput: \"blue is sky the\"\n
\n\n

Example 2:

\n\n
Input: s = \"  hello world  \"\nOutput: \"world hello\"\nExplanation: Your reversed string should not contain leading or trailing spaces.\n
\n\n

Example 3:

\n\n
Input: s = \"a good   example\"\nOutput: \"example good a\"\nExplanation: You need to reduce multiple spaces between two words to a single space in the reversed string.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 104
    • \n\t
  • s contains English letters (upper-case and lower-case), digits, and spaces ' '.
    • \n\t
  • There is at least one word in s.
    • \n
\n\n

 

\n

Follow-up: If the string data type is mutable in your language, can you solve it in-place with O(1) extra space?

\n
" }, { "path": "0198-house-robber/0198-house-robber.java", "content": "class Solution {\n public int rob(int[] nums) {\n \n int n = nums.length;\n \n if(n == 1) return nums[0];\n \n int dp2=nums[0], dp1=Math.max(nums[0],nums[1]),dp=dp1;\n \n for(int i = 2; i < n; i++){\n dp = Math.max(dp1, dp2 + nums[i]);\n dp2 = dp1;\n dp1 = dp;\n }\n return dp;\n\n }\n}" }, { "path": "0198-house-robber/README.md", "content": "

198. House Robber

Medium

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security systems connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

\n\n

Given an integer array nums representing the amount of money of each house, return the maximum amount of money you can rob tonight without alerting the police.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3,1]\nOutput: 4\nExplanation: Rob house 1 (money = 1) and then rob house 3 (money = 3).\nTotal amount you can rob = 1 + 3 = 4.\n
\n\n

Example 2:

\n\n
Input: nums = [2,7,9,3,1]\nOutput: 12\nExplanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).\nTotal amount you can rob = 2 + 9 + 1 = 12.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 100
    • \n\t
  • 0 <= nums[i] <= 400
    • \n
\n
" }, { "path": "0212-word-search-ii/0212-word-search-ii.java", "content": "class Solution {\n private static final char HASH_TAG = '#';\n private Tree root = new Tree();\n \n public List findWords(char[][] board, String[] words) {\n for (String word : words) {\n Tree temp = root;\n // Test case 60/63 \n for (int i = word.length() - 1; i >= 0; i--) {\n int idx = word.charAt(i) - 'a';\n if (temp.val[idx] == null) {\n temp.val[idx] = new Tree();\n temp.val[idx].parent = temp;\n temp.val[idx].idx = idx;\n }\n temp = temp.val[idx];\n }\n temp.word = word;\n } \n return searchWord(board);\n }\n \n private List searchWord(char[][] board) {\n List res = new ArrayList<>();\n \n for (int i = 0; i < board.length; i++)\n for (int j = 0; j < board[0].length; j++) {\n Tree temp = root;\n checkWord(res, i, j, board, temp);\n }\n \n return res;\n }\n \n private void checkWord(List res, int y, int x, char[][] board, Tree temp) {\n \n if (x >= board[0].length || x < 0\n || y >= board.length || y < 0)\n return;\n \n char ch = board[y][x];\n if (ch== HASH_TAG || temp.val[ch - 'a'] == null)\n return;\n \n temp = temp.val[ch - 'a'];\n \n if (temp.word != null) {\n res.add(temp.word);\n temp.word = null; // Test case 17/63: When there is more than one answer\n Tree ptr = temp;\n while (ptr.parent != null \n && ptr.isEmpty()) {\n int idx = ptr.idx;\n ptr = ptr.parent;\n ptr.val[idx] = null;\n }\n }\n \n board[y][x] = HASH_TAG;\n\n checkWord(res, y, x + 1, board, temp);\n checkWord(res, y, x - 1, board, temp);\n checkWord(res, y + 1, x, board, temp);\n checkWord(res, y - 1, x, board, temp);\n \n board[y][x] = ch;\n }\n \n class Tree {\n Tree parent;\n Tree[] val = new Tree[26];\n String word;\n int idx;\n\n public boolean isEmpty() {\n for (int i = 0; i < 26; i++) \n if (val[i] != null)\n return false;\n\n return true;\n }\n }\n}" }, { "path": "0212-word-search-ii/NOTES.md", "content": "​" }, { "path": "0212-word-search-ii/README.md", "content": "

212. Word Search II

Hard

Given an m x n board of characters and a list of strings words, return all words on the board.

\n\n

Each word must be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: board = [[\"o\",\"a\",\"a\",\"n\"],[\"e\",\"t\",\"a\",\"e\"],[\"i\",\"h\",\"k\",\"r\"],[\"i\",\"f\",\"l\",\"v\"]], words = [\"oath\",\"pea\",\"eat\",\"rain\"]\nOutput: [\"eat\",\"oath\"]\n
\n\n

Example 2:

\n\"\"\n
Input: board = [[\"a\",\"b\"],[\"c\",\"d\"]], words = [\"abcb\"]\nOutput: []\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == board.length
    • \n\t
  • n == board[i].length
    • \n\t
  • 1 <= m, n <= 12
    • \n\t
  • board[i][j] is a lowercase English letter.
    • \n\t
  • 1 <= words.length <= 3 * 104
    • \n\t
  • 1 <= words[i].length <= 10
    • \n\t
  • words[i] consists of lowercase English letters.
    • \n\t
  • All the strings of words are unique.
    • \n
\n
" }, { "path": "0219-contains-duplicate-ii/0219-contains-duplicate-ii.java", "content": "class Solution {\n public boolean containsNearbyDuplicate(int[] nums, int k) {\n Map list = new HashMap();\n for(int i=0; i219. Contains Duplicate II

Easy

Given an integer array nums and an integer k, return true if there are two distinct indices i and j in the array such that nums[i] == nums[j] and abs(i - j) <= k.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3,1], k = 3\nOutput: true\n
\n\n

Example 2:

\n\n
Input: nums = [1,0,1,1], k = 1\nOutput: true\n
\n\n

Example 3:

\n\n
Input: nums = [1,2,3,1,2,3], k = 2\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • -109 <= nums[i] <= 109
    • \n\t
  • 0 <= k <= 105
    • \n
\n
" }, { "path": "0222-count-complete-tree-nodes/0222-count-complete-tree-nodes.java", "content": "class Solution {\n public int countNodes(TreeNode root) {\n if(root == null){\n return 0;\n }\n int leftDep=1;\n TreeNode leftNode = root.left;\n while(leftNode != null){\n leftDep++;\n leftNode = leftNode.left;\n }\n int rightDep = 1;\n TreeNode rightNode = root.right;\n while(rightNode != null){\n rightDep++;\n rightNode = rightNode.right;\n }\n if(leftDep == rightDep){\n return (int)Math.pow(2,leftDep)-1;\n }\n return countNodes(root.left)+countNodes(root.right)+1;\n }\n}" }, { "path": "0222-count-complete-tree-nodes/NOTES.md", "content": "​" }, { "path": "0222-count-complete-tree-nodes/README.md", "content": "

222. Count Complete Tree Nodes

Medium

Given the root of a complete binary tree, return the number of the nodes in the tree.

\n\n

According to Wikipedia, every level, except possibly the last, is completely filled in a complete binary tree, and all nodes in the last level are as far left as possible. It can have between 1 and 2h nodes inclusive at the last level h.

\n\n

Design an algorithm that runs in less than O(n) time complexity.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,3,4,5,6]\nOutput: 6\n
\n\n

Example 2:

\n\n
Input: root = []\nOutput: 0\n
\n\n

Example 3:

\n\n
Input: root = [1]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 5 * 104].
    • \n\t
  • 0 <= Node.val <= 5 * 104
    • \n\t
  • The tree is guaranteed to be complete.
    • \n
\n
" }, { "path": "0223-rectangle-area/0223-rectangle-area.java", "content": "class Solution {\n public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {\n int areaOfA = (ay2 - ay1) * (ax2 - ax1);\n int areaOfB = (by2 - by1) * (bx2 - bx1);\n\n // calculate x overlap\n int left = Math.max(ax1, bx1);\n int right = Math.min(ax2, bx2);\n int xOverlap = right - left;\n\n // calculate y overlap\n int top = Math.min(ay2, by2);\n int bottom = Math.max(ay1, by1);\n int yOverlap = top - bottom;\n\n int areaOfOverlap = 0;\n // if the rectangles overlap each other, then calculate\n // the area of the overlap\n if (xOverlap > 0 && yOverlap > 0) {\n areaOfOverlap = xOverlap * yOverlap;\n }\n\n // areaOfOverlap is counted twice when in the summation of\n // areaOfA and areaOfB, so we need to subtract it from the\n // total, to get the toal area covered by both the rectangles\n int totalArea = areaOfA + areaOfB - areaOfOverlap;\n\n return totalArea;\n }\n}" }, { "path": "0223-rectangle-area/NOTES.md", "content": "​" }, { "path": "0223-rectangle-area/README.md", "content": "

223. Rectangle Area

Medium

Given the coordinates of two rectilinear rectangles in a 2D plane, return the total area covered by the two rectangles.

\n\n

The first rectangle is defined by its bottom-left corner (ax1, ay1) and its top-right corner (ax2, ay2).

\n\n

The second rectangle is defined by its bottom-left corner (bx1, by1) and its top-right corner (bx2, by2).

\n\n

 

\n

Example 1:

\n\"Rectangle\n
Input: ax1 = -3, ay1 = 0, ax2 = 3, ay2 = 4, bx1 = 0, by1 = -1, bx2 = 9, by2 = 2\nOutput: 45\n
\n\n

Example 2:

\n\n
Input: ax1 = -2, ay1 = -2, ax2 = 2, ay2 = 2, bx1 = -2, by1 = -2, bx2 = 2, by2 = 2\nOutput: 16\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • -104 <= ax1 <= ax2 <= 104
    • \n\t
  • -104 <= ay1 <= ay2 <= 104
    • \n\t
  • -104 <= bx1 <= bx2 <= 104
    • \n\t
  • -104 <= by1 <= by2 <= 104
    • \n
\n
" }, { "path": "0224-basic-calculator/0224-basic-calculator.java", "content": "class Solution {\n int idx; // this index traverse the string in one pass, between different level of recursion\n public int calculate(String s) {\n idx = 0; // Initialization should be here\n return calc(s);\n }\n \n private int calc(String s) {\n int res = 0, num = 0, sign = 1;\n while (idx < s.length()) {\n char c = s.charAt(idx++);\n if (c >= '0' && c <= '9') num = num * 10 + c - '0';\n else if (c == '(') num = calc(s); // ( is start of a new sub-problem, Let recursion solve the sub-problem\n else if (c == ')') return res + sign * num;\n else if (c == '+' || c == '-') { // only when we meet a new sign, we know a while number has been read\n res += sign * num;\n num = 0;\n sign = c == '-' ? -1 : 1;\n }\n }\n return res + sign * num; // last number is not processed yet\n }\n}" }, { "path": "0224-basic-calculator/NOTES.md", "content": "​" }, { "path": "0224-basic-calculator/README.md", "content": "

224. Basic Calculator

Hard

Given a string s representing a valid expression, implement a basic calculator to evaluate it, and return the result of the evaluation.

\n\n

Note: You are not allowed to use any built-in function which evaluates strings as mathematical expressions, such as eval().

\n\n

 

\n

Example 1:

\n\n
Input: s = \"1 + 1\"\nOutput: 2\n
\n\n

Example 2:

\n\n
Input: s = \" 2-1 + 2 \"\nOutput: 3\n
\n\n

Example 3:

\n\n
Input: s = \"(1+(4+5+2)-3)+(6+8)\"\nOutput: 23\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 3 * 105
    • \n\t
  • s consists of digits, '+', '-', '(', ')', and ' '.
    • \n\t
  • s represents a valid expression.
    • \n\t
  • '+' is not used as a unary operation (i.e., \"+1\" and \"+(2 + 3)\" is invalid).
    • \n\t
  • '-' could be used as a unary operation (i.e., \"-1\" and \"-(2 + 3)\" is valid).
    • \n\t
  • There will be no two consecutive operators in the input.
    • \n\t
  • Every number and running calculation will fit in a signed 32-bit integer.
    • \n
\n
" }, { "path": "0232-implement-queue-using-stacks/0232-implement-queue-using-stacks.java", "content": "class MyQueue {\n private Stack s1 = new Stack<>();\n private Stack s2 = new Stack<>();\n\n /** Initialize your data structure here. */\n public MyQueue() {\n \n }\n \n /** Push element x to the back of queue. */\n public void push(int x) {\n s1.push(x);\n }\n \n /** Removes the element from in front of queue and returns that element. */\n public int pop() {\n if (s2.isEmpty()) {\n while (!s1.isEmpty())\n s2.push(s1.pop());\n }\n return s2.pop();\n }\n \n /** Get the front element. */\n public int peek() {\n if (s2.isEmpty()) {\n while (!s1.isEmpty())\n s2.push(s1.pop());\n }\n return s2.peek();\n }\n \n /** Returns whether the queue is empty. */\n public boolean empty() {\n return s1.isEmpty() && s2.isEmpty();\n }\n}\n\n/**\n * Your MyQueue object will be instantiated and called as such:\n * MyQueue obj = new MyQueue();\n * obj.push(x);\n * int param_2 = obj.pop();\n * int param_3 = obj.peek();\n * boolean param_4 = obj.empty();\n */" }, { "path": "0232-implement-queue-using-stacks/NOTES.md", "content": "​" }, { "path": "0232-implement-queue-using-stacks/README.md", "content": "

232. Implement Queue using Stacks

Easy

Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (push, peek, pop, and empty).

\n\n

Implement the MyQueue class:

\n\n
    \n\t
  • void push(int x) Pushes element x to the back of the queue.
    • \n\t
  • int pop() Removes the element from the front of the queue and returns it.
    • \n\t
  • int peek() Returns the element at the front of the queue.
    • \n\t
  • boolean empty() Returns true if the queue is empty, false otherwise.
    • \n
\n\n

Notes:

\n\n
    \n\t
  • You must use only standard operations of a stack, which means only push to top, peek/pop from top, size, and is empty operations are valid.
    • \n\t
  • Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack's standard operations.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"MyQueue\", \"push\", \"push\", \"peek\", \"pop\", \"empty\"]\n[[], [1], [2], [], [], []]\nOutput\n[null, null, null, 1, 1, false]\n\nExplanation\nMyQueue myQueue = new MyQueue();\nmyQueue.push(1); // queue is: [1]\nmyQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)\nmyQueue.peek(); // return 1\nmyQueue.pop(); // return 1, queue is [2]\nmyQueue.empty(); // return false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= x <= 9
    • \n\t
  • At most 100 calls will be made to push, pop, peek, and empty.
    • \n\t
  • All the calls to pop and peek are valid.
    • \n
\n\n

 

\n

Follow-up: Can you implement the queue such that each operation is amortized O(1) time complexity? In other words, performing n operations will take overall O(n) time even if one of those operations may take longer.

\n
" }, { "path": "0236-lowest-common-ancestor-of-a-binary-tree/0236-lowest-common-ancestor-of-a-binary-tree.java", "content": "class Solution {\n public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {\n if (root == null || root == p || root == q) return root;\n TreeNode left = lowestCommonAncestor(root.left, p, q);\n TreeNode right = lowestCommonAncestor(root.right, p, q);\n if (left != null && right != null) return root;\n return left != null ? left : right;\n }\n}" }, { "path": "0236-lowest-common-ancestor-of-a-binary-tree/NOTES.md", "content": "​" }, { "path": "0236-lowest-common-ancestor-of-a-binary-tree/README.md", "content": "

236. Lowest Common Ancestor of a Binary Tree

Medium

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

\n\n

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1\nOutput: 3\nExplanation: The LCA of nodes 5 and 1 is 3.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4\nOutput: 5\nExplanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.\n
\n\n

Example 3:

\n\n
Input: root = [1,2], p = 1, q = 2\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [2, 105].
    • \n\t
  • -109 <= Node.val <= 109
    • \n\t
  • All Node.val are unique.
    • \n\t
  • p != q
    • \n\t
  • p and q will exist in the tree.
    • \n
\n
" }, { "path": "0237-delete-node-in-a-linked-list/0237-delete-node-in-a-linked-list.java", "content": "class Solution {\n public void deleteNode(ListNode node) {\n // Since we know input node is not last node, so nextNode will not be null\n ListNode nextNode = node.next;\n // Step 2\n node.val = nextNode.val;\n // Step 3\n node.next = nextNode.next;\n nextNode.next = null;\n }\n}" }, { "path": "0237-delete-node-in-a-linked-list/NOTES.md", "content": "​" }, { "path": "0237-delete-node-in-a-linked-list/README.md", "content": "

237. Delete Node in a Linked List

Medium

There is a singly-linked list head and we want to delete a node node in it.

\n\n

You are given the node to be deleted node. You will not be given access to the first node of head.

\n\n

All the values of the linked list are unique, and it is guaranteed that the given node node is not the last node in the linked list.

\n\n

Delete the given node. Note that by deleting the node, we do not mean removing it from memory. We mean:

\n\n
    \n\t
  • The value of the given node should not exist in the linked list.
    • \n\t
  • The number of nodes in the linked list should decrease by one.
    • \n\t
  • All the values before node should be in the same order.
    • \n\t
  • All the values after node should be in the same order.
    • \n
\n\n

Custom testing:

\n\n
    \n\t
  • For the input, you should provide the entire linked list head and the node to be given node. node should not be the last node of the list and should be an actual node in the list.
    • \n\t
  • We will build the linked list and pass the node to your function.
    • \n\t
  • The output will be the entire list after calling your function.
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [4,5,1,9], node = 5\nOutput: [4,1,9]\nExplanation: You are given the second node with value 5, the linked list should become 4 -> 1 -> 9 after calling your function.\n
\n\n

Example 2:

\n\"\"\n
Input: head = [4,5,1,9], node = 1\nOutput: [4,5,9]\nExplanation: You are given the third node with value 1, the linked list should become 4 -> 5 -> 9 after calling your function.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of the nodes in the given list is in the range [2, 1000].
    • \n\t
  • -1000 <= Node.val <= 1000
    • \n\t
  • The value of each node in the list is unique.
    • \n\t
  • The node to be deleted is in the list and is not a tail node.
    • \n
\n
" }, { "path": "0242-valid-anagram/0242-valid-anagram.cpp", "content": "class Solution {\npublic:\n bool isAnagram(string s, string t) {\n sort(s.begin(),s.end());\n sort(t.begin(),t.end());\n if(s==t)\n return true;\n else\n return false;\n }\n};\n" }, { "path": "0242-valid-anagram/0242-valid-anagram.java", "content": "class Solution {\n public boolean isAnagram(String a, String b) {\n int[] arr=new int[128]; //O(1)\n if(a.length()!=b.length()){\n return false;\n }\n // abca\n // caba\n for(int i=0;i242. Valid Anagram

Easy

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

\n\n

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.

\n\n

 

\n

Example 1:

\n
Input: s = \"anagram\", t = \"nagaram\"\nOutput: true\n

Example 2:

\n
Input: s = \"rat\", t = \"car\"\nOutput: false\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length, t.length <= 5 * 104
    • \n\t
  • s and t consist of lowercase English letters.
    • \n
\n\n

 

\n

Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

\n
" }, { "path": "0263-ugly-number/0263-ugly-number.java", "content": "class Solution {\n public boolean isUgly(int n) {\n while(n!=0){\n if(n==1 || n==2 || n==3 || n==5){\n return true;\n }\n if(n%2==0){\n n/=2;\n }\n else if(n%3==0){\n n/=3;\n }\n else if(n%5==0){\n n/=5;\n }else{\n return false;\n }\n }\n return false;\n }\n}" }, { "path": "0263-ugly-number/NOTES.md", "content": "​" }, { "path": "0263-ugly-number/README.md", "content": "

263. Ugly Number

Easy

An ugly number is a positive integer whose prime factors are limited to 2, 3, and 5.

\n\n

Given an integer n, return true if n is an ugly number.

\n\n

 

\n

Example 1:

\n\n
Input: n = 6\nOutput: true\nExplanation: 6 = 2 × 3\n
\n\n

Example 2:

\n\n
Input: n = 1\nOutput: true\nExplanation: 1 has no prime factors, therefore all of its prime factors are limited to 2, 3, and 5.\n
\n\n

Example 3:

\n\n
Input: n = 14\nOutput: false\nExplanation: 14 is not ugly since it includes the prime factor 7.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • -231 <= n <= 231 - 1
    • \n
\n
" }, { "path": "0279-perfect-squares/0279-perfect-squares.java", "content": "class Solution {\n public int numSquares(int n) {\n\tint sqrt = (int) Math.sqrt(n);\n\n\tif (sqrt * sqrt == n) // Perfect square\n\t\treturn 1;\n\n\twhile (n % 4 == 0) // 4^a (8b + 7)\n\t\tn = n / 4;\n\n\tif (n % 8 == 7)\n\t\treturn 4;\n\n\tfor (int i = 1; i * i <= n; i++) { // Sum of two perfect squares\n\t\tint square = i * i;\n\t\tint base = (int) Math.sqrt(n - square);\n\n\t\tif (base * base == n - square)\n\t\t\treturn 2;\n\t}\n\n\treturn 3;\n}\n}" }, { "path": "0279-perfect-squares/NOTES.md", "content": "​" }, { "path": "0279-perfect-squares/README.md", "content": "

279. Perfect Squares

Medium

Given an integer n, return the least number of perfect square numbers that sum to n.

\n\n

A perfect square is an integer that is the square of an integer; in other words, it is the product of some integer with itself. For example, 1, 4, 9, and 16 are perfect squares while 3 and 11 are not.

\n\n

 

\n

Example 1:

\n\n
Input: n = 12\nOutput: 3\nExplanation: 12 = 4 + 4 + 4.\n
\n\n

Example 2:

\n\n
Input: n = 13\nOutput: 2\nExplanation: 13 = 4 + 9.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 104
    • \n
\n
" }, { "path": "0290-word-pattern/0290-word-pattern.java", "content": "class Solution {\n public boolean wordPattern(String pattern, String s) {\n String[] words = s.split(\" \");\n Map wordMap = new HashMap<>();\n Map charMap = new HashMap<>();\n if(pattern.length()!=words.length){\n return false;\n }\n for(int i= 0;i290. Word Pattern

Easy

Given a pattern and a string s, find if s follows the same pattern.

\n\n

Here follow means a full match, such that there is a bijection between a letter in pattern and a non-empty word in s.

\n\n

 

\n

Example 1:

\n\n
Input: pattern = \"abba\", s = \"dog cat cat dog\"\nOutput: true\n
\n\n

Example 2:

\n\n
Input: pattern = \"abba\", s = \"dog cat cat fish\"\nOutput: false\n
\n\n

Example 3:

\n\n
Input: pattern = \"aaaa\", s = \"dog cat cat dog\"\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= pattern.length <= 300
    • \n\t
  • pattern contains only lower-case English letters.
    • \n\t
  • 1 <= s.length <= 3000
    • \n\t
  • s contains only lowercase English letters and spaces ' '.
    • \n\t
  • s does not contain any leading or trailing spaces.
    • \n\t
  • All the words in s are separated by a single space.
    • \n
\n
" }, { "path": "0295-find-median-from-data-stream/0295-find-median-from-data-stream.java", "content": "class MedianFinder {\n \n ArrayList list;\n\n public MedianFinder() {\n list = new ArrayList<>();\n }\n \n public void addNum(int num) {\n int i;\n if(list.size() > 0){\n for (i = 0; (i < list.size() && list.get(i) < num); i++);\n if(i == -1){\n i = 0;\n }\n list.add(i , num);\n }else{\n list.add(num);\n }\n }\n \n public double findMedian() {\n // System.out.println(list);\n int index = list.size()/2;\n if(list.size() % 2 == 0){\n return (double) (list.get(index) + list.get(index - 1))/2;\n }else{\n return list.get(index);\n }\n \n }\n}" }, { "path": "0295-find-median-from-data-stream/NOTES.md", "content": "​" }, { "path": "0295-find-median-from-data-stream/README.md", "content": "

295. Find Median from Data Stream

Hard

The median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value, and the median is the mean of the two middle values.

\n\n
    \n\t
  • For example, for arr = [2,3,4], the median is 3.
    • \n\t
  • For example, for arr = [2,3], the median is (2 + 3) / 2 = 2.5.
    • \n
\n\n

Implement the MedianFinder class:

\n\n
    \n\t
  • MedianFinder() initializes the MedianFinder object.
    • \n\t
  • void addNum(int num) adds the integer num from the data stream to the data structure.
    • \n\t
  • double findMedian() returns the median of all elements so far. Answers within 10-5 of the actual answer will be accepted.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"MedianFinder\", \"addNum\", \"addNum\", \"findMedian\", \"addNum\", \"findMedian\"]\n[[], [1], [2], [], [3], []]\nOutput\n[null, null, null, 1.5, null, 2.0]\n\nExplanation\nMedianFinder medianFinder = new MedianFinder();\nmedianFinder.addNum(1);    // arr = [1]\nmedianFinder.addNum(2);    // arr = [1, 2]\nmedianFinder.findMedian(); // return 1.5 (i.e., (1 + 2) / 2)\nmedianFinder.addNum(3);    // arr[1, 2, 3]\nmedianFinder.findMedian(); // return 2.0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • -105 <= num <= 105
    • \n\t
  • There will be at least one element in the data structure before calling findMedian.
    • \n\t
  • At most 5 * 104 calls will be made to addNum and findMedian.
    • \n
\n\n

 

\n

Follow up:

\n\n
    \n\t
  • If all integer numbers from the stream are in the range [0, 100], how would you optimize your solution?
    • \n\t
  • If 99% of all integer numbers from the stream are in the range [0, 100], how would you optimize your solution?
    • \n
\n
" }, { "path": "0309-best-time-to-buy-and-sell-stock-with-cooldown/0309-best-time-to-buy-and-sell-stock-with-cooldown.java", "content": "class Solution {\n public int maxProfit(int[] prices) {\n if (prices == null || prices.length <= 1) {\n return 0;\n }\n int len = prices.length;\n int[] hold = new int[len];\n int[] unHold = new int[len];\n hold[0] = -prices[0];\n hold[1] = Math.max(-prices[0], -prices[1]);\n unHold[0] = 0;\n unHold[1] = Math.max(0, prices[1] - prices[0]);\n for (int i = 2; i < len; i++) {\n hold[i] = Math.max(hold[i - 1], unHold[i - 2] - prices[i]); \n unHold[i] = Math.max(unHold[i - 1], hold[i - 1] + prices[i]);\n }\n return unHold[len - 1];\n }\n}" }, { "path": "0309-best-time-to-buy-and-sell-stock-with-cooldown/NOTES.md", "content": "​" }, { "path": "0309-best-time-to-buy-and-sell-stock-with-cooldown/README.md", "content": "

309. Best Time to Buy and Sell Stock with Cooldown

Medium

You are given an array prices where prices[i] is the price of a given stock on the ith day.

\n\n

Find the maximum profit you can achieve. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times) with the following restrictions:

\n\n
    \n\t
  • After you sell your stock, you cannot buy stock on the next day (i.e., cooldown one day).
    • \n
\n\n

Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).

\n\n

 

\n

Example 1:

\n\n
Input: prices = [1,2,3,0,2]\nOutput: 3\nExplanation: transactions = [buy, sell, cooldown, buy, sell]\n
\n\n

Example 2:

\n\n
Input: prices = [1]\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= prices.length <= 5000
    • \n\t
  • 0 <= prices[i] <= 1000
    • \n
\n
" }, { "path": "0328-odd-even-linked-list/0328-odd-even-linked-list.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode oddEvenList(ListNode head) {\n if(head==null || head.next==null)return head;\n ListNode oddHead=head;\n ListNode evenHead=head.next;\n ListNode odd=head;\n ListNode even=head.next;\n while(odd!=null && even!=null && even.next!=null){\n odd.next=odd.next.next;\n even.next=even.next.next;\n odd=odd.next;\n even=even.next;\n }\n if(odd==null)even.next=oddHead;\n else odd.next=evenHead;\n return oddHead;\n }\n}" }, { "path": "0328-odd-even-linked-list/NOTES.md", "content": "​" }, { "path": "0328-odd-even-linked-list/README.md", "content": "

328. Odd Even Linked List

Medium

Given the head of a singly linked list, group all the nodes with odd indices together followed by the nodes with even indices, and return the reordered list.

\n\n

The first node is considered odd, and the second node is even, and so on.

\n\n

Note that the relative order inside both the even and odd groups should remain as it was in the input.

\n\n

You must solve the problem in O(1) extra space complexity and O(n) time complexity.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,3,4,5]\nOutput: [1,3,5,2,4]\n
\n\n

Example 2:

\n\"\"\n
Input: head = [2,1,3,5,6,4,7]\nOutput: [2,3,6,7,1,5,4]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the linked list is in the range [0, 104].
    • \n\t
  • -106 <= Node.val <= 106
    • \n
\n
" }, { "path": "0334-increasing-triplet-subsequence/0334-increasing-triplet-subsequence.java", "content": "class Solution {\n public boolean increasingTriplet(int[] nums) {\n int first_num = Integer.MAX_VALUE;\n int second_num = Integer.MAX_VALUE;\n for(int num:nums)\n {\n if(num<=first_num)\n {\n first_num = num;\n }\n else if(num<=second_num)\n {\n second_num = num;\n }else\n {\n return true;\n }\n }\n return false;\n }\n}" }, { "path": "0334-increasing-triplet-subsequence/NOTES.md", "content": "​" }, { "path": "0334-increasing-triplet-subsequence/README.md", "content": "

334. Increasing Triplet Subsequence

Medium

Given an integer array nums, return true if there exists a triple of indices (i, j, k) such that i < j < k and nums[i] < nums[j] < nums[k]. If no such indices exists, return false.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3,4,5]\nOutput: true\nExplanation: Any triplet where i < j < k is valid.\n
\n\n

Example 2:

\n\n
Input: nums = [5,4,3,2,1]\nOutput: false\nExplanation: No triplet exists.\n
\n\n

Example 3:

\n\n
Input: nums = [2,1,5,0,4,6]\nOutput: true\nExplanation: The triplet (3, 4, 5) is valid because nums[3] == 0 < nums[4] == 4 < nums[5] == 6.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 5 * 105
    • \n\t
  • -231 <= nums[i] <= 231 - 1
    • \n
\n\n

 

\nFollow up: Could you implement a solution that runs in O(n) time complexity and O(1) space complexity?
" }, { "path": "0345-reverse-vowels-of-a-string/0345-reverse-vowels-of-a-string.java", "content": "class Solution {\n public String reverseVowels(String s) {\n int i=0;\n int j=s.length()-1;\n char[]arr=s.toCharArray();\n while(ii && !vowel(arr[j]))j--;\n if(i>j)break;\n char temp=arr[i];\n arr[i]=arr[j];\n arr[j]=temp;\n i++;\n j--;\n }\n return new String(arr);\n }\n boolean vowel(char c){\n return switch (c) {\n case 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U' -> true;\n default -> false;\n };\n \n }\n}" }, { "path": "0345-reverse-vowels-of-a-string/NOTES.md", "content": "​" }, { "path": "0345-reverse-vowels-of-a-string/README.md", "content": "

345. Reverse Vowels of a String

Easy

Given a string s, reverse only all the vowels in the string and return it.

\n\n

The vowels are 'a', 'e', 'i', 'o', and 'u', and they can appear in both lower and upper cases, more than once.

\n\n

 

\n

Example 1:

\n
Input: s = \"hello\"\nOutput: \"holle\"\n

Example 2:

\n
Input: s = \"leetcode\"\nOutput: \"leotcede\"\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 3 * 105
    • \n\t
  • s consist of printable ASCII characters.
    • \n
\n
" }, { "path": "0374-guess-number-higher-or-lower/0374-guess-number-higher-or-lower.java", "content": "/* The guess API is defined in the parent class GuessGame.\n @param num, your guess\n @return -1 if my number is lower, 1 if my number is higher, otherwise return 0\n int guess(int num); */\n\npublic class Solution extends GuessGame {\n public int guessNumber(int n) {\n int low = 1;\n int high = n;\n while (low <= high) {\n int mid1 = low + (high - low) / 3;\n int mid2 = high - (high - low) / 3;\n int res1 = guess(mid1);\n int res2 = guess(mid2);\n if (res1 == 0)\n return mid1;\n if (res2 == 0)\n return mid2;\n else if (res1 < 0)\n high = mid1 - 1;\n else if (res2 > 0)\n low = mid2 + 1;\n else {\n low = mid1 + 1;\n high = mid2 - 1;\n }\n }\n return -1;\n }\n}" }, { "path": "0374-guess-number-higher-or-lower/NOTES.md", "content": "​" }, { "path": "0374-guess-number-higher-or-lower/README.md", "content": "

374. Guess Number Higher or Lower

Easy

We are playing the Guess Game. The game is as follows:

\n\n

I pick a number from 1 to n. You have to guess which number I picked.

\n\n

Every time you guess wrong, I will tell you whether the number I picked is higher or lower than your guess.

\n\n

You call a pre-defined API int guess(int num), which returns three possible results:

\n\n
    \n\t
  • -1: Your guess is higher than the number I picked (i.e. num > pick).
    • \n\t
  • 1: Your guess is lower than the number I picked (i.e. num < pick).
    • \n\t
  • 0: your guess is equal to the number I picked (i.e. num == pick).
    • \n
\n\n

Return the number that I picked.

\n\n

 

\n

Example 1:

\n\n
Input: n = 10, pick = 6\nOutput: 6\n
\n\n

Example 2:

\n\n
Input: n = 1, pick = 1\nOutput: 1\n
\n\n

Example 3:

\n\n
Input: n = 2, pick = 1\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 231 - 1
    • \n\t
  • 1 <= pick <= n
    • \n
\n
" }, { "path": "0380-insert-delete-getrandom-o1/0380-insert-delete-getrandom-o1.java", "content": "class RandomizedSet {\n List list;\n HashMap map;\n \n public RandomizedSet() {\n list=new ArrayList<>();\n map=new HashMap<>();\n }\n \n public boolean insert(int val) {\n if(!map.containsKey(val)){\n list.add(val);\n map.put(val,list.size()-1);\n return true;\n }\n return false;\n }\n \n // Swap value to be removed with last value. Remove now the value at last \n // index & update map with new index and remove the value to be removed.\n public boolean remove(int val) {\n if(map.containsKey(val)){\n int index=map.get(val);\n swap(index);\n list.remove(list.size()-1);\n map.remove(val);\n return true;\n }\n return false;\n }\n \n // User defined.\n private void swap(int index) {\n int lastIndex=list.size()-1;\n int lastVal=list.get(lastIndex);\n \n int temp=list.get(index);\n list.set(index,lastVal);\n \n map.put(lastVal,index);\n }\n \n public int getRandom() {\n return list.get(new Random().nextInt(list.size()));\n }\n}" }, { "path": "0380-insert-delete-getrandom-o1/NOTES.md", "content": "​" }, { "path": "0380-insert-delete-getrandom-o1/README.md", "content": "

380. Insert Delete GetRandom O(1)

Medium

Implement the RandomizedSet class:

\n\n
    \n\t
  • RandomizedSet() Initializes the RandomizedSet object.
    • \n\t
  • bool insert(int val) Inserts an item val into the set if not present. Returns true if the item was not present, false otherwise.
    • \n\t
  • bool remove(int val) Removes an item val from the set if present. Returns true if the item was present, false otherwise.
    • \n\t
  • int getRandom() Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the same probability of being returned.
    • \n
\n\n

You must implement the functions of the class such that each function works in average O(1) time complexity.

\n\n

 

\n

Example 1:

\n\n
Input\n[\"RandomizedSet\", \"insert\", \"remove\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"getRandom\"]\n[[], [1], [2], [2], [], [1], [2], []]\nOutput\n[null, true, false, true, 2, true, false, 2]\n\nExplanation\nRandomizedSet randomizedSet = new RandomizedSet();\nrandomizedSet.insert(1); // Inserts 1 to the set. Returns true as 1 was inserted successfully.\nrandomizedSet.remove(2); // Returns false as 2 does not exist in the set.\nrandomizedSet.insert(2); // Inserts 2 to the set, returns true. Set now contains [1,2].\nrandomizedSet.getRandom(); // getRandom() should return either 1 or 2 randomly.\nrandomizedSet.remove(1); // Removes 1 from the set, returns true. Set now contains [2].\nrandomizedSet.insert(2); // 2 was already in the set, so return false.\nrandomizedSet.getRandom(); // Since 2 is the only number in the set, getRandom() will always return 2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • -231 <= val <= 231 - 1
    • \n\t
  • At most 2 * 105 calls will be made to insert, remove, and getRandom.
    • \n\t
  • There will be at least one element in the data structure when getRandom is called.
    • \n
\n
" }, { "path": "0409-longest-palindrome/0409-longest-palindrome.java", "content": "class Solution {\n public int longestPalindrome(String s) {\n int[]freq=new int[123];\n for(char c:s.toCharArray()){\n freq[c]++;\n }\n int ans=0;\n boolean hasOdd=false;\n for(int i:freq){\n if((i&1)==1){\n hasOdd=true;\n ans+=i-1;\n }else{\n ans+=i;\n }\n }\n return hasOdd?ans+1:ans;\n }\n}" }, { "path": "0409-longest-palindrome/NOTES.md", "content": "​" }, { "path": "0409-longest-palindrome/README.md", "content": "

409. Longest Palindrome

Easy

Given a string s which consists of lowercase or uppercase letters, return the length of the longest palindrome that can be built with those letters.

\n\n

Letters are case sensitive, for example, \"Aa\" is not considered a palindrome here.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"abccccdd\"\nOutput: 7\nExplanation: One longest palindrome that can be built is \"dccaccd\", whose length is 7.\n
\n\n

Example 2:

\n\n
Input: s = \"a\"\nOutput: 1\nExplanation: The longest palindrome that can be built is \"a\", whose length is 1.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 2000
    • \n\t
  • s consists of lowercase and/or uppercase English letters only.
    • \n
\n
" }, { "path": "0446-arithmetic-slices-ii-subsequence/0446-arithmetic-slices-ii-subsequence.java", "content": "\nclass Solution {\n public int numberOfArithmeticSlices(int[] A) {\n int n = A.length;\n long ans = 0;\n Map[] cnt = new Map[n];\n for (int i = 0; i < n; i++) {\n cnt[i] = new HashMap<>(i);\n for (int j = 0; j < i; j++) {\n long delta = (long)A[i] - (long)A[j];\n if (delta < Integer.MIN_VALUE || delta > Integer.MAX_VALUE) {\n continue;\n }\n int diff = (int)delta;\n int sum = cnt[j].getOrDefault(diff, 0);\n int origin = cnt[i].getOrDefault(diff, 0);\n cnt[i].put(diff, origin + sum + 1);\n ans += sum;\n }\n }\n return (int)ans; \n }\n}" }, { "path": "0446-arithmetic-slices-ii-subsequence/NOTES.md", "content": "​" }, { "path": "0446-arithmetic-slices-ii-subsequence/README.md", "content": "

446. Arithmetic Slices II - Subsequence

Hard

Given an integer array nums, return the number of all the arithmetic subsequences of nums.

\n\n

A sequence of numbers is called arithmetic if it consists of at least three elements and if the difference between any two consecutive elements is the same.

\n\n
    \n\t
  • For example, [1, 3, 5, 7, 9], [7, 7, 7, 7], and [3, -1, -5, -9] are arithmetic sequences.
    • \n\t
  • For example, [1, 1, 2, 5, 7] is not an arithmetic sequence.
    • \n
\n\n

A subsequence of an array is a sequence that can be formed by removing some elements (possibly none) of the array.

\n\n
    \n\t
  • For example, [2,5,10] is a subsequence of [1,2,1,2,4,1,5,10].
    • \n
\n\n

The test cases are generated so that the answer fits in 32-bit integer.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [2,4,6,8,10]\nOutput: 7\nExplanation: All arithmetic subsequence slices are:\n[2,4,6]\n[4,6,8]\n[6,8,10]\n[2,4,6,8]\n[4,6,8,10]\n[2,4,6,8,10]\n[2,6,10]\n
\n\n

Example 2:

\n\n
Input: nums = [7,7,7,7,7]\nOutput: 16\nExplanation: Any subsequence of this array is arithmetic.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1  <= nums.length <= 1000
    • \n\t
  • -231 <= nums[i] <= 231 - 1
    • \n
\n
" }, { "path": "0451-sort-characters-by-frequency/0451-sort-characters-by-frequency.java", "content": "class Solution {\n public String frequencySort(String s) {\n int[] a = new int[750];\n \n for(int i=0;ia[max_freq])\n max_freq=i;\n }\n sb.append(String.valueOf((char)(max_freq+48)).repeat(a[max_freq]));\n a[max_freq]=0; \n }\n return sb.toString();\n }\n}" }, { "path": "0451-sort-characters-by-frequency/NOTES.md", "content": "​" }, { "path": "0451-sort-characters-by-frequency/README.md", "content": "

451. Sort Characters By Frequency

Medium

Given a string s, sort it in decreasing order based on the frequency of the characters. The frequency of a character is the number of times it appears in the string.

\n\n

Return the sorted string. If there are multiple answers, return any of them.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"tree\"\nOutput: \"eert\"\nExplanation: 'e' appears twice while 'r' and 't' both appear once.\nSo 'e' must appear before both 'r' and 't'. Therefore \"eetr\" is also a valid answer.\n
\n\n

Example 2:

\n\n
Input: s = \"cccaaa\"\nOutput: \"aaaccc\"\nExplanation: Both 'c' and 'a' appear three times, so both \"cccaaa\" and \"aaaccc\" are valid answers.\nNote that \"cacaca\" is incorrect, as the same characters must be together.\n
\n\n

Example 3:

\n\n
Input: s = \"Aabb\"\nOutput: \"bbAa\"\nExplanation: \"bbaA\" is also a valid answer, but \"Aabb\" is incorrect.\nNote that 'A' and 'a' are treated as two different characters.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 5 * 105
    • \n\t
  • s consists of uppercase and lowercase English letters and digits.
    • \n
\n
" }, { "path": "0452-minimum-number-of-arrows-to-burst-balloons/0452-minimum-number-of-arrows-to-burst-balloons.java", "content": "class Solution {\n public int findMinArrowShots(int[][] points) {\n \n // This Problem is similar to Non Overlapping Interval Problem of Greedy Approach\n // Link for detiled discussion : http://www.leetcode-solution.com/2019/06/01/0452-minimum-number-of-arrows-to-burst-balloons.html\n \n // Base case\n if(points.length == 0)\n return 0;\n \n // Sort the point accroding to their end points i.e., a[1] - b[1]\n Arrays.sort(points, (a,b) -> a[1] - b[1]);\n \n // Position arrow at end (Extreme Right) as it has maximum chance of hittng there\n int arrPos = points[0][1];\n int count = 1; // Minimun 1 arrow is required to shoot any points\n \n for(int i = 1; i < points.length; i++ ) // start with 1 as 0th index end will be check for start of 1st \n {\n int left = points[i][0];\n int right = points[i][1];\n \n \n //check whether the arrowFired can burst other balloons.\n //if not fire arrow at the next point end value\n if (!(arrPos >= left && arrPos <= right)) \n {\n \n count++; // increase the arrowsFired by 1.\n arrPos = points[i][1]; // next point end value.\n \n }\n /* if(arrPos >= points[i][0]) // Since Current arrow position than start pos of array that means we can \n { // continue, but as soon as it not true we break as our current arrow pos\n continue; // cant handle beyond that point . so update its pos and count++\n }\n count++ ; // As we are done with current pos \n arrPos = points[i][1]; // Update as we already exhausted our option with previous position\n */\n \n }\n \n return count;\n }\n}\n" }, { "path": "0452-minimum-number-of-arrows-to-burst-balloons/NOTES.md", "content": "​" }, { "path": "0452-minimum-number-of-arrows-to-burst-balloons/README.md", "content": "

452. Minimum Number of Arrows to Burst Balloons

Medium

There are some spherical balloons taped onto a flat wall that represents the XY-plane. The balloons are represented as a 2D integer array points where points[i] = [xstart, xend] denotes a balloon whose horizontal diameter stretches between xstart and xend. You do not know the exact y-coordinates of the balloons.

\n\n

Arrows can be shot up directly vertically (in the positive y-direction) from different points along the x-axis. A balloon with xstart and xend is burst by an arrow shot at x if xstart <= x <= xend. There is no limit to the number of arrows that can be shot. A shot arrow keeps traveling up infinitely, bursting any balloons in its path.

\n\n

Given the array points, return the minimum number of arrows that must be shot to burst all balloons.

\n\n

 

\n

Example 1:

\n\n
Input: points = [[10,16],[2,8],[1,6],[7,12]]\nOutput: 2\nExplanation: The balloons can be burst by 2 arrows:\n- Shoot an arrow at x = 6, bursting the balloons [2,8] and [1,6].\n- Shoot an arrow at x = 11, bursting the balloons [10,16] and [7,12].\n
\n\n

Example 2:

\n\n
Input: points = [[1,2],[3,4],[5,6],[7,8]]\nOutput: 4\nExplanation: One arrow needs to be shot for each balloon for a total of 4 arrows.\n
\n\n

Example 3:

\n\n
Input: points = [[1,2],[2,3],[3,4],[4,5]]\nOutput: 2\nExplanation: The balloons can be burst by 2 arrows:\n- Shoot an arrow at x = 2, bursting the balloons [1,2] and [2,3].\n- Shoot an arrow at x = 4, bursting the balloons [3,4] and [4,5].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= points.length <= 105
    • \n\t
  • points[i].length == 2
    • \n\t
  • -231 <= xstart < xend <= 231 - 1
    • \n
\n
" }, { "path": "0491-non-decreasing-subsequences/0491-non-decreasing-subsequences.java", "content": "class Solution {\n private void backtrack(int[] nums, int index, List sequence,\n Set> result) {\n // if we have checked all elements\n if (index == nums.length) {\n if (sequence.size() >= 2) {\n result.add(new ArrayList<>(sequence));\n }\n return;\n }\n // if the sequence remains increasing after appending nums[index]\n if (sequence.isEmpty() ||\n sequence.get(sequence.size() - 1) <= nums[index]) {\n // append nums[index] to the sequence\n sequence.add(nums[index]);\n // call recursively\n backtrack(nums, index + 1, sequence, result);\n // delete nums[index] from the end of the sequence\n sequence.remove(sequence.size() - 1);\n }\n // call recursively not appending an element\n backtrack(nums, index + 1, sequence, result);\n }\n\n public List> findSubsequences(int[] nums) {\n Set> result = new HashSet>();\n List sequence = new ArrayList();\n backtrack(nums, 0, sequence, result);\n return new ArrayList(result);\n }\n}" }, { "path": "0491-non-decreasing-subsequences/NOTES.md", "content": "​" }, { "path": "0491-non-decreasing-subsequences/README.md", "content": "

491. Non-decreasing Subsequences

Medium

Given an integer array nums, return all the different possible non-decreasing subsequences of the given array with at least two elements. You may return the answer in any order.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [4,6,7,7]\nOutput: [[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]\n
\n\n

Example 2:

\n\n
Input: nums = [4,4,3,2,1]\nOutput: [[4,4]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 15
    • \n\t
  • -100 <= nums[i] <= 100
    • \n
\n
" }, { "path": "0520-detect-capital/0520-detect-capital.java", "content": "class Solution {\n public boolean detectCapitalUse(String word) {\n int n = word.length();\n if (n == 1) {\n return true;\n }\n\n // case 1: All capital\n if (Character.isUpperCase(word.charAt(0)) && Character.isUpperCase(word.charAt(1))) {\n for (int i = 2; i < n; i++) {\n if (Character.isLowerCase(word.charAt(i))) {\n return false;\n }\n }\n // case 2 and case 3\n } else {\n for (int i = 1; i < n; i++) {\n if (Character.isUpperCase(word.charAt(i))) {\n return false;\n }\n }\n }\n\n // if pass one of the cases\n return true;\n }\n}" }, { "path": "0520-detect-capital/NOTES.md", "content": "​" }, { "path": "0523-continuous-subarray-sum/0523-continuous-subarray-sum.java", "content": "class Solution \n{\n public boolean checkSubarraySum(int[] nums, int k) \n {\n int prefixSum = 0;\n \n HashMap map = new HashMap<>();\n \n map.put(0, -1);\n\n for (int i = 0; i < nums.length; i++)\n {\n prefixSum += nums[i];\n \n // this is the twist\n if (k != 0)\n {\n prefixSum = prefixSum % k; //whose elements sum up to a multiple of k\n }\n \n // this is general\n if (map.containsKey(prefixSum))\n {\n // if nums has a continuous subarray of size at least two elements\n if (i - map.get(prefixSum) > 1) \n {\n return true;\n }\n }\n else\n {\n map.put(prefixSum, i); // adding the index\n }\n }\n return false;\n }\n}" }, { "path": "0523-continuous-subarray-sum/NOTES.md", "content": "​" }, { "path": "0523-continuous-subarray-sum/README.md", "content": "

523. Continuous Subarray Sum

Medium

Given an integer array nums and an integer k, return true if nums has a continuous subarray of size at least two whose elements sum up to a multiple of k, or false otherwise.

\n\n

An integer x is a multiple of k if there exists an integer n such that x = n * k. 0 is always a multiple of k.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [23,2,4,6,7], k = 6\nOutput: true\nExplanation: [2, 4] is a continuous subarray of size 2 whose elements sum up to 6.\n
\n\n

Example 2:

\n\n
Input: nums = [23,2,6,4,7], k = 6\nOutput: true\nExplanation: [23, 2, 6, 4, 7] is an continuous subarray of size 5 whose elements sum up to 42.\n42 is a multiple of 6 because 42 = 7 * 6 and 7 is an integer.\n
\n\n

Example 3:

\n\n
Input: nums = [23,2,6,4,7], k = 13\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • 0 <= nums[i] <= 109
    • \n\t
  • 0 <= sum(nums[i]) <= 231 - 1
    • \n\t
  • 1 <= k <= 231 - 1
    • \n
\n
" }, { "path": "0587-erect-the-fence/0587-erect-the-fence.java", "content": "public class Solution {\n public int orientation(int[] p, int[] q, int[] r) {\n return (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1]);\n }\n public int[][] outerTrees(int[][] points) {\n Arrays.sort(points, new Comparator () {\n public int compare(int[] p, int[] q) {\n return q[0] - p[0] == 0 ? q[1] - p[1] : q[0] - p[0];\n }\n });\n Stack hull = new Stack<>();\n for (int i = 0; i < points.length; i++) {\n while (hull.size() >= 2 && orientation(hull.get(hull.size() - 2), hull.get(hull.size() - 1), points[i]) > 0)\n hull.pop();\n hull.push(points[i]);\n }\n hull.pop();\n for (int i = points.length - 1; i >= 0; i--) {\n while (hull.size() >= 2 && orientation(hull.get(hull.size() - 2), hull.get(hull.size() - 1), points[i]) > 0)\n hull.pop();\n hull.push(points[i]);\n }\n // remove redundant elements from the stack\n HashSet ret = new HashSet<>(hull);\n return ret.toArray(new int[ret.size()][]);\n }\n}" }, { "path": "0587-erect-the-fence/README.md", "content": "

587. Erect the Fence

Hard

You are given an array trees where trees[i] = [xi, yi] represents the location of a tree in the garden.

\n\n

You are asked to fence the entire garden using the minimum length of rope as it is expensive. The garden is well fenced only if all the trees are enclosed.

\n\n

Return the coordinates of trees that are exactly located on the fence perimeter.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: points = [[1,1],[2,2],[2,0],[2,4],[3,3],[4,2]]\nOutput: [[1,1],[2,0],[3,3],[2,4],[4,2]]\n
\n\n

Example 2:

\n\"\"\n
Input: points = [[1,2],[2,2],[4,2]]\nOutput: [[4,2],[2,2],[1,2]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= points.length <= 3000
    • \n\t
  • points[i].length == 2
    • \n\t
  • 0 <= xi, yi <= 100
    • \n\t
  • All the given points are unique.
    • \n
\n
" }, { "path": "0645-set-mismatch/0645-set-mismatch.java", "content": "class Solution {\n public int[] findErrorNums(int[] nums) {\n /** Assume m is the missing and d is the duplicate element\n diff= m-d;\n squareDiff= m^2-d^2;\n sum=m+d= squareDiff/diff\n =>sum = (m+d)(m-d)/(m-d);\n now m=(sum+diff)2;\n and d= (sum-diff)2;\n **/\n int diff=0;\n int sqaureDiff=0;\n for(int i=0;i645. Set Mismatch

Easy

You have a set of integers s, which originally contains all the numbers from 1 to n. Unfortunately, due to some error, one of the numbers in s got duplicated to another number in the set, which results in repetition of one number and loss of another number.

\n\n

You are given an integer array nums representing the data status of this set after the error.

\n\n

Find the number that occurs twice and the number that is missing and return them in the form of an array.

\n\n

 

\n

Example 1:

\n
Input: nums = [1,2,2,4]\nOutput: [2,3]\n

Example 2:

\n
Input: nums = [1,1]\nOutput: [1,2]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= nums.length <= 104
    • \n\t
  • 1 <= nums[i] <= 104
    • \n
\n
" }, { "path": "0692-top-k-frequent-words/0692-top-k-frequent-words.java", "content": "class Solution {\n public List topKFrequent(String[] words, int k) {\n Map map = new HashMap<>();\n for(String w : words){\n int c = map.getOrDefault(w,0);\n c++;\n map.put(w,c);\n }\n Queue> pq = new PriorityQueue<>((a,b)->(a.getValue() == b.getValue() ? a.getKey().compareTo(b.getKey()) : (a.getValue()-b.getValue())*-1));\n\n for(Map.Entry e : map.entrySet()){\n pq.offer(e);\n }\n List result = new ArrayList<>();\n while(k > 0){\n k--;\n result.add(pq.poll().getKey());\n }\n return result;\n\n }\n}" }, { "path": "0692-top-k-frequent-words/NOTES.md", "content": "​" }, { "path": "0692-top-k-frequent-words/README.md", "content": "

692. Top K Frequent Words

Medium

Given an array of strings words and an integer k, return the k most frequent strings.

\n\n

Return the answer sorted by the frequency from highest to lowest. Sort the words with the same frequency by their lexicographical order.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"i\",\"love\",\"leetcode\",\"i\",\"love\",\"coding\"], k = 2\nOutput: [\"i\",\"love\"]\nExplanation: \"i\" and \"love\" are the two most frequent words.\nNote that \"i\" comes before \"love\" due to a lower alphabetical order.\n
\n\n

Example 2:

\n\n
Input: words = [\"the\",\"day\",\"is\",\"sunny\",\"the\",\"the\",\"the\",\"sunny\",\"is\",\"is\"], k = 4\nOutput: [\"the\",\"is\",\"sunny\",\"day\"]\nExplanation: \"the\", \"is\", \"sunny\" and \"day\" are the four most frequent words, with the number of occurrence being 4, 3, 2 and 1 respectively.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words.length <= 500
    • \n\t
  • 1 <= words[i].length <= 10
    • \n\t
  • words[i] consists of lowercase English letters.
    • \n\t
  • k is in the range [1, The number of unique words[i]]
    • \n
\n\n

 

\n

Follow-up: Could you solve it in O(n log(k)) time and O(n) extra space?

\n
" }, { "path": "0739-daily-temperatures/0739-daily-temperatures.java", "content": "class Solution {\n public int[] dailyTemperatures(int[] a) {\n Deque s=new ArrayDeque<>();\n int[]ans=new int[a.length];\n for(int i=a.length-1;i>=0;i--){\n while(!s.isEmpty() && a[s.peek()]<=a[i]){\n s.pop();\n }\n if(s.isEmpty()){\n ans[i]=0;\n }else{\n ans[i]=s.peek()-i;\n }\n s.push(i);\n }\n return ans;\n }\n}" }, { "path": "0739-daily-temperatures/README.md", "content": "

739. Daily Temperatures

Medium

Given an array of integers temperatures represents the daily temperatures, return an array answer such that answer[i] is the number of days you have to wait after the ith day to get a warmer temperature. If there is no future day for which this is possible, keep answer[i] == 0 instead.

\n\n

 

\n

Example 1:

\n
Input: temperatures = [73,74,75,71,69,72,76,73]\nOutput: [1,1,4,2,1,1,0,0]\n

Example 2:

\n
Input: temperatures = [30,40,50,60]\nOutput: [1,1,1,0]\n

Example 3:

\n
Input: temperatures = [30,60,90]\nOutput: [1,1,0]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= temperatures.length <= 105
    • \n\t
  • 30 <= temperatures[i] <= 100
    • \n
\n
" }, { "path": "0766-toeplitz-matrix/0766-toeplitz-matrix.java", "content": "class Solution {\n public boolean isToeplitzMatrix(int[][] matrix) {\n for(int i=0;i766. Toeplitz Matrix

Easy

Given an m x n matrix, return true if the matrix is Toeplitz. Otherwise, return false.

\n\n

A matrix is Toeplitz if every diagonal from top-left to bottom-right has the same elements.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: matrix = [[1,2,3,4],[5,1,2,3],[9,5,1,2]]\nOutput: true\nExplanation:\nIn the above grid, the diagonals are:\n\"[9]\", \"[5, 5]\", \"[1, 1, 1]\", \"[2, 2, 2]\", \"[3, 3]\", \"[4]\".\nIn each diagonal all elements are the same, so the answer is True.\n
\n\n

Example 2:

\n\"\"\n
Input: matrix = [[1,2],[2,2]]\nOutput: false\nExplanation:\nThe diagonal \"[1, 2]\" has different elements.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == matrix.length
    • \n\t
  • n == matrix[i].length
    • \n\t
  • 1 <= m, n <= 20
    • \n\t
  • 0 <= matrix[i][j] <= 99
    • \n
\n\n

 

\n

Follow up:

\n\n
    \n\t
  • What if the matrix is stored on disk, and the memory is limited such that you can only load at most one row of the matrix into the memory at once?
    • \n\t
  • What if the matrix is so large that you can only load up a partial row into the memory at once?
    • \n
\n
" }, { "path": "0787-cheapest-flights-within-k-stops/0787-cheapest-flights-within-k-stops.java", "content": "class Solution {\n public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {\n Map> adj = new HashMap<>();\n for (int[] i : flights)\n adj.computeIfAbsent(i[0], value -> new ArrayList<>()).add(new int[] { i[1], i[2] });\n\n int[] dist = new int[n];\n Arrays.fill(dist, Integer.MAX_VALUE);\n\n Queue q = new LinkedList<>();\n q.offer(new int[] { src, 0 });\n int stops = 0;\n\n while (stops <= k && !q.isEmpty()) {\n int sz = q.size();\n // Iterate on current level.\n while (sz-- > 0) {\n int[] temp = q.poll();\n int node = temp[0];\n int distance = temp[1];\n\n if (!adj.containsKey(node))\n continue;\n // Loop over neighbors of popped node.\n for (int[] e : adj.get(node)) {\n int neighbour = e[0];\n int price = e[1];\n if (price + distance >= dist[neighbour])\n continue;\n dist[neighbour] = price + distance;\n q.offer(new int[] { neighbour, dist[neighbour] });\n }\n }\n stops++;\n }\n return dist[dst] == Integer.MAX_VALUE ? -1 : dist[dst];\n }\n}" }, { "path": "0787-cheapest-flights-within-k-stops/NOTES.md", "content": "​" }, { "path": "0787-cheapest-flights-within-k-stops/README.md", "content": "

787. Cheapest Flights Within K Stops

Medium

There are n cities connected by some number of flights. You are given an array flights where flights[i] = [fromi, toi, pricei] indicates that there is a flight from city fromi to city toi with cost pricei.

\n\n

You are also given three integers src, dst, and k, return the cheapest price from src to dst with at most k stops. If there is no such route, return -1.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1\nOutput: 700\nExplanation:\nThe graph is shown above.\nThe optimal path with at most 1 stop from city 0 to 3 is marked in red and has cost 100 + 600 = 700.\nNote that the path through cities [0,1,2,3] is cheaper but is invalid because it uses 2 stops.\n
\n\n

Example 2:

\n\"\"\n
Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1\nOutput: 200\nExplanation:\nThe graph is shown above.\nThe optimal path with at most 1 stop from city 0 to 2 is marked in red and has cost 100 + 100 = 200.\n
\n\n

Example 3:

\n\"\"\n
Input: n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0\nOutput: 500\nExplanation:\nThe graph is shown above.\nThe optimal path with no stops from city 0 to 2 is marked in red and has cost 500.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 100
    • \n\t
  • 0 <= flights.length <= (n * (n - 1) / 2)
    • \n\t
  • flights[i].length == 3
    • \n\t
  • 0 <= fromi, toi < n
    • \n\t
  • fromi != toi
    • \n\t
  • 1 <= pricei <= 104
    • \n\t
  • There will not be any multiple flights between two cities.
    • \n\t
  • 0 <= src, dst, k < n
    • \n\t
  • src != dst
    • \n
\n
" }, { "path": "0790-domino-and-tromino-tiling/0790-domino-and-tromino-tiling.java", "content": "class Solution {\n public int numTilings(int n) {\n int dp[] = new int[n+4];\n \n int mod = (int)(Math.pow(10,9)+7);\n dp[1] = 1;\n dp[2] = 2;\n dp[3] = 5;\n \n for(int i=4;i<=n;i++){\n dp[i] = ((2*dp[i-1])%mod)+dp[i-3];\n dp[i] %= mod;\n }\n \n return dp[n];\n }\n}" }, { "path": "0790-domino-and-tromino-tiling/NOTES.md", "content": "​" }, { "path": "0790-domino-and-tromino-tiling/README.md", "content": "

790. Domino and Tromino Tiling

Medium

You have two types of tiles: a 2 x 1 domino shape and a tromino shape. You may rotate these shapes.

\n\"\"\n

Given an integer n, return the number of ways to tile an 2 x n board. Since the answer may be very large, return it modulo 109 + 7.

\n\n

In a tiling, every square must be covered by a tile. Two tilings are different if and only if there are two 4-directionally adjacent cells on the board such that exactly one of the tilings has both squares occupied by a tile.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 3\nOutput: 5\nExplanation: The five different ways are show above.\n
\n\n

Example 2:

\n\n
Input: n = 1\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 1000
    • \n
\n
" }, { "path": "0797-all-paths-from-source-to-target/0797-all-paths-from-source-to-target.java", "content": "class Solution {\n public List> allPathsSourceTarget(int[][] graph) {\n \n List> ans = new ArrayList<>();\n List temp = new ArrayList<>();\n temp.add(0);\n dfs(graph,ans,temp,0);\n return ans;\n }\n \n public void dfs(int[][] graph, List> ans, List temp, int start){\n \n if(start == graph.length-1){\n ans.add(new ArrayList<>(temp));\n return;\n }\n \n for(int i : graph[start]){\n temp.add(i);\n dfs(graph,ans,temp,i);\n temp.remove(temp.size()-1); \n }\n \n }\n}" }, { "path": "0797-all-paths-from-source-to-target/NOTES.md", "content": "​" }, { "path": "0797-all-paths-from-source-to-target/README.md", "content": "

797. All Paths From Source to Target

Medium

Given a directed acyclic graph (DAG) of n nodes labeled from 0 to n - 1, find all possible paths from node 0 to node n - 1 and return them in any order.

\n\n

The graph is given as follows: graph[i] is a list of all nodes you can visit from node i (i.e., there is a directed edge from node i to node graph[i][j]).

\n\n

 

\n

Example 1:

\n\"\"\n
Input: graph = [[1,2],[3],[3],[]]\nOutput: [[0,1,3],[0,2,3]]\nExplanation: There are two paths: 0 -> 1 -> 3 and 0 -> 2 -> 3.\n
\n\n

Example 2:

\n\"\"\n
Input: graph = [[4,3,1],[3,2,4],[3],[4],[]]\nOutput: [[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == graph.length
    • \n\t
  • 2 <= n <= 15
    • \n\t
  • 0 <= graph[i][j] < n
    • \n\t
  • graph[i][j] != i (i.e., there will be no self-loops).
    • \n\t
  • All the elements of graph[i] are unique.
    • \n\t
  • The input graph is guaranteed to be a DAG.
    • \n
\n
" }, { "path": "0834-sum-of-distances-in-tree/0834-sum-of-distances-in-tree.java", "content": "class Solution {\n public int[] sumOfDistancesInTree(int n, int[][] edges) {\n final int[] parents = buildParents(n, edges);\n final int[] counts = new int[n];\n final int[] childrenCount = new int[n];\n final int[] distanceToChildren = new int[n];\n for (int p : parents) {\n \tif (p >= 0) counts[p]++;\n }\n int start = 0, end = 0;\n for (int i = 0; i < parents.length; i++) {\n \tif (counts[i] == 0) {\n \t\tq[end++] = i;\n \t}\n }\n while (start < end) {\n \tfinal int node = q[start++];\n \tfinal int parent = parents[node];\n \tif (parent < 0) break;\n \tfinal int c = childrenCount[node] + 1;\n \tchildrenCount[parent] += c;\n \tdistanceToChildren[parent] += distanceToChildren[node] + c;\n \tif (--counts[parent] == 0) {\n \t\tq[end++] = parent;\n \t}\n }\n// System.out.println(\"Parents: \" + Arrays.toString(parents));\n// System.out.println(\"ChildrenCount: \" + Arrays.toString(childrenCount));\n// System.out.println(\"distanceToChildren: \" + Arrays.toString(distanceToChildren));\n final int root = q[end - 1];\n final int[] r = new int[n];\n r[root] = distanceToChildren[root];\n for (int i = end - 2; i >= 0; i--) {\n \tfinal int node = q[i];\n \tfinal int parent = parents[node];\n \tfinal int minus = childrenCount[node] + 1;\n \tr[node] = r[parent] + n - 2 * minus;\n }\n return r;\n }\n\t\n\tstatic final int[] q = new int[30001];\n\t\n\tstatic int[] buildParents(int n, int[][] edges) {\n\t\tfinal int[][] next = buildNext(n, edges);\n final int[] parents = new int[n];\n Arrays.fill(parents, -1);\n int start = 0, end = 0;\n q[end++] = 0;\n while (start < end) {\n \tfinal int parent = q[start++];\n \tfor (int c : next[parent]) {\n \t\tif (parents[c] < 0) {\n \t\t\tparents[c] = parent;\n \t\t\tq[end++] = c;\n \t\t}\n \t}\n }\n parents[0] = -1;\n return parents;\n\t}\n\t\n\tstatic int[][] buildNext(final int n, final int[][] edges) {\n\t\tfinal int[] counts = new int[n];\n\t\tfor (final int[] e : edges) {\n\t\t\tcounts[e[0]]++;\n\t\t\tcounts[e[1]]++;\n\t\t}\n\t\tfinal int[][] res = new int[n][];\n\t\tfor (int i = 0; i < n; i++) {\n\t\t\tres[i] = new int[counts[i]];\n\t\t}\n\t\tfor (final int[] e : edges) {\n\t\t\tfinal int l = e[0];\n\t\t\tfinal int r = e[1];\n\t\t\tres[l][--counts[l]] = r;\n\t\t\tres[r][--counts[r]] = l;\n\t\t}\n\t\treturn res;\n\t}\n}" }, { "path": "0834-sum-of-distances-in-tree/NOTES.md", "content": "​" }, { "path": "0834-sum-of-distances-in-tree/README.md", "content": "

834. Sum of Distances in Tree

Hard

There is an undirected connected tree with n nodes labeled from 0 to n - 1 and n - 1 edges.

\n\n

You are given the integer n and the array edges where edges[i] = [ai, bi] indicates that there is an edge between nodes ai and bi in the tree.

\n\n

Return an array answer of length n where answer[i] is the sum of the distances between the ith node in the tree and all other nodes.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]\nOutput: [8,12,6,10,10,10]\nExplanation: The tree is shown above.\nWe can see that dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5)\nequals 1 + 1 + 2 + 2 + 2 = 8.\nHence, answer[0] = 8, and so on.\n
\n\n

Example 2:

\n\"\"\n
Input: n = 1, edges = []\nOutput: [0]\n
\n\n

Example 3:

\n\"\"\n
Input: n = 2, edges = [[1,0]]\nOutput: [1,1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 3 * 104
    • \n\t
  • edges.length == n - 1
    • \n\t
  • edges[i].length == 2
    • \n\t
  • 0 <= ai, bi < n
    • \n\t
  • ai != bi
    • \n\t
  • The given input represents a valid tree.
    • \n
\n
" }, { "path": "0835-image-overlap/0835-image-overlap.java", "content": "class Solution {\n\n protected int convolute(int[][] A, int[][] kernel, int xShift, int yShift) {\n int result = 0;\n for (int row = 0; row < A.length; ++row)\n for (int col = 0; col < A.length; ++col)\n result += A[row][col] * kernel[row + yShift][col + xShift];\n return result;\n }\n\n public int largestOverlap(int[][] A, int[][] B) {\n\n int N = A.length;\n int[][] B_padded = new int[3 * N - 2][3 * N - 2];\n for (int row = 0; row < N; ++row)\n for (int col = 0; col < N; ++col)\n B_padded[row + N - 1][col + N - 1] = B[row][col];\n\n int maxOverlaps = 0;\n for (int xShift = 0; xShift < 2 * N - 1; ++xShift)\n for (int yShift = 0; yShift < 2 * N - 1; ++yShift) {\n maxOverlaps = Math.max(maxOverlaps,\n convolute(A, B_padded, xShift, yShift));\n }\n\n return maxOverlaps;\n }\n}" }, { "path": "0835-image-overlap/NOTES.md", "content": "​" }, { "path": "0835-image-overlap/README.md", "content": "

835. Image Overlap

Medium

You are given two images, img1 and img2, represented as binary, square matrices of size n x n. A binary matrix has only 0s and 1s as values.

\n\n

We translate one image however we choose by sliding all the 1 bits left, right, up, and/or down any number of units. We then place it on top of the other image. We can then calculate the overlap by counting the number of positions that have a 1 in both images.

\n\n

Note also that a translation does not include any kind of rotation. Any 1 bits that are translated outside of the matrix borders are erased.

\n\n

Return the largest possible overlap.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: img1 = [[1,1,0],[0,1,0],[0,1,0]], img2 = [[0,0,0],[0,1,1],[0,0,1]]\nOutput: 3\nExplanation: We translate img1 to right by 1 unit and down by 1 unit.\n\"\"\nThe number of positions that have a 1 in both images is 3 (shown in red).\n\"\"\n
\n\n

Example 2:

\n\n
Input: img1 = [[1]], img2 = [[1]]\nOutput: 1\n
\n\n

Example 3:

\n\n
Input: img1 = [[0]], img2 = [[0]]\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == img1.length == img1[i].length
    • \n\t
  • n == img2.length == img2[i].length
    • \n\t
  • 1 <= n <= 30
    • \n\t
  • img1[i][j] is either 0 or 1.
    • \n\t
  • img2[i][j] is either 0 or 1.
    • \n
\n
" }, { "path": "0841-keys-and-rooms/0841-keys-and-rooms.java", "content": "class Solution {\n public boolean canVisitAllRooms(List> rooms) {\n boolean[] visited = new boolean[rooms.size()];\n int count = 0;\n count = dfs(rooms,0, visited, count);\n return count == rooms.size();\n }\n\n public int dfs(List> rooms, int currRoom, boolean[] visited, int count) {\n if (visited[currRoom] == true) {\n return count;\n }\n visited[currRoom] = true;\n ++count;\n for (Integer roomKey: rooms.get(currRoom)) {\n count = dfs(rooms, roomKey, visited, count);\n }\n return count;\n }\n}" }, { "path": "0841-keys-and-rooms/NOTES.md", "content": "​" }, { "path": "0841-keys-and-rooms/README.md", "content": "

841. Keys and Rooms

Medium

There are n rooms labeled from 0 to n - 1 and all the rooms are locked except for room 0. Your goal is to visit all the rooms. However, you cannot enter a locked room without having its key.

\n\n

When you visit a room, you may find a set of distinct keys in it. Each key has a number on it, denoting which room it unlocks, and you can take all of them with you to unlock the other rooms.

\n\n

Given an array rooms where rooms[i] is the set of keys that you can obtain if you visited room i, return true if you can visit all the rooms, or false otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: rooms = [[1],[2],[3],[]]\nOutput: true\nExplanation: \nWe visit room 0 and pick up key 1.\nWe then visit room 1 and pick up key 2.\nWe then visit room 2 and pick up key 3.\nWe then visit room 3.\nSince we were able to visit every room, we return true.\n
\n\n

Example 2:

\n\n
Input: rooms = [[1,3],[3,0,1],[2],[0]]\nOutput: false\nExplanation: We can not enter room number 2 since the only key that unlocks it is in that room.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == rooms.length
    • \n\t
  • 2 <= n <= 1000
    • \n\t
  • 0 <= rooms[i].length <= 1000
    • \n\t
  • 1 <= sum(rooms[i].length) <= 3000
    • \n\t
  • 0 <= rooms[i][j] < n
    • \n\t
  • All the values of rooms[i] are unique.
    • \n
\n
" }, { "path": "0872-leaf-similar-trees/0872-leaf-similar-trees.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public boolean leafSimilar(TreeNode root1, TreeNode root2) {\n // Collect the leaf values from each tree\n List leafValues1 = getLeafValues(root1, new ArrayList<>());\n List leafValues2 = getLeafValues(root2, new ArrayList<>());\n \n // Compare the leaf value lists\n return leafValues1.equals(leafValues2);\n }\n List getLeafValues(TreeNode node, List values) {\n // If the node is null, return\n if (node == null) {\n return values;\n }\n \n // If the node is a leaf node, add its value to the list\n if (node.left == null && node.right == null) {\n values.add(node.val);\n }\n \n // Recursively traverse the left and right subtrees\n getLeafValues(node.left, values);\n getLeafValues(node.right, values);\n \n return values;\n }\n}" }, { "path": "0872-leaf-similar-trees/NOTES.md", "content": "​" }, { "path": "0872-leaf-similar-trees/README.md", "content": "

872. Leaf-Similar Trees

Easy

Consider all the leaves of a binary tree, from left to right order, the values of those leaves form a leaf value sequence.

\n\n

\"\"

\n\n

For example, in the given tree above, the leaf value sequence is (6, 7, 4, 9, 8).

\n\n

Two binary trees are considered leaf-similar if their leaf value sequence is the same.

\n\n

Return true if and only if the two given trees with head nodes root1 and root2 are leaf-similar.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: root1 = [1,2,3], root2 = [1,3,2]\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in each tree will be in the range [1, 200].
    • \n\t
  • Both of the given trees will have values in the range [0, 200].
    • \n
\n
" }, { "path": "0876-middle-of-the-linked-list/0876-middle-of-the-linked-list.java", "content": "class Solution {\n public ListNode middleNode(ListNode head) {\n ListNode slow = head, fast = head;\n while (fast != null && fast.next != null) {\n slow = slow.next;\n fast = fast.next.next;\n }\n return slow;\n }\n}" }, { "path": "0876-middle-of-the-linked-list/NOTES.md", "content": "​" }, { "path": "0876-middle-of-the-linked-list/README.md", "content": "

876. Middle of the Linked List

Easy

Given the head of a singly linked list, return the middle node of the linked list.

\n\n

If there are two middle nodes, return the second middle node.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,3,4,5]\nOutput: [3,4,5]\nExplanation: The middle node of the list is node 3.\n
\n\n

Example 2:

\n\"\"\n
Input: head = [1,2,3,4,5,6]\nOutput: [4,5,6]\nExplanation: Since the list has two middle nodes with values 3 and 4, we return the second one.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is in the range [1, 100].
    • \n\t
  • 1 <= Node.val <= 100
    • \n
\n
" }, { "path": "0886-possible-bipartition/0886-possible-bipartition.java", "content": "class Solution {\n public boolean possibleBipartition(int n, int[][] dislikes) {\n int[] colour = new int[n+1];\n ArrayList[] dislikeMap = new ArrayList[n+1];\n \n for(int i = 1; i <= n; i++)\n dislikeMap[i] = new ArrayList();\n \n for(int[] d: dislikes) {\n dislikeMap[d[0]].add(d[1]);\n dislikeMap[d[1]].add(d[0]);\n }\n \n \n Queue queue = new LinkedList<>();\n for(int i = 1; i <= n; i++) {\n if(colour[i] == 0) {\n colour[i] = 1;\n queue = new LinkedList<>();\n queue.offer(i);\n \n while(!queue.isEmpty()) {\n int curr = queue.poll();\n \n for(int neighbour: dislikeMap[curr]) {\n if(colour[neighbour] == 0) {\n colour[neighbour] = colour[curr] == 1?-1:1;\n queue.offer(neighbour);\n }\n else {\n if(colour[neighbour] == colour[curr])\n return false;\n }\n }\n }\n }\n }\n return true;\n }\n}" }, { "path": "0886-possible-bipartition/NOTES.md", "content": "​" }, { "path": "0886-possible-bipartition/README.md", "content": "

886. Possible Bipartition

Medium

We want to split a group of n people (labeled from 1 to n) into two groups of any size. Each person may dislike some other people, and they should not go into the same group.

\n\n

Given the integer n and the array dislikes where dislikes[i] = [ai, bi] indicates that the person labeled ai does not like the person labeled bi, return true if it is possible to split everyone into two groups in this way.

\n\n

 

\n

Example 1:

\n\n
Input: n = 4, dislikes = [[1,2],[1,3],[2,4]]\nOutput: true\nExplanation: group1 [1,4] and group2 [2,3].\n
\n\n

Example 2:

\n\n
Input: n = 3, dislikes = [[1,2],[1,3],[2,3]]\nOutput: false\n
\n\n

Example 3:

\n\n
Input: n = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 2000
    • \n\t
  • 0 <= dislikes.length <= 104
    • \n\t
  • dislikes[i].length == 2
    • \n\t
  • 1 <= dislikes[i][j] <= n
    • \n\t
  • ai < bi
    • \n\t
  • All the pairs of dislikes are unique.
    • \n
\n
" }, { "path": "0899-orderly-queue/0899-orderly-queue.java", "content": "class Solution {\n public String orderlyQueue(String s, int k) {\n if (k == 1) {\n String ans = s;\n for (int i = 0; i < s.length(); ++i) {\n String temp = s.substring(i) + s.substring(0, i);\n if (temp.compareTo(ans) < 0) {\n ans = temp;\n }\n }\n return ans;\n } else {\n char[] chars = s.toCharArray();\n Arrays.sort(chars);\n return new String(chars);\n }\n }\n}" }, { "path": "0899-orderly-queue/NOTES.md", "content": "​" }, { "path": "0899-orderly-queue/README.md", "content": "

899. Orderly Queue

Hard

You are given a string s and an integer k. You can choose one of the first k letters of s and append it at the end of the string..

\n\n

Return the lexicographically smallest string you could have after applying the mentioned step any number of moves.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"cba\", k = 1\nOutput: \"acb\"\nExplanation: \nIn the first move, we move the 1st character 'c' to the end, obtaining the string \"bac\".\nIn the second move, we move the 1st character 'b' to the end, obtaining the final result \"acb\".\n
\n\n

Example 2:

\n\n
Input: s = \"baaca\", k = 3\nOutput: \"aaabc\"\nExplanation: \nIn the first move, we move the 1st character 'b' to the end, obtaining the string \"aacab\".\nIn the second move, we move the 3rd character 'c' to the end, obtaining the final result \"aaabc\".\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= k <= s.length <= 1000
    • \n\t
  • s consist of lowercase English letters.
    • \n
\n
" }, { "path": "0901-online-stock-span/0901-online-stock-span.java", "content": "class StockSpanner {\n Stack stack = new Stack<>();\n \n public int next(int price) {\n int ans = 1;\n while (!stack.isEmpty() && stack.peek()[0] <= price) {\n ans += stack.pop()[1];\n }\n \n stack.push(new int[] {price, ans});\n return ans;\n }\n}\n\n/**\n * Your StockSpanner object will be instantiated and called as such:\n * StockSpanner obj = new StockSpanner();\n * int param_1 = obj.next(price);\n */" }, { "path": "0901-online-stock-span/NOTES.md", "content": "​" }, { "path": "0901-online-stock-span/README.md", "content": "

901. Online Stock Span

Medium

Design an algorithm that collects daily price quotes for some stock and returns the span of that stock's price for the current day.

\n\n

The span of the stock's price today is defined as the maximum number of consecutive days (starting from today and going backward) for which the stock price was less than or equal to today's price.

\n\n
    \n\t
  • For example, if the price of a stock over the next 7 days were [100,80,60,70,60,75,85], then the stock spans would be [1,1,1,2,1,4,6].
    • \n
\n\n

Implement the StockSpanner class:

\n\n
    \n\t
  • StockSpanner() Initializes the object of the class.
    • \n\t
  • int next(int price) Returns the span of the stock's price given that today's price is price.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"StockSpanner\", \"next\", \"next\", \"next\", \"next\", \"next\", \"next\", \"next\"]\n[[], [100], [80], [60], [70], [60], [75], [85]]\nOutput\n[null, 1, 1, 1, 2, 1, 4, 6]\n\nExplanation\nStockSpanner stockSpanner = new StockSpanner();\nstockSpanner.next(100); // return 1\nstockSpanner.next(80);  // return 1\nstockSpanner.next(60);  // return 1\nstockSpanner.next(70);  // return 2\nstockSpanner.next(60);  // return 1\nstockSpanner.next(75);  // return 4, because the last 4 prices (including today's price of 75) were less than or equal to today's price.\nstockSpanner.next(85);  // return 6\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= price <= 105
    • \n\t
  • At most 104 calls will be made to next.
    • \n
\n
" }, { "path": "0907-sum-of-subarray-minimums/0907-sum-of-subarray-minimums.java", "content": "\nclass Solution {\n public int sumSubarrayMins(int[] arr) {\n int MOD = 1000000007;\n\n Stack stack = new Stack<>();\n long sumOfMinimums = 0;\n\n // building monotonically increasing stack\n for (int i = 0; i <= arr.length; i++) {\n\n // when i reaches the array length, it is an indication that\n // all the elements have been processed, and the remaining\n // elements in the stack should now be popped out.\n\n while (!stack.empty() && (i == arr.length || arr[stack.peek()] >= arr[i])) {\n\n // Notice the sign \">=\", This ensures that no contribution\n // is counted twice. rightBoundary takes equal or smaller \n // elements into account while leftBoundary takes only the\n // strictly smaller elements into account\n\n int mid = stack.pop();\n int leftBoundary = stack.empty() ? -1 : stack.peek();\n int rightBoundary = i;\n\n // count of subarrays where mid is the minimum element\n long count = (mid - leftBoundary) * (rightBoundary - mid) % MOD;\n\n sumOfMinimums += (count * arr[mid]) % MOD;\n sumOfMinimums %= MOD;\n }\n stack.push(i);\n }\n\n return (int) (sumOfMinimums);\n }\n}\n" }, { "path": "0907-sum-of-subarray-minimums/NOTES.md", "content": "​" }, { "path": "0907-sum-of-subarray-minimums/README.md", "content": "

907. Sum of Subarray Minimums

Medium

Given an array of integers arr, find the sum of min(b), where b ranges over every (contiguous) subarray of arr. Since the answer may be large, return the answer modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: arr = [3,1,2,4]\nOutput: 17\nExplanation: \nSubarrays are [3], [1], [2], [4], [3,1], [1,2], [2,4], [3,1,2], [1,2,4], [3,1,2,4]. \nMinimums are 3, 1, 2, 4, 1, 1, 2, 1, 1, 1.\nSum is 17.\n
\n\n

Example 2:

\n\n
Input: arr = [11,81,94,43,3]\nOutput: 444\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= arr.length <= 3 * 104
    • \n\t
  • 1 <= arr[i] <= 3 * 104
    • \n
\n
" }, { "path": "0909-snakes-and-ladders/0909-snakes-and-ladders.java", "content": "class Solution {\n public int snakesAndLadders(int[][] board) {\n int n = board.length;\n Pair[] cells = new Pair[n * n + 1];\n int label = 1;\n Integer[] columns = new Integer[n];\n for (int i = 0; i < n; i++) {\n columns[i] = i;\n }\n for (int row = n - 1; row >= 0; row--) {\n for (int column : columns) {\n cells[label++] = new Pair<>(row, column);\n }\n Collections.reverse(Arrays.asList(columns));\n }\n int[] dist = new int[n * n + 1];\n Arrays.fill(dist, -1);\n Queue q = new LinkedList();\n dist[1] = 0;\n q.add(1);\n while (!q.isEmpty()) {\n int curr = q.remove();\n for (int next = curr + 1; next <= Math.min(curr + 6, n * n); next++) {\n int row = cells[next].getKey(), column = cells[next].getValue();\n int destination = board[row][column] != -1 ? board[row][column] : next;\n if (dist[destination] == -1) {\n dist[destination] = dist[curr] + 1;\n q.add(destination);\n }\n }\n }\n return dist[n * n];\n }\n}" }, { "path": "0909-snakes-and-ladders/NOTES.md", "content": "​" }, { "path": "0909-snakes-and-ladders/README.md", "content": "

909. Snakes and Ladders

Medium

You are given an n x n integer matrix board where the cells are labeled from 1 to n2 in a Boustrophedon style starting from the bottom left of the board (i.e. board[n - 1][0]) and alternating direction each row.

\n\n

You start on square 1 of the board. In each move, starting from square curr, do the following:

\n\n
    \n\t
  • Choose a destination square next with a label in the range [curr + 1, min(curr + 6, n2)].\n\n\t
      \n\t\t
    • This choice simulates the result of a standard 6-sided die roll: i.e., there are always at most 6 destinations, regardless of the size of the board.
      • \n\t
    \n\t
    • \n\t
  • If next has a snake or ladder, you must move to the destination of that snake or ladder. Otherwise, you move to next.
    • \n\t
  • The game ends when you reach the square n2.
    • \n
\n\n

A board square on row r and column c has a snake or ladder if board[r][c] != -1. The destination of that snake or ladder is board[r][c]. Squares 1 and n2 do not have a snake or ladder.

\n\n

Note that you only take a snake or ladder at most once per move. If the destination to a snake or ladder is the start of another snake or ladder, you do not follow the subsequent snake or ladder.

\n\n
    \n\t
  • For example, suppose the board is [[-1,4],[-1,3]], and on the first move, your destination square is 2. You follow the ladder to square 3, but do not follow the subsequent ladder to 4.
    • \n
\n\n

Return the least number of moves required to reach the square n2. If it is not possible to reach the square, return -1.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: board = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]\nOutput: 4\nExplanation: \nIn the beginning, you start at square 1 (at row 5, column 0).\nYou decide to move to square 2 and must take the ladder to square 15.\nYou then decide to move to square 17 and must take the snake to square 13.\nYou then decide to move to square 14 and must take the ladder to square 35.\nYou then decide to move to square 36, ending the game.\nThis is the lowest possible number of moves to reach the last square, so return 4.\n
\n\n

Example 2:

\n\n
Input: board = [[-1,-1],[-1,3]]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == board.length == board[i].length
    • \n\t
  • 2 <= n <= 20
    • \n\t
  • grid[i][j] is either -1 or in the range [1, n2].
    • \n\t
  • The squares labeled 1 and n2 do not have any ladders or snakes.
    • \n
\n
" }, { "path": "0918-maximum-sum-circular-subarray/0918-maximum-sum-circular-subarray.java", "content": "class Solution {\n public int maxSubarraySumCircular(int[] nums) {\n int curMax = 0, curMin = 0, sum = 0, maxSum = nums[0], minSum = nums[0];\n for (int num : nums) {\n curMax = Math.max(curMax, 0) + num;\n maxSum = Math.max(maxSum, curMax);\n curMin = Math.min(curMin, 0) + num;\n minSum = Math.min(minSum, curMin);\n sum += num; \n }\n return sum == minSum ? maxSum : Math.max(maxSum, sum - minSum);\n }\n}" }, { "path": "0918-maximum-sum-circular-subarray/README.md", "content": "

918. Maximum Sum Circular Subarray

Medium

Given a circular integer array nums of length n, return the maximum possible sum of a non-empty subarray of nums.

\n\n

A circular array means the end of the array connects to the beginning of the array. Formally, the next element of nums[i] is nums[(i + 1) % n] and the previous element of nums[i] is nums[(i - 1 + n) % n].

\n\n

A subarray may only include each element of the fixed buffer nums at most once. Formally, for a subarray nums[i], nums[i + 1], ..., nums[j], there does not exist i <= k1, k2 <= j with k1 % n == k2 % n.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,-2,3,-2]\nOutput: 3\nExplanation: Subarray [3] has maximum sum 3.\n
\n\n

Example 2:

\n\n
Input: nums = [5,-3,5]\nOutput: 10\nExplanation: Subarray [5,5] has maximum sum 5 + 5 = 10.\n
\n\n

Example 3:

\n\n
Input: nums = [-3,-2,-3]\nOutput: -2\nExplanation: Subarray [-2] has maximum sum -2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == nums.length
    • \n\t
  • 1 <= n <= 3 * 104
    • \n\t
  • -3 * 104 <= nums[i] <= 3 * 104
    • \n
\n
" }, { "path": "0926-flip-string-to-monotone-increasing/0926-flip-string-to-monotone-increasing.java", "content": "class Solution {\n public int minFlipsMonoIncr(String s) {\n int ans = 0, num = 0;\n for (int i = 0; i < s.length(); ++i) {\n if (s.charAt(i) == '0') {\n ans = Math.min(num, ans + 1);\n } else {\n ++num;\n }\n }\n return ans;\n }\n}" }, { "path": "0926-flip-string-to-monotone-increasing/NOTES.md", "content": "​" }, { "path": "0938-range-sum-of-bst/0938-range-sum-of-bst.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public int rangeSumBST(TreeNode root, int low, int high) {\n return root == null ? 0 :\n \t\t (root.val >= low && root.val <= high ? root.val : 0) +\n \t\t (root.val > low ? rangeSumBST(root.left, low, high) : 0) + \n \t\t (root.val < high ? rangeSumBST(root.right, low, high) : 0);\n }\n}" }, { "path": "0938-range-sum-of-bst/NOTES.md", "content": "​" }, { "path": "0938-range-sum-of-bst/README.md", "content": "

938. Range Sum of BST

Easy

Given the root node of a binary search tree and two integers low and high, return the sum of values of all nodes with a value in the inclusive range [low, high].

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [10,5,15,3,7,null,18], low = 7, high = 15\nOutput: 32\nExplanation: Nodes 7, 10, and 15 are in the range [7, 15]. 7 + 10 + 15 = 32.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10\nOutput: 23\nExplanation: Nodes 6, 7, and 10 are in the range [6, 10]. 6 + 7 + 10 = 23.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 2 * 104].
    • \n\t
  • 1 <= Node.val <= 105
    • \n\t
  • 1 <= low <= high <= 105
    • \n\t
  • All Node.val are unique.
    • \n
\n
" }, { "path": "0944-delete-columns-to-make-sorted/0944-delete-columns-to-make-sorted.java", "content": "class Solution {\n public int minDeletionSize(String[] strs) {\n int cols=strs[0].length();\n int ans=0;\n for(int col=0;col944. Delete Columns to Make Sorted

Easy

You are given an array of n strings strs, all of the same length.

\n\n

The strings can be arranged such that there is one on each line, making a grid. For example, strs = [\"abc\", \"bce\", \"cae\"] can be arranged as:

\n\n
abc\nbce\ncae\n
\n\n

You want to delete the columns that are not sorted lexicographically. In the above example (0-indexed), columns 0 ('a', 'b', 'c') and 2 ('c', 'e', 'e') are sorted while column 1 ('b', 'c', 'a') is not, so you would delete column 1.

\n\n

Return the number of columns that you will delete.

\n\n

 

\n

Example 1:

\n\n
Input: strs = [\"cba\",\"daf\",\"ghi\"]\nOutput: 1\nExplanation: The grid looks as follows:\n  cba\n  daf\n  ghi\nColumns 0 and 2 are sorted, but column 1 is not, so you only need to delete 1 column.\n
\n\n

Example 2:

\n\n
Input: strs = [\"a\",\"b\"]\nOutput: 0\nExplanation: The grid looks as follows:\n  a\n  b\nColumn 0 is the only column and is sorted, so you will not delete any columns.\n
\n\n

Example 3:

\n\n
Input: strs = [\"zyx\",\"wvu\",\"tsr\"]\nOutput: 3\nExplanation: The grid looks as follows:\n  zyx\n  wvu\n  tsr\nAll 3 columns are not sorted, so you will delete all 3.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == strs.length
    • \n\t
  • 1 <= n <= 100
    • \n\t
  • 1 <= strs[i].length <= 1000
    • \n\t
  • strs[i] consists of lowercase English letters.
    • \n
\n
" }, { "path": "0947-most-stones-removed-with-same-row-or-column/0947-most-stones-removed-with-same-row-or-column.java", "content": "class Solution {\n public int removeStones(int[][] stones) {\n if (stones == null || stones.length <= 1) {\n return 0;\n }\n\n int n = stones.length;\n\n UnionFind uf = new UnionFind();\n for (int[] edge : stones) {\n uf.union(edge[0] + 10001, edge[1]);\n }\n\n return n - uf.count;\n }\n\n class UnionFind {\n Map parents;\n int count;\n\n public UnionFind() {\n parents = new HashMap<>();\n count = 0;\n }\n\n public int find(int x) {\n if (!parents.containsKey(x)) {\n parents.put(x, x);\n count++;\n }\n\n if (x != parents.get(x)) {\n parents.put(x, find(parents.get(x)));\n }\n\n return parents.get(x);\n }\n\n public void union(int x, int y) {\n int rootX = find(x);\n int rootY = find(y);\n if (rootX == rootY) {\n return;\n }\n\n parents.put(rootX, rootY);\n count--;\n }\n }\n}" }, { "path": "0947-most-stones-removed-with-same-row-or-column/NOTES.md", "content": "​" }, { "path": "0947-most-stones-removed-with-same-row-or-column/README.md", "content": "

947. Most Stones Removed with Same Row or Column

Medium

On a 2D plane, we place n stones at some integer coordinate points. Each coordinate point may have at most one stone.

\n\n

A stone can be removed if it shares either the same row or the same column as another stone that has not been removed.

\n\n

Given an array stones of length n where stones[i] = [xi, yi] represents the location of the ith stone, return the largest possible number of stones that can be removed.

\n\n

 

\n

Example 1:

\n\n
Input: stones = [[0,0],[0,1],[1,0],[1,2],[2,1],[2,2]]\nOutput: 5\nExplanation: One way to remove 5 stones is as follows:\n1. Remove stone [2,2] because it shares the same row as [2,1].\n2. Remove stone [2,1] because it shares the same column as [0,1].\n3. Remove stone [1,2] because it shares the same row as [1,0].\n4. Remove stone [1,0] because it shares the same column as [0,0].\n5. Remove stone [0,1] because it shares the same row as [0,0].\nStone [0,0] cannot be removed since it does not share a row/column with another stone still on the plane.\n
\n\n

Example 2:

\n\n
Input: stones = [[0,0],[0,2],[1,1],[2,0],[2,2]]\nOutput: 3\nExplanation: One way to make 3 moves is as follows:\n1. Remove stone [2,2] because it shares the same row as [2,0].\n2. Remove stone [2,0] because it shares the same column as [0,0].\n3. Remove stone [0,2] because it shares the same row as [0,0].\nStones [0,0] and [1,1] cannot be removed since they do not share a row/column with another stone still on the plane.\n
\n\n

Example 3:

\n\n
Input: stones = [[0,0]]\nOutput: 0\nExplanation: [0,0] is the only stone on the plane, so you cannot remove it.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= stones.length <= 1000
    • \n\t
  • 0 <= xi, yi <= 104
    • \n\t
  • No two stones are at the same coordinate point.
    • \n
\n
" }, { "path": "0974-subarray-sums-divisible-by-k/0974-subarray-sums-divisible-by-k.java", "content": "class Solution {\n public int subarraysDivByK(int[] nums, int k) {\n int n = nums.length;\n int prefixMod = 0, result = 0;\n\n // There are k mod groups 0...k-1.\n int[] modGroups = new int[k];\n modGroups[0] = 1;\n\n for (int num: nums) {\n // Take modulo twice to avoid negative remainders.\n prefixMod = (prefixMod + num % k + k) % k;\n // Add the count of subarrays that have the same remainder as the current\n // one to cancel out the remainders.\n result += modGroups[prefixMod];\n modGroups[prefixMod]++;\n }\n\n return result;\n }\n}" }, { "path": "0974-subarray-sums-divisible-by-k/NOTES.md", "content": "​" }, { "path": "0974-subarray-sums-divisible-by-k/README.md", "content": "

974. Subarray Sums Divisible by K

Medium

Given an integer array nums and an integer k, return the number of non-empty subarrays that have a sum divisible by k.

\n\n

A subarray is a contiguous part of an array.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [4,5,0,-2,-3,1], k = 5\nOutput: 7\nExplanation: There are 7 subarrays with a sum divisible by k = 5:\n[4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]\n
\n\n

Example 2:

\n\n
Input: nums = [5], k = 9\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 3 * 104
    • \n\t
  • -104 <= nums[i] <= 104
    • \n\t
  • 2 <= k <= 104
    • \n
\n
" }, { "path": "0976-largest-perimeter-triangle/0976-largest-perimeter-triangle.java", "content": "class Solution {\n public int largestPerimeter(int[] nums) {\n Arrays.sort(nums);\n int i=nums.length-1;\n while(i>1){\n int a=nums[i];\n int b=nums[i-1];\n int c=nums[i-2];\n if(c+b>a){\n return a+b+c;\n }else{\n i--;\n }\n }\n return 0;\n }\n}" }, { "path": "0976-largest-perimeter-triangle/NOTES.md", "content": "​" }, { "path": "0976-largest-perimeter-triangle/README.md", "content": "

976. Largest Perimeter Triangle

Easy

Given an integer array nums, return the largest perimeter of a triangle with a non-zero area, formed from three of these lengths. If it is impossible to form any triangle of a non-zero area, return 0.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [2,1,2]\nOutput: 5\n
\n\n

Example 2:

\n\n
Input: nums = [1,2,1]\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 3 <= nums.length <= 104
    • \n\t
  • 1 <= nums[i] <= 106
    • \n
\n
" }, { "path": "0980-unique-paths-iii/0980-unique-paths-iii.java", "content": "class Solution {\n public int uniquePathsIII(int[][] grid) {\n int zero = 0; // Count the 0's\n int sx = 0; // starting x index\n int sy = 0; // starting y index\n \n for(int r = 0; r < grid.length; r++){ // r = row\n for(int c = 0; c < grid[0].length; c++){ // c = column\n if(grid[r][c] == 0) zero++; // if current cell is 0, count it.\n else if(grid[r][c] == 1){\n sx = r; // starting x co-ordinate\n sy = c; // starting y co-ordinate\n }\n }\n }\n return dfs(grid, sx, sy, zero);\n }\n public int dfs(int grid[][], int x, int y, int zero){\n // Base Condition\n if(x < 0 || y < 0 || x >= grid.length || y >= grid[0].length || grid[x][y] == -1){\n return 0;\n }\n if(grid[x][y] == 2){\n return zero == -1 ? 1 : 0; // Why zero = -1, because in above example we have 9 zero's. So, when we reach the final cell we are covering one cell extra then the zero count. \n // If that's the case we find the path and return '1' otherwise return '0';\n }\n grid[x][y] = -1; // mark the visited cells as -1;\n zero--; // and reduce the zero by 1\n \n int totalPaths = dfs(grid, x + 1, y, zero) + // calculating all the paths available in 4 directions\n dfs(grid, x - 1, y, zero) + \n dfs(grid, x, y + 1, zero) + \n dfs(grid, x, y - 1, zero);\n \n // Let's say if we are not able to count all the paths. Now we use Backtracking over here\n grid[x][y] = 0;\n zero++;\n \n return totalPaths; // if we get all the paths, simply return it.\n }\n}" }, { "path": "0980-unique-paths-iii/NOTES.md", "content": "​" }, { "path": "0980-unique-paths-iii/README.md", "content": "

980. Unique Paths III

Hard

You are given an m x n integer array grid where grid[i][j] could be:

\n\n
    \n\t
  • 1 representing the starting square. There is exactly one starting square.
    • \n\t
  • 2 representing the ending square. There is exactly one ending square.
    • \n\t
  • 0 representing empty squares we can walk over.
    • \n\t
  • -1 representing obstacles that we cannot walk over.
    • \n
\n\n

Return the number of 4-directional walks from the starting square to the ending square, that walk over every non-obstacle square exactly once.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: grid = [[1,0,0,0],[0,0,0,0],[0,0,2,-1]]\nOutput: 2\nExplanation: We have the following two paths: \n1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2)\n2. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2)\n
\n\n

Example 2:

\n\"\"\n
Input: grid = [[1,0,0,0],[0,0,0,0],[0,0,0,2]]\nOutput: 4\nExplanation: We have the following four paths: \n1. (0,0),(0,1),(0,2),(0,3),(1,3),(1,2),(1,1),(1,0),(2,0),(2,1),(2,2),(2,3)\n2. (0,0),(0,1),(1,1),(1,0),(2,0),(2,1),(2,2),(1,2),(0,2),(0,3),(1,3),(2,3)\n3. (0,0),(1,0),(2,0),(2,1),(2,2),(1,2),(1,1),(0,1),(0,2),(0,3),(1,3),(2,3)\n4. (0,0),(1,0),(2,0),(2,1),(1,1),(0,1),(0,2),(0,3),(1,3),(1,2),(2,2),(2,3)\n
\n\n

Example 3:

\n\"\"\n
Input: grid = [[0,1],[2,0]]\nOutput: 0\nExplanation: There is no path that walks over every empty square exactly once.\nNote that the starting and ending square can be anywhere in the grid.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == grid.length
    • \n\t
  • n == grid[i].length
    • \n\t
  • 1 <= m, n <= 20
    • \n\t
  • 1 <= m * n <= 20
    • \n\t
  • -1 <= grid[i][j] <= 2
    • \n\t
  • There is exactly one starting cell and one ending cell.
    • \n
\n
" }, { "path": "0997-find-the-town-judge/0997-find-the-town-judge.java", "content": "class Solution {\n public int findJudge(int n, int[][] trust) {\n \n int count[] = new int[n+1];\n \n for(int t[] : trust){\n count[t[0]]--; // outdegree\n count[t[1]]++; // indegree\n }\n \n for(int i=1;i<=n;i++){\n if(count[i]==n-1) return i;\n }\n \n return -1;\n \n }\n}" }, { "path": "0997-find-the-town-judge/NOTES.md", "content": "​" }, { "path": "0997-find-the-town-judge/README.md", "content": "

997. Find the Town Judge

Easy

In a town, there are n people labeled from 1 to n. There is a rumor that one of these people is secretly the town judge.

\n\n

If the town judge exists, then:

\n\n
    \n\t
  1. The town judge trusts nobody.
    2. \n\t
  2. Everybody (except for the town judge) trusts the town judge.
    3. \n\t
  3. There is exactly one person that satisfies properties 1 and 2.
    4. \n
\n\n

You are given an array trust where trust[i] = [ai, bi] representing that the person labeled ai trusts the person labeled bi.

\n\n

Return the label of the town judge if the town judge exists and can be identified, or return -1 otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: n = 2, trust = [[1,2]]\nOutput: 2\n
\n\n

Example 2:

\n\n
Input: n = 3, trust = [[1,3],[2,3]]\nOutput: 3\n
\n\n

Example 3:

\n\n
Input: n = 3, trust = [[1,3],[2,3],[3,1]]\nOutput: -1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 1000
    • \n\t
  • 0 <= trust.length <= 104
    • \n\t
  • trust[i].length == 2
    • \n\t
  • All the pairs of trust are unique.
    • \n\t
  • ai != bi
    • \n\t
  • 1 <= ai, bi <= n
    • \n
\n
" }, { "path": "1007-minimum-domino-rotations-for-equal-row/1007-minimum-domino-rotations-for-equal-row.java", "content": "class Solution {\n public int minDominoRotations(int[] tops, int[] bottoms) {\n int ans =-1;\n for(int i=1;i<=6;i++){\n int currAns = helper(i,tops,bottoms);\n if (currAns != -1 && (ans == -1 || ans > currAns)) {\n ans = currAns;\n }\n }\n return ans;\n }\n \n private int helper(int target,int[] a,int[] b){\n int numswapA =0;\n int numswapB =0;\n for(int i=0;i1007. Minimum Domino Rotations For Equal Row

Medium

In a row of dominoes, tops[i] and bottoms[i] represent the top and bottom halves of the ith domino. (A domino is a tile with two numbers from 1 to 6 - one on each half of the tile.)

\n\n

We may rotate the ith domino, so that tops[i] and bottoms[i] swap values.

\n\n

Return the minimum number of rotations so that all the values in tops are the same, or all the values in bottoms are the same.

\n\n

If it cannot be done, return -1.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: tops = [2,1,2,4,2,2], bottoms = [5,2,6,2,3,2]\nOutput: 2\nExplanation: \nThe first figure represents the dominoes as given by tops and bottoms: before we do any rotations.\nIf we rotate the second and fourth dominoes, we can make every value in the top row equal to 2, as indicated by the second figure.\n
\n\n

Example 2:

\n\n
Input: tops = [3,5,1,2,3], bottoms = [3,6,3,3,4]\nOutput: -1\nExplanation: \nIn this case, it is not possible to rotate the dominoes to make one row of values equal.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= tops.length <= 2 * 104
    • \n\t
  • bottoms.length == tops.length
    • \n\t
  • 1 <= tops[i], bottoms[i] <= 6
    • \n
\n
" }, { "path": "102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public List> levelOrder(TreeNode root) {\n List> ans=new ArrayList<>();\n if(root==null)return ans;\n Queue q=new LinkedList<>();\n q.add(root);\n while(!q.isEmpty()){\n int sz=q.size();\n List list=new ArrayList<>();\n while(sz-->0){\n TreeNode node=q.remove();\n list.add(node.val);\n if(node.left!=null)q.add(node.left);\n if(node.right!=null)q.add(node.right);\n }\n ans.add(list);\n }\n return ans;\n }\n}" }, { "path": "102-binary-tree-level-order-traversal/102-binary-tree-level-order-traversal.py", "content": "# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:\n \n res = []\n \n # Breadth-First-Search Algo\n \n def traverse(node, i):\n if node:\n if i102. Binary Tree Level Order Traversal

Medium

Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [3,9,20,null,null,15,7]\nOutput: [[3],[9,20],[15,7]]\n
\n\n

Example 2:

\n\n
Input: root = [1]\nOutput: [[1]]\n
\n\n

Example 3:

\n\n
Input: root = []\nOutput: []\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 2000].
    • \n\t
  • -1000 <= Node.val <= 1000
    • \n
\n
" }, { "path": "1020-number-of-enclaves/1020-number-of-enclaves.cpp", "content": "class Solution {\npublic:\npair bfs(vector>& gr, vector>& vis, int x, int y) {\n\tqueue>qq;\n\t// (1,2) (2,1) (1,0) (0,1)\n\tvectorxmoves = { 0,1,0,-1 };\n\tvectorymoves = { 1,0,-1,0 };\n\n\tqq.push(make_pair(x, y));\n\tvis[x][y] = true;\n\tpairtemp;\n\tint r,c;\n\tbool is_at_boundary = false;\n\tint count = 0;\n\twhile (!qq.empty()) {\n\t\ttemp = qq.front();\n\t\tqq.pop();\n\t\t++count;\n\t\t\n\t\tfor (int i = 0;i < 4;i++) {\n\t\t\tr = temp.first + xmoves[i];\n\t\t\tc = temp.second + ymoves[i];\n\n\t\t\tif (r < 0 || c < 0 || r >= gr.size() || c >= gr[0].size())\n\t\t\t\tis_at_boundary = true;\n\t\t\telse if (!vis[r][c] && gr[r][c]) {\n\t\t\t\tvis[r][c] = true;\n\t\t\t\tqq.push(make_pair(r, c));\n\t\t\t}\n\n\t\t}\n\t}\n\n\treturn { count,is_at_boundary };\n}\n int numEnclaves(vector>& grid) {\n int n = grid.size(), m = grid[0].size();\n\tint answer = 0;\n\tvector>vis(n, vector(m,false));\n\tpairresult;\n\tfor (int i = 0;i < n;i++) {\n\t\tfor (int j = 0;j < m;j++) {\n\t\t\tif (!vis[i][j] && grid[i][j]) {\n\t\t\t\tresult = bfs(grid, vis, i, j);\n\t\t\t\t//cout <<\"result is \"<< result.first << endl;\n\t\t\t\tif (!result.second)answer += result.first;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn answer;\n }\n};" }, { "path": "1020. Number of Enclaves.java", "content": "class Solution {\n public int numEnclaves(int[][] grid) {\n int n=grid.length;\n int m=grid[0].length;\n\n int[][] vis=new int[n][m];\n \n for(int j=0;j=a.length || j<0 || j>=a[0].length || vis[i][j]==1 || a[i][j]==0){\n return ;\n }\n vis[i][j]=1;\n \n dfs(a,vis,i+1,j);\n dfs(a,vis,i-1,j);\n dfs(a,vis,i,j+1);\n dfs(a,vis,i,j-1);\n \n return;\n }\n}\n" }, { "path": "1026-maximum-difference-between-node-and-ancestor/1026-maximum-difference-between-node-and-ancestor.java", "content": "class Solution {\n int maxDifference = 0;\n public int maxAncestorDiff(TreeNode root) {\n int max = Integer.MIN_VALUE;\n int min = Integer.MAX_VALUE;\n dfs(root, max, min);\n return maxDifference;\n }\n \n void dfs(TreeNode root, int max, int min){\n if(root == null) return;\n \n if(root.val < min) {\n min = root.val;\n \n }\n if(root.val > max) {\n max = root.val;\n };\n \n if(Math.abs(min - max) > maxDifference) {\n maxDifference = Math.abs(min - max);\n }\n dfs(root.left, max, min);\n dfs(root.right, max, min);\n }\n}" }, { "path": "1026-maximum-difference-between-node-and-ancestor/NOTES.md", "content": "​" }, { "path": "1026-maximum-difference-between-node-and-ancestor/README.md", "content": "

1026. Maximum Difference Between Node and Ancestor

Medium

Given the root of a binary tree, find the maximum value v for which there exist different nodes a and b where v = |a.val - b.val| and a is an ancestor of b.

\n\n

A node a is an ancestor of b if either: any child of a is equal to b or any child of a is an ancestor of b.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [8,3,10,1,6,null,14,null,null,4,7,13]\nOutput: 7\nExplanation: We have various ancestor-node differences, some of which are given below :\n|8 - 3| = 5\n|3 - 7| = 4\n|8 - 1| = 7\n|10 - 13| = 3\nAmong all possible differences, the maximum value of 7 is obtained by |8 - 1| = 7.
\n\n

Example 2:

\n\"\"\n
Input: root = [1,null,2,null,0,3]\nOutput: 3\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [2, 5000].
    • \n\t
  • 0 <= Node.val <= 105
    • \n
\n
" }, { "path": "1029-two-city-scheduling/1029-two-city-scheduling.java", "content": "class Solution {\n public int twoCitySchedCost(int[][] costs) {\n int n=costs.length;\n int[][]diff=new int[n][3];\n for(int i=0;io1[0]-o2[0]);\n int ans=0;\n for(int i=0;i=n/2){\n ans+=diff[i][1];\n }else{\n ans+=diff[i][2];\n }\n }\n return ans;\n }\n}" }, { "path": "1029-two-city-scheduling/NOTES.md", "content": "​" }, { "path": "1029-two-city-scheduling/README.md", "content": "

1029. Two City Scheduling

Medium

A company is planning to interview 2n people. Given the array costs where costs[i] = [aCosti, bCosti], the cost of flying the ith person to city a is aCosti, and the cost of flying the ith person to city b is bCosti.

\n\n

Return the minimum cost to fly every person to a city such that exactly n people arrive in each city.

\n\n

 

\n

Example 1:

\n\n
Input: costs = [[10,20],[30,200],[400,50],[30,20]]\nOutput: 110\nExplanation: \nThe first person goes to city A for a cost of 10.\nThe second person goes to city A for a cost of 30.\nThe third person goes to city B for a cost of 50.\nThe fourth person goes to city B for a cost of 20.\n\nThe total minimum cost is 10 + 30 + 50 + 20 = 110 to have half the people interviewing in each city.\n
\n\n

Example 2:

\n\n
Input: costs = [[259,770],[448,54],[926,667],[184,139],[840,118],[577,469]]\nOutput: 1859\n
\n\n

Example 3:

\n\n
Input: costs = [[515,563],[451,713],[537,709],[343,819],[855,779],[457,60],[650,359],[631,42]]\nOutput: 3086\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 * n == costs.length
    • \n\t
  • 2 <= costs.length <= 100
    • \n\t
  • costs.length is even.
    • \n\t
  • 1 <= aCosti, bCosti <= 1000
    • \n
\n
" }, { "path": "1046-last-stone-weight/1046-last-stone-weight.java", "content": "class Solution {\n public int lastStoneWeight(int[] stones) {\n int c = stones.length;\n while(c > 1){\n Arrays.sort(stones);\n stones[c-2]=stones[c-1] - stones[c-2];\n c--;\n }\n \n return stones[0];\n \n }\n}" }, { "path": "1046-last-stone-weight/NOTES.md", "content": "​" }, { "path": "1046-last-stone-weight/README.md", "content": "

1046. Last Stone Weight

Easy

You are given an array of integers stones where stones[i] is the weight of the ith stone.

\n\n

We are playing a game with the stones. On each turn, we choose the heaviest two stones and smash them together. Suppose the heaviest two stones have weights x and y with x <= y. The result of this smash is:

\n\n
    \n\t
  • If x == y, both stones are destroyed, and
    • \n\t
  • If x != y, the stone of weight x is destroyed, and the stone of weight y has new weight y - x.
    • \n
\n\n

At the end of the game, there is at most one stone left.

\n\n

Return the smallest possible weight of the left stone. If there are no stones left, return 0.

\n\n

 

\n

Example 1:

\n\n
Input: stones = [2,7,4,1,8,1]\nOutput: 1\nExplanation: \nWe combine 7 and 8 to get 1 so the array converts to [2,4,1,1,1] then,\nwe combine 2 and 4 to get 2 so the array converts to [2,1,1,1] then,\nwe combine 2 and 1 to get 1 so the array converts to [1,1,1] then,\nwe combine 1 and 1 to get 0 so the array converts to [1] then that's the value of the last stone.\n
\n\n

Example 2:

\n\n
Input: stones = [1]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= stones.length <= 30
    • \n\t
  • 1 <= stones[i] <= 1000
    • \n
\n
" }, { "path": "1047-remove-all-adjacent-duplicates-in-string/1047-remove-all-adjacent-duplicates-in-string.java", "content": "class Solution {\n public String removeDuplicates(String s) {\n int i = 0;\n int len = s.length();\n\n char arr[] = s.toCharArray();\n for(int j = 0; j0 && arr[i]==arr[i-1]){\n i -= 2;\n }\n i++;\n }\n return new String(arr, 0, i);\n\n }\n}" }, { "path": "1047-remove-all-adjacent-duplicates-in-string/NOTES.md", "content": "​" }, { "path": "1047-remove-all-adjacent-duplicates-in-string/README.md", "content": "

1047. Remove All Adjacent Duplicates In String

Easy

You are given a string s consisting of lowercase English letters. A duplicate removal consists of choosing two adjacent and equal letters and removing them.

\n\n

We repeatedly make duplicate removals on s until we no longer can.

\n\n

Return the final string after all such duplicate removals have been made. It can be proven that the answer is unique.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"abbaca\"\nOutput: \"ca\"\nExplanation: \nFor example, in \"abbaca\" we could remove \"bb\" since the letters are adjacent and equal, and this is the only possible move.  The result of this move is that the string is \"aaca\", of which only \"aa\" is possible, so the final string is \"ca\".\n
\n\n

Example 2:

\n\n
Input: s = \"azxxzy\"\nOutput: \"ay\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 105
    • \n\t
  • s consists of lowercase English letters.
    • \n
\n
" }, { "path": "1048-longest-string-chain/1048-longest-string-chain.java", "content": "class Solution {\n public int longestStrChain(String[] words) {\n Arrays.sort(words,(a,b)->a.length()-b.length());\n Map map=new HashMap<>();\n int res=0;\n for(String word:words){\n map.put(word,1);\n for(int i=0;i1048. Longest String Chain

Medium

You are given an array of words where each word consists of lowercase English letters.

\n\n

wordA is a predecessor of wordB if and only if we can insert exactly one letter anywhere in wordA without changing the order of the other characters to make it equal to wordB.

\n\n
    \n\t
  • For example, \"abc\" is a predecessor of \"abac\", while \"cba\" is not a predecessor of \"bcad\".
    • \n
\n\n

A word chain is a sequence of words [word1, word2, ..., wordk] with k >= 1, where word1 is a predecessor of word2, word2 is a predecessor of word3, and so on. A single word is trivially a word chain with k == 1.

\n\n

Return the length of the longest possible word chain with words chosen from the given list of words.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"a\",\"b\",\"ba\",\"bca\",\"bda\",\"bdca\"]\nOutput: 4\nExplanation: One of the longest word chains is [\"a\",\"ba\",\"bda\",\"bdca\"].\n
\n\n

Example 2:

\n\n
Input: words = [\"xbc\",\"pcxbcf\",\"xb\",\"cxbc\",\"pcxbc\"]\nOutput: 5\nExplanation: All the words can be put in a word chain [\"xb\", \"xbc\", \"cxbc\", \"pcxbc\", \"pcxbcf\"].\n
\n\n

Example 3:

\n\n
Input: words = [\"abcd\",\"dbqca\"]\nOutput: 1\nExplanation: The trivial word chain [\"abcd\"] is one of the longest word chains.\n[\"abcd\",\"dbqca\"] is not a valid word chain because the ordering of the letters is changed.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words.length <= 1000
    • \n\t
  • 1 <= words[i].length <= 16
    • \n\t
  • words[i] only consists of lowercase English letters.
    • \n
\n
" }, { "path": "105-construct-binary-tree-from-preorder-and-inorder-traversal/105-construct-binary-tree-from-preorder-and-inorder-traversal.java", "content": "class Solution {\n int preorderIndex;\n Map inorderIndexMap;\n public TreeNode buildTree(int[] preorder, int[] inorder) {\n preorderIndex = 0;\n // build a hashmap to store value -> its index relations\n inorderIndexMap = new HashMap<>();\n for (int i = 0; i < inorder.length; i++) {\n inorderIndexMap.put(inorder[i], i);\n }\n\n return arrayToTree(preorder, 0, preorder.length - 1);\n }\n\n private TreeNode arrayToTree(int[] preorder, int left, int right) {\n // if there are no elements to construct the tree\n if (left > right) return null;\n\n // select the preorder_index element as the root and increment it\n int rootValue = preorder[preorderIndex++];\n TreeNode root = new TreeNode(rootValue);\n\n // build left and right subtree\n // excluding inorderIndexMap[rootValue] element because it's the root\n root.left = arrayToTree(preorder, left, inorderIndexMap.get(rootValue) - 1);\n root.right = arrayToTree(preorder, inorderIndexMap.get(rootValue) + 1, right);\n return root;\n }\n}" }, { "path": "105-construct-binary-tree-from-preorder-and-inorder-traversal/NOTES.md", "content": "​" }, { "path": "105-construct-binary-tree-from-preorder-and-inorder-traversal/README.md", "content": "

105. Construct Binary Tree from Preorder and Inorder Traversal

Medium

Given two integer arrays preorder and inorder where preorder is the preorder traversal of a binary tree and inorder is the inorder traversal of the same tree, construct and return the binary tree.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]\nOutput: [3,9,20,null,null,15,7]\n
\n\n

Example 2:

\n\n
Input: preorder = [-1], inorder = [-1]\nOutput: [-1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= preorder.length <= 3000
    • \n\t
  • inorder.length == preorder.length
    • \n\t
  • -3000 <= preorder[i], inorder[i] <= 3000
    • \n\t
  • preorder and inorder consist of unique values.
    • \n\t
  • Each value of inorder also appears in preorder.
    • \n\t
  • preorder is guaranteed to be the preorder traversal of the tree.
    • \n\t
  • inorder is guaranteed to be the inorder traversal of the tree.
    • \n
\n
" }, { "path": "1061-lexicographically-smallest-equivalent-string/1061-lexicographically-smallest-equivalent-string.java", "content": "class Solution {\n int representative[] = new int[26];\n\n // Returns the root representative of the component.\n int find(int x) {\n if (representative[x] == x) {\n return x;\n }\n\n return representative[x] = find(representative[x]);\n }\n\n // Perform union if x and y aren't in the same component.\n void performUnion(int x, int y) {\n x = find(x);\n y = find(y);\n\n if (x == y) {\n return;\n }\n\n // Make the smaller character representative.\n if (x < y) {\n representative[y] = x;\n } else {\n representative[x] = y;\n }\n }\n\n public String smallestEquivalentString(String s1, String s2, String baseStr) {\n // Make each character representative of itself.\n for (int i = 0; i < 26; i++) {\n representative[i] = i;\n }\n\n // Perform union merge for all the edges.\n for (int i = 0; i < s1.length(); i++) {\n performUnion(s1.charAt(i) - 'a', s2.charAt(i) - 'a');\n }\n\n String ans = \"\";\n // Create the answer string with final mappings.\n for (char c : baseStr.toCharArray()) {\n ans += (char)(find(c - 'a') + 'a');\n }\n\n return ans;\n }\n}" }, { "path": "1061-lexicographically-smallest-equivalent-string/NOTES.md", "content": "​" }, { "path": "1061-lexicographically-smallest-equivalent-string/README.md", "content": "

1061. Lexicographically Smallest Equivalent String

Medium

You are given two strings of the same length s1 and s2 and a string baseStr.

\n\n

We say s1[i] and s2[i] are equivalent characters.

\n\n
    \n\t
  • For example, if s1 = \"abc\" and s2 = \"cde\", then we have 'a' == 'c', 'b' == 'd', and 'c' == 'e'.
    • \n
\n\n

Equivalent characters follow the usual rules of any equivalence relation:

\n\n
    \n\t
  • Reflexivity: 'a' == 'a'.
    • \n\t
  • Symmetry: 'a' == 'b' implies 'b' == 'a'.
    • \n\t
  • Transitivity: 'a' == 'b' and 'b' == 'c' implies 'a' == 'c'.
    • \n
\n\n

For example, given the equivalency information from s1 = \"abc\" and s2 = \"cde\", \"acd\" and \"aab\" are equivalent strings of baseStr = \"eed\", and \"aab\" is the lexicographically smallest equivalent string of baseStr.

\n\n

Return the lexicographically smallest equivalent string of baseStr by using the equivalency information from s1 and s2.

\n\n

 

\n

Example 1:

\n\n
Input: s1 = \"parker\", s2 = \"morris\", baseStr = \"parser\"\nOutput: \"makkek\"\nExplanation: Based on the equivalency information in s1 and s2, we can group their characters as [m,p], [a,o], [k,r,s], [e,i].\nThe characters in each group are equivalent and sorted in lexicographical order.\nSo the answer is \"makkek\".\n
\n\n

Example 2:

\n\n
Input: s1 = \"hello\", s2 = \"world\", baseStr = \"hold\"\nOutput: \"hdld\"\nExplanation: Based on the equivalency information in s1 and s2, we can group their characters as [h,w], [d,e,o], [l,r].\nSo only the second letter 'o' in baseStr is changed to 'd', the answer is \"hdld\".\n
\n\n

Example 3:

\n\n
Input: s1 = \"leetcode\", s2 = \"programs\", baseStr = \"sourcecode\"\nOutput: \"aauaaaaada\"\nExplanation: We group the equivalent characters in s1 and s2 as [a,o,e,r,s,c], [l,p], [g,t] and [d,m], thus all letters in baseStr except 'u' and 'd' are transformed to 'a', the answer is \"aauaaaaada\".\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s1.length, s2.length, baseStr <= 1000
    • \n\t
  • s1.length == s2.length
    • \n\t
  • s1, s2, and baseStr consist of lowercase English letters.
    • \n
\n
" }, { "path": "1074-number-of-submatrices-that-sum-to-target/1074-number-of-submatrices-that-sum-to-target.java", "content": "class Solution {\n public int numSubmatrixSumTarget(int[][] matrix, int target) {\n int m = matrix.length;\n int n = matrix[0].length;\n int res = 0;\n \n // traverse upper boundary\n for (int top = 0; top < m; top++) {\n \n // for each upper boundary, we have a prefix sum array\n int[] sum = new int[n];\n \n // traverse lower boundary\n for (int bottom = top; bottom < m; bottom++) {\n \n // count the prefix sum for each column\n for (int col = 0; col < n; col++) {\n sum[col] += matrix[bottom][col];\n }\n \n // traverse left and right boundary\n for (int left = 0; left < n; left++) {\n int cnt = 0;\n for (int right = left; right < n; right++) {\n cnt += sum[right];\n if (cnt == target) res++;\n }\n }\n }\n }\n return res;\n }\n}" }, { "path": "1074-number-of-submatrices-that-sum-to-target/NOTES.md", "content": "​" }, { "path": "108-convert-sorted-array-to-binary-search-tree/108-convert-sorted-array-to-binary-search-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public TreeNode sortedArrayToBST(int[] nums) {\n return create(nums,0,nums.length-1);\n }\n TreeNode create(int[]nums,int i,int j){\n if(j108. Convert Sorted Array to Binary Search Tree

Easy

Given an integer array nums where the elements are sorted in ascending order, convert it to a height-balanced binary search tree.

\n\n

A height-balanced binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than one.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: nums = [-10,-3,0,5,9]\nOutput: [0,-3,9,-10,null,5]\nExplanation: [0,-10,5,null,-3,null,9] is also accepted:\n\"\"\n
\n\n

Example 2:

\n\"\"\n
Input: nums = [1,3]\nOutput: [3,1]\nExplanation: [1,null,3] and [3,1] are both height-balanced BSTs.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 104
    • \n\t
  • -104 <= nums[i] <= 104
    • \n\t
  • nums is sorted in a strictly increasing order.
    • \n
\n
" }, { "path": "1081-smallest-subsequence-of-distinct-characters/1081-smallest-subsequence-of-distinct-characters.java", "content": "class Solution {\n public String smallestSubsequence(String s) {\n int[]freq=new int[26];\n int[]done=new int[26];\n for(char c:s.toCharArray()){\n freq[c-97]++;\n }\n Deque stack=new ArrayDeque<>();\n for(int i=0;i0 && stack.peek()>ch){\n if(freq[stack.peek()-97]>0){\n char out=stack.pop();\n done[out-97]=0;\n }else{\n break;\n }\n }\n done[ch-97]=1;\n stack.push(ch);\n }\n freq[ch-97]--;\n }\n StringBuilder sb=new StringBuilder();\n while(stack.size()>0){\n sb.append(stack.pop());\n }\n return sb.reverse().toString();\n }\n}" }, { "path": "1081-smallest-subsequence-of-distinct-characters/NOTES.md", "content": "​" }, { "path": "1081-smallest-subsequence-of-distinct-characters/README.md", "content": "

1081. Smallest Subsequence of Distinct Characters

Medium

Given a string s, return the lexicographically smallest subsequence of s that contains all the distinct characters of s exactly once.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"bcabc\"\nOutput: \"abc\"\n
\n\n

Example 2:

\n\n
Input: s = \"cbacdcbc\"\nOutput: \"acdb\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 1000
    • \n\t
  • s consists of lowercase English letters.
    • \n
\n\n

 

\nNote: This question is the same as 316: https://leetcode.com/problems/remove-duplicate-letters/
" }, { "path": "1091-shortest-path-in-binary-matrix/1091-shortest-path-in-binary-matrix.java", "content": "class Solution {\n public int shortestPathBinaryMatrix(int[][] grid) {\n int n=grid.length;\n if(grid[0][0]==1||grid[n-1][n-1]==1)return -1;\n if(n==1&&grid[0][0]==0)return 1;\n grid[0][0]=1;\n List pos=new ArrayList<>();\n pos.add(new int[]{0,0});\n check(grid,pos);\n if(grid[n-1][n-1]==0)return -1;\n return grid[n-1][n-1];\n \n }\n public void check(int[][] grid,List pos){\n int n=grid.length;\n List newpos=new ArrayList<>();\n for(int[] p:pos){\n int i=p[0];\n int j=p[1];\n int curdis=grid[i][j]+1;\n if(i>0&&j>0&&grid[i-1][j-1]==0){\n grid[i-1][j-1]=curdis;\n newpos.add(new int[]{i-1,j-1});\n }\n if(i0&&grid[i+1][j-1]==0){\n grid[i+1][j-1]=curdis;\n newpos.add(new int[]{i+1,j-1});\n }\n if(i>0&&j0&&grid[i][j-1]==0){\n grid[i][j-1]=curdis;\n newpos.add(new int[]{i,j-1});\n }\n if(j0&&grid[i-1][j]==0){\n grid[i-1][j]=curdis;\n newpos.add(new int[]{i-1,j});\n }\n }\n if(!newpos.isEmpty())check(grid,newpos);\n \n \n }\n}" }, { "path": "1091-shortest-path-in-binary-matrix/NOTES.md", "content": "​" }, { "path": "1091-shortest-path-in-binary-matrix/README.md", "content": "

1091. Shortest Path in Binary Matrix

Medium

Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.

\n\n

A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:

\n\n
    \n\t
  • All the visited cells of the path are 0.
    • \n\t
  • All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner).
    • \n
\n\n

The length of a clear path is the number of visited cells of this path.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: grid = [[0,1],[1,0]]\nOutput: 2\n
\n\n

Example 2:

\n\"\"\n
Input: grid = [[0,0,0],[1,1,0],[1,1,0]]\nOutput: 4\n
\n\n

Example 3:

\n\n
Input: grid = [[1,0,0],[1,1,0],[1,1,0]]\nOutput: -1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == grid.length
    • \n\t
  • n == grid[i].length
    • \n\t
  • 1 <= n <= 100
    • \n\t
  • grid[i][j] is 0 or 1
    • \n
\n
" }, { "path": "11-container-with-most-water/11-container-with-most-water.java", "content": "class Solution {\n public int maxArea(int[] height) {\n int result = 0;\n int left = 0;\n int right = height.length - 1;\n while (left < right) {\n int hLeft = height[left];\n int hRight = height[right];\n \n result = Math.max(result, Math.min(hLeft, hRight) * (right - left));\n \n if (hLeft < hRight) {\n while (left < right && height[left] <= hLeft) {\n left++; \n }\n } else {\n while (left < right && height[right] <= hRight) {\n right--; \n }\n }\n }\n return result;\n }\n}" }, { "path": "11-container-with-most-water/Container_With_Most_Water.cpp", "content": "class Solution {\npublic:\n int maxArea(vector& h) {\n int maxi = 0;\n int i=0,j=h.size()-1;\n while(i11. Container With Most Water

Medium

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).

\n\n

Find two lines that together with the x-axis form a container, such that the container contains the most water.

\n\n

Return the maximum amount of water a container can store.

\n\n

Notice that you may not slant the container.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: height = [1,8,6,2,5,4,8,3,7]\nOutput: 49\nExplanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.\n
\n\n

Example 2:

\n\n
Input: height = [1,1]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == height.length
    • \n\t
  • 2 <= n <= 105
    • \n\t
  • 0 <= height[i] <= 104
    • \n
\n
" }, { "path": "112-path-sum/112-path-sum.java", "content": "class Solution{\n public boolean hasPathSum(TreeNode root, int targetSum) {\n if(root==null){\n return false;\n }\n if(root.left==null && root.right==null && targetSum-root.val==0){\n return true;\n }\n \n return hasPathSum(root.left, targetSum-root.val) || hasPathSum(root.right, targetSum-root.val);\n \n }\n} \n " }, { "path": "112-path-sum/NOTES.md", "content": "​" }, { "path": "112-path-sum/README.md", "content": "

112. Path Sum

Easy

Given the root of a binary tree and an integer targetSum, return true if the tree has a root-to-leaf path such that adding up all the values along the path equals targetSum.

\n\n

A leaf is a node with no children.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22\nOutput: true\nExplanation: The root-to-leaf path with the target sum is shown.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [1,2,3], targetSum = 5\nOutput: false\nExplanation: There two root-to-leaf paths in the tree:\n(1 --> 2): The sum is 3.\n(1 --> 3): The sum is 4.\nThere is no root-to-leaf path with sum = 5.\n
\n\n

Example 3:

\n\n
Input: root = [], targetSum = 0\nOutput: false\nExplanation: Since the tree is empty, there are no root-to-leaf paths.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 5000].
    • \n\t
  • -1000 <= Node.val <= 1000
    • \n\t
  • -1000 <= targetSum <= 1000
    • \n
\n
" }, { "path": "113 Path Sum II med s24.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n vector> ans;\n void dfs(TreeNode* node, vector& path, int remainingSum) {\n if (!node) return;\n path.push_back(node-> val);\n if (!node->left && !node->right && remainingSum == node->val) ans.push_back(path);\n dfs(node-> left, path, remainingSum - node-> val);\n dfs(node-> right, path, remainingSum - node-> val);\n // backtrack \n path.pop_back();\n }\n vector> pathSum(TreeNode* root, int targetSum) {\n // used to store current route\n vector path;\n // dfs from the root\n dfs(root, path, targetSum);\n return ans; \n }\n};" }, { "path": "113-Path-Sum-II.cpp", "content": "class Solution {\npublic:\n vector>ans;\n void dfs(vector&curr,TreeNode* root,int target)\n {\n if(!root)\n return;\n curr.push_back(root->val);\n if(root->val==target && !root->left && !root->right)\n ans.push_back(curr);\n dfs(curr,root->left,target-root->val);\n dfs(curr,root->right,target-root->val);\n curr.pop_back();\n }\n ///////\n vector> pathSum(TreeNode* root, int targetSum) \n {\n vectorcurr;\n dfs(curr,root,targetSum);\n \n return ans;\n }\n};\n" }, { "path": "113-path-sum-ii/113-path-sum-ii.java", "content": "class Solution {\n public void check(TreeNode root,int T,List curr,List> list){\n if(root == null){\n return;\n }\n if(T-root.val==0 && root.left == root.right){\n curr.add(root.val);\n list.add(new ArrayList<>(curr));\n curr.remove(curr.size()-1);\n return;\n }\n curr.add(root.val);\n check(root.left,T-root.val,curr,list);\n check(root.right,T-root.val,curr,list);\n curr.remove(curr.size()-1);\n \n }\n public List> pathSum(TreeNode root, int targetSum) {\n List> list = new ArrayList<>();\n List curr = new ArrayList<>();\n check(root,targetSum,curr,list);\n return list;\n }\n}" }, { "path": "113-path-sum-ii/113. Path Sum II.cpp", "content": "class Solution {\npublic:\n vector> v; \n void dfs(TreeNode* root, int targetSum, vector &t){\n if(!root) return;\n t.push_back(root->val);\n targetSum -= root->val;\n if(!root->left and !root->right and targetSum == 0){\n v.push_back(t); \n }else{\n dfs(root->left, targetSum, t);\n dfs(root->right, targetSum, t);\n }\n // backtracking\n t.pop_back();\n return;\n }\n vector> pathSum(TreeNode* root, int targetSum) { \n if(!root) return {}; \n vector t;\n dfs(root, targetSum, t);\n return v;\n }\n};\n" }, { "path": "113-path-sum-ii/NOTES.md", "content": "​" }, { "path": "113-path-sum-ii/README.md", "content": "

113. Path Sum II

Medium

Given the root of a binary tree and an integer targetSum, return all root-to-leaf paths where the sum of the node values in the path equals targetSum. Each path should be returned as a list of the node values, not node references.

\n\n

A root-to-leaf path is a path starting from the root and ending at any leaf node. A leaf is a node with no children.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22\nOutput: [[5,4,11,2],[5,8,4,5]]\nExplanation: There are two paths whose sum equals targetSum:\n5 + 4 + 11 + 2 = 22\n5 + 8 + 4 + 5 = 22\n
\n\n

Example 2:

\n\"\"\n
Input: root = [1,2,3], targetSum = 5\nOutput: []\n
\n\n

Example 3:

\n\n
Input: root = [1,2], targetSum = 0\nOutput: []\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 5000].
    • \n\t
  • -1000 <= Node.val <= 1000
    • \n\t
  • -1000 <= targetSum <= 1000
    • \n
\n
" }, { "path": "114-flatten-binary-tree-to-linked-list/114-flatten-binary-tree-to-linked-list.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public void flatten(TreeNode root) {\n if(root==null)return;\n flatten(root.left);\n TreeNode righty=root.right;\n root.right=root.left;\n root.left=null;\n flatten(righty);\n TreeNode temp=root;\n while(temp.right!=null){\n temp=temp.right;\n }\n temp.right=righty;\n }\n}" }, { "path": "114-flatten-binary-tree-to-linked-list/NOTES.md", "content": "​" }, { "path": "114-flatten-binary-tree-to-linked-list/README.md", "content": "

114. Flatten Binary Tree to Linked List

Medium

Given the root of a binary tree, flatten the tree into a \"linked list\":

\n\n
    \n\t
  • The \"linked list\" should use the same TreeNode class where the right child pointer points to the next node in the list and the left child pointer is always null.
    • \n\t
  • The \"linked list\" should be in the same order as a pre-order traversal of the binary tree.
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,5,3,4,null,6]\nOutput: [1,null,2,null,3,null,4,null,5,null,6]\n
\n\n

Example 2:

\n\n
Input: root = []\nOutput: []\n
\n\n

Example 3:

\n\n
Input: root = [0]\nOutput: [0]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 2000].
    • \n\t
  • -100 <= Node.val <= 100
    • \n
\n\n

 

\nFollow up: Can you flatten the tree in-place (with O(1) extra space)?
" }, { "path": "114-flatten-binary-tree-to-linked-list/SolutionCode.cpp", "content": "class Solution\n{\n public:\n Node* helper(Node* root){\n if(!root) return NULL;\n \n if(!root->left && !root->right) return root;\n \n Node* l = helper(root->left);\n Node* r = helper(root->right);\n \n root->left = NULL;\n if(l){\n root->right = l;\n while(l->right){\n l = l->right;\n }\n l-> right = r;\n }\n else if(r) root->right = r;\n \n return root;\n }\n void flatten(Node *root)\n {\n helper(root); \n }\n};\n" }, { "path": "1143-longest-common-subsequence/1143-longest-common-subsequence.java", "content": "class Solution {\n public int longestCommonSubsequence(String s1, String s2) {\n int[][]dp=new int[s1.length()+1][s2.length()+1];\n for(int i=1;i<=s1.length();i++){\n for(int j=1;j<=s2.length();j++){\n if(s1.charAt(i-1)==s2.charAt(j-1)){\n dp[i][j]=dp[i-1][j-1]+1;\n }else{\n dp[i][j]=Math.max(dp[i-1][j],dp[i][j-1]);\n }\n }\n }\n return dp[s1.length()][s2.length()];\n }\n}" }, { "path": "1143-longest-common-subsequence/README.md", "content": "

1143. Longest Common Subsequence

Medium

Given two strings text1 and text2, return the length of their longest common subsequence. If there is no common subsequence, return 0.

\n\n

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

\n\n
    \n\t
  • For example, \"ace\" is a subsequence of \"abcde\".
    • \n
\n\n

A common subsequence of two strings is a subsequence that is common to both strings.

\n\n

 

\n

Example 1:

\n\n
Input: text1 = \"abcde\", text2 = \"ace\" \nOutput: 3  \nExplanation: The longest common subsequence is \"ace\" and its length is 3.\n
\n\n

Example 2:

\n\n
Input: text1 = \"abc\", text2 = \"abc\"\nOutput: 3\nExplanation: The longest common subsequence is \"abc\" and its length is 3.\n
\n\n

Example 3:

\n\n
Input: text1 = \"abc\", text2 = \"def\"\nOutput: 0\nExplanation: There is no such common subsequence, so the result is 0.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= text1.length, text2.length <= 1000
    • \n\t
  • text1 and text2 consist of only lowercase English characters.
    • \n
\n
" }, { "path": "1155-number-of-dice-rolls-with-target-sum/1155-number-of-dice-rolls-with-target-sum.java", "content": "class Solution {\n static int MOD = (int)1e9 + 7;\n int helper(int n,int t,int k,int dp[][]){\n if(n < 0 || t < 0) return 0;\n if(n == 0 && t == 0) return 1;\n if(dp[n][t] != -1) return dp[n][t];\n int c_ans = 0;\n for(int i = 1;i <= k;i++){\n c_ans = (c_ans + helper(n - 1,t - i,k,dp)) % MOD;\n }\n return dp[n][t] = c_ans;\n }\n public int numRollsToTarget(int n, int k, int target) {\n int dp[][] = new int[n + 1][target + 1];\n for(var a:dp) Arrays.fill(a,-1);\n return helper(n,target,k,dp);\n }\n}" }, { "path": "1155-number-of-dice-rolls-with-target-sum/NOTES.md", "content": "​" }, { "path": "1155-number-of-dice-rolls-with-target-sum/README.md", "content": "

1155. Number of Dice Rolls With Target Sum

Medium

You have n dice and each die has k faces numbered from 1 to k.

\n\n

Given three integers n, k, and target, return the number of possible ways (out of the kn total ways) to roll the dice so the sum of the face-up numbers equals target. Since the answer may be too large, return it modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: n = 1, k = 6, target = 3\nOutput: 1\nExplanation: You throw one die with 6 faces.\nThere is only one way to get a sum of 3.\n
\n\n

Example 2:

\n\n
Input: n = 2, k = 6, target = 7\nOutput: 6\nExplanation: You throw two dice, each with 6 faces.\nThere are 6 ways to get a sum of 7: 1+6, 2+5, 3+4, 4+3, 5+2, 6+1.\n
\n\n

Example 3:

\n\n
Input: n = 30, k = 30, target = 500\nOutput: 222616187\nExplanation: The answer must be returned modulo 109 + 7.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n, k <= 30
    • \n\t
  • 1 <= target <= 1000
    • \n
\n
" }, { "path": "117-populating-next-right-pointers-in-each-node-ii/117-populating-next-right-pointers-in-each-node-ii.java", "content": "class Solution {\n public Node connect(Node root) {\n if (root == null || (root.left == null && root.right == null) ) {\n return root;\n }\n \n // connect left child to right child\n if (root.left != null && root.right != null) {\n root.left.next = root.right;\n }\n \n // connect right child (or left if right is abasent) to child of next nodes.\n Node lNode = (root.right == null) ? root.left : root.right;\n \n Node next = root.next;\n while (next != null && next.left == null && next.right == null) {\n next = next.next;\n }\n\n if (next != null) {\n lNode.next = (next.left != null) ? next.left : next.right;\n }\n \n // process right child first\n connect(root.right);\n connect(root.left);\n \n return root;\n }\n}" }, { "path": "117-populating-next-right-pointers-in-each-node-ii/NOTES.md", "content": "​" }, { "path": "117-populating-next-right-pointers-in-each-node-ii/README.md", "content": "

117. Populating Next Right Pointers in Each Node II

Medium

Given a binary tree

\n\n
struct Node {\n  int val;\n  Node *left;\n  Node *right;\n  Node *next;\n}\n
\n\n

Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.

\n\n

Initially, all next pointers are set to NULL.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,3,4,5,null,7]\nOutput: [1,#,2,3,#,4,5,7,#]\nExplanation: Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.\n
\n\n

Example 2:

\n\n
Input: root = []\nOutput: []\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 6000].
    • \n\t
  • -100 <= Node.val <= 100
    • \n
\n\n

 

\n

Follow-up:

\n\n
    \n\t
  • You may only use constant extra space.
    • \n\t
  • The recursive approach is fine. You may assume implicit stack space does not count as extra space for this problem.
    • \n
\n
" }, { "path": "118-pascals-triangle/118-pascals-triangle.java", "content": "class Solution {\n public List> generate(int numRows) {\n List> triangle = new ArrayList<>();\n \n triangle.add(new ArrayList());\n triangle.get(0).add(1);\n \n for(int i=1; i row = new ArrayList<>();\n List previousRow = triangle.get(i-1);\n \n //first element is always 1\n row.add(1);\n \n for(int j=1; j118. Pascal's Triangle

Easy

Given an integer numRows, return the first numRows of Pascal's triangle.

\n\n

In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:

\n\"\"\n

 

\n

Example 1:

\n
Input: numRows = 5\nOutput: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]\n

Example 2:

\n
Input: numRows = 1\nOutput: [[1]]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= numRows <= 30
    • \n
\n
" }, { "path": "1192-critical-connections-in-a-network/1192-critical-connections-in-a-network.java", "content": "class Solution {\n int[] disc, low;\n int time = 1;\n List> ans = new ArrayList<>();\n Map> edgeMap = new HashMap<>();\n public List> criticalConnections(int n, List> connections) {\n disc = new int[n];\n low = new int[n];\n for (int i = 0; i < n; i++)\n edgeMap.put(i, new ArrayList());\n for (List conn : connections) {\n edgeMap.get(conn.get(0)).add(conn.get(1));\n edgeMap.get(conn.get(1)).add(conn.get(0));\n }\n dfs(0, -1);\n return ans;\n }\n public void dfs(int curr, int prev) {\n disc[curr] = low[curr] = time++;\n for (int next : edgeMap.get(curr)) {\n if (disc[next] == 0) {\n dfs(next, curr);\n low[curr] = Math.min(low[curr], low[next]);\n } else if (next != prev)\n low[curr] = Math.min(low[curr], disc[next]);\n if (low[next] > disc[curr]) \n ans.add(Arrays.asList(curr, next));\n }\n }\n}" }, { "path": "1192-critical-connections-in-a-network/README.md", "content": "

1192. Critical Connections in a Network

Hard

There are n servers numbered from 0 to n - 1 connected by undirected server-to-server connections forming a network where connections[i] = [ai, bi] represents a connection between servers ai and bi. Any server can reach other servers directly or indirectly through the network.

\n\n

A critical connection is a connection that, if removed, will make some servers unable to reach some other server.

\n\n

Return all critical connections in the network in any order.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 4, connections = [[0,1],[1,2],[2,0],[1,3]]\nOutput: [[1,3]]\nExplanation: [[3,1]] is also accepted.\n
\n\n

Example 2:

\n\n
Input: n = 2, connections = [[0,1]]\nOutput: [[0,1]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= n <= 105
    • \n\t
  • n - 1 <= connections.length <= 105
    • \n\t
  • 0 <= ai, bi <= n - 1
    • \n\t
  • ai != bi
    • \n\t
  • There are no repeated connections.
    • \n
\n
" }, { "path": "12-integer-to-roman/12-Leetcode-Integer-to-roman.cpp", "content": "class Solution {\npublic:\n string intToRoman(int num) {\n vector> vp{{1, \"I\"}, {4, \"IV\"}, {5, \"V\"}, {9, \"IX\"}, {10, \"X\"}, {40, \"XL\"}, {50, \"L\"}, {90, \"XC\"}, {100, \"C\"}, {400, \"CD\"}, {500, \"D\"}, {900, \"CM\"}, {1000, \"M\"}};\n string s = \"\";\n int j = vp.size() - 1;\n while(num != 0){ \n for(int i = j; i >= 0; i--){\n if(vp[i].first <= num){\n s += vp[i].second;\n num -= vp[i].first;\n j = i;\n break;\n }\n }\n }\n return s;\n }\n};\n" }, { "path": "12-integer-to-roman/12-integer-to-roman.java", "content": "public class Solution {\n public String intToRoman(int A) {\n StringBuilder sb=new StringBuilder();\n while(A!=0){\n String str=Integer.toString(A);\n String num=\"\";\n for(int i=str.length()-1;i>=0;i--){\n if(str.charAt(i)!='0'){\n num=str.substring(i);\n break;\n }\n }\n String roman=getRoman(Integer.parseInt(num));\n sb.insert(0,roman);\n A-=Integer.parseInt(num);\n }\n return sb.toString();\n }\n public String getRoman(int a){\n switch(a){\n case 1:\n return \"I\";\n case 2:\n return \"II\";\n case 3:\n return \"III\";\n case 4:\n return \"IV\";\n case 5:\n return \"V\";\n case 6:\n return \"VI\";\n case 7:\n return \"VII\";\n case 8:\n return \"VIII\";\n case 9:\n return \"IX\";\n case 10:\n return \"X\";\n case 20:\n return \"XX\";\n case 30:\n return \"XXX\";\n case 40:\n return \"XL\";\n case 50:\n return \"L\";\n case 60:\n return \"LX\";\n case 70:\n return \"LXX\";\n case 80:\n return \"LXXX\";\n case 90:\n return \"XC\";\n case 100:\n return \"C\";\n case 200:\n return \"CC\";\n case 300:\n return \"CCC\";\n case 400:\n return \"CD\";\n case 500:\n return \"D\";\n case 600:\n return \"DC\";\n case 700:\n return \"DCC\";\n case 800:\n return \"DCCC\";\n case 900:\n return \"CM\";\n case 1000:\n return \"M\";\n case 2000:\n return \"MM\";\n case 3000:\n return \"MMM\";\n }\n return \"\";\n }\n}" }, { "path": "12-integer-to-roman/NOTES.md", "content": "​" }, { "path": "12-integer-to-roman/README.md", "content": "

12. Integer to Roman

Medium

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

\n\n
Symbol       Value\nI             1\nV             5\nX             10\nL             50\nC             100\nD             500\nM             1000
\n\n

For example, 2 is written as II in Roman numeral, just two one's added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

\n\n

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

\n\n
    \n\t
  • I can be placed before V (5) and X (10) to make 4 and 9. 
    • \n\t
  • X can be placed before L (50) and C (100) to make 40 and 90. 
    • \n\t
  • C can be placed before D (500) and M (1000) to make 400 and 900.
    • \n
\n\n

Given an integer, convert it to a roman numeral.

\n\n

 

\n

Example 1:

\n\n
Input: num = 3\nOutput: \"III\"\nExplanation: 3 is represented as 3 ones.\n
\n\n

Example 2:

\n\n
Input: num = 58\nOutput: \"LVIII\"\nExplanation: L = 50, V = 5, III = 3.\n
\n\n

Example 3:

\n\n
Input: num = 1994\nOutput: \"MCMXCIV\"\nExplanation: M = 1000, CM = 900, XC = 90 and IV = 4.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= num <= 3999
    • \n
\n
" }, { "path": "120-triangle/120-triangle.java", "content": "class Solution {\n public int minimumTotal(List> list) {\n int sz=list.size();\n if(sz==1)\n return list.get(0).get(0);\n int dp[]=new int[sz+1];\n for(int row=sz-1;row>=0;row--)\n {\n int len=list.get(row).size();\n for(int col=0;col120. Triangle

Medium

Given a triangle array, return the minimum path sum from top to bottom.

\n\n

For each step, you may move to an adjacent number of the row below. More formally, if you are on index i on the current row, you may move to either index i or index i + 1 on the next row.

\n\n

 

\n

Example 1:

\n\n
Input: triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]\nOutput: 11\nExplanation: The triangle looks like:\n   2\n  3 4\n 6 5 7\n4 1 8 3\nThe minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above).\n
\n\n

Example 2:

\n\n
Input: triangle = [[-10]]\nOutput: -10\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= triangle.length <= 200
    • \n\t
  • triangle[0].length == 1
    • \n\t
  • triangle[i].length == triangle[i - 1].length + 1
    • \n\t
  • -104 <= triangle[i][j] <= 104
    • \n
\n\n

 

\nFollow up: Could you do this using only O(n) extra space, where n is the total number of rows in the triangle?
" }, { "path": "1207-unique-number-of-occurrences/1207-unique-number-of-occurrences.java", "content": "class Solution {\n public boolean uniqueOccurrences(int[] arr) {\n\t\tint min = Integer.MAX_VALUE;\n\t\tint max = Integer.MIN_VALUE;\n\n\t\tfor (int num : arr) {\n\t\t\tmin = Math.min(min, num);\n\t\t\tmax = Math.max(max, num);\n\t\t}\n\n\t\tint[] frequency = new int[max - min + 1];\n\t\tboolean[] frequency2 = new boolean[arr.length + 1];\n\n\t\tfor (int num : arr) {\n\t\t\tfrequency[num - min]++;\n\t\t}\n\n\t\tfor (int num : frequency) {\n\t\t\tif (num > 0) {\n\t\t\t\tif (frequency2[num]) return false;\n\n\t\t\t\tfrequency2[num]=true;\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn true;\n }\n}" }, { "path": "1207-unique-number-of-occurrences/NOTES.md", "content": "​" }, { "path": "1207-unique-number-of-occurrences/README.md", "content": "

1207. Unique Number of Occurrences

Easy

Given an array of integers arr, return true if the number of occurrences of each value in the array is unique, or false otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: arr = [1,2,2,1,1,3]\nOutput: true\nExplanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.
\n\n

Example 2:

\n\n
Input: arr = [1,2]\nOutput: false\n
\n\n

Example 3:

\n\n
Input: arr = [-3,0,1,-3,1,1,1,-3,10,0]\nOutput: true\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= arr.length <= 1000
    • \n\t
  • -1000 <= arr[i] <= 1000
    • \n
\n
" }, { "path": "1209-remove-all-adjacent-duplicates-in-string-ii/1209-remove-all-adjacent-duplicates-in-string-ii.java", "content": "class Solution {\n public String removeDuplicates(String s, int k) {\n int w = 0;\n int n = s.length();\n int []count = new int[n];\n char[] ar = s.toCharArray();\n for(int i=0;i1209. Remove All Adjacent Duplicates in String II

Medium

You are given a string s and an integer k, a k duplicate removal consists of choosing k adjacent and equal letters from s and removing them, causing the left and the right side of the deleted substring to concatenate together.

\n\n

We repeatedly make k duplicate removals on s until we no longer can.

\n\n

Return the final string after all such duplicate removals have been made. It is guaranteed that the answer is unique.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"abcd\", k = 2\nOutput: \"abcd\"\nExplanation: There's nothing to delete.
\n\n

Example 2:

\n\n
Input: s = \"deeedbbcccbdaa\", k = 3\nOutput: \"aa\"\nExplanation: \nFirst delete \"eee\" and \"ccc\", get \"ddbbbdaa\"\nThen delete \"bbb\", get \"dddaa\"\nFinally delete \"ddd\", get \"aa\"
\n\n

Example 3:

\n\n
Input: s = \"pbbcggttciiippooaais\", k = 2\nOutput: \"ps\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 105
    • \n\t
  • 2 <= k <= 104
    • \n\t
  • s only contains lower case English letters.
    • \n
\n
" }, { "path": "1220-count-vowels-permutation/1220-count-vowels-permutation.java", "content": "class Solution {\n public int countVowelPermutation(int n) {\n int mod=(int)Math.pow(10,9)+7;\n int[]dp=new int[5];\n for(int i=0;i<5;i++){\n dp[i]=1;\n }\n for(int level=2;level<=n;level++){\n int a= ((dp[1]+ dp[2])%mod +dp[4])%mod;\n int e= (dp[0] + dp[2])%mod;\n int i= (dp[1] + dp[3])%mod;\n int o=dp[2];\n int u=(dp[2]+ dp[3])%mod;\n dp[0]=a;\n dp[1]=e;\n dp[2]=i;\n dp[3]=o;\n dp[4]=u;\n }\n return (((dp[0]+dp[1])%mod +(dp[2]+dp[3])%mod)%mod +dp[4])%mod;\n }\n}" }, { "path": "1220-count-vowels-permutation/NOTES.md", "content": "​" }, { "path": "1220-count-vowels-permutation/README.md", "content": "

1220. Count Vowels Permutation

Hard

Given an integer n, your task is to count how many strings of length n can be formed under the following rules:

\n\n
    \n\t
  • Each character is a lower case vowel ('a', 'e', 'i', 'o', 'u')
    • \n\t
  • Each vowel 'a' may only be followed by an 'e'.
    • \n\t
  • Each vowel 'e' may only be followed by an 'a' or an 'i'.
    • \n\t
  • Each vowel 'i' may not be followed by another 'i'.
    • \n\t
  • Each vowel 'o' may only be followed by an 'i' or a 'u'.
    • \n\t
  • Each vowel 'u' may only be followed by an 'a'.
    • \n
\n\n

Since the answer may be too large, return it modulo 10^9 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: n = 1\nOutput: 5\nExplanation: All possible strings are: \"a\", \"e\", \"i\" , \"o\" and \"u\".\n
\n\n

Example 2:

\n\n
Input: n = 2\nOutput: 10\nExplanation: All possible strings are: \"ae\", \"ea\", \"ei\", \"ia\", \"ie\", \"io\", \"iu\", \"oi\", \"ou\" and \"ua\".\n
\n\n

Example 3: 

\n\n
Input: n = 5\nOutput: 68
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 2 * 10^4
    • \n
\n
" }, { "path": "1235-maximum-profit-in-job-scheduling/1235-maximum-profit-in-job-scheduling.java", "content": "class Solution {\n class Job implements Comparable{\n int start;\n int end;\n int profit;\n Job(int start, int end, int profit) {\n this.start = start;\n this.end = end;\n this.profit = profit;\n }\n public int compareTo(Job otherJob) {\n return this.start - otherJob.start;\n }\n }\n public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {\n int n = startTime.length;\n Job[] jobs = new Job[n];\n for (int i=0; i=0; i--) {\n dp[i] = Math.max(jobs[i].profit, dp[i+1]);\n for (int j=i+1; j < n; j++) {\n if (jobs[i].end <= jobs[j].start) {\n dp[i] = Math.max(dp[i], jobs[i].profit + dp[j]);\n break;\n }\n }\n }\n return dp[0];\n }\n}" }, { "path": "1235-maximum-profit-in-job-scheduling/NOTES.md", "content": "​" }, { "path": "1235-maximum-profit-in-job-scheduling/README.md", "content": "

1235. Maximum Profit in Job Scheduling

Hard

We have n jobs, where every job is scheduled to be done from startTime[i] to endTime[i], obtaining a profit of profit[i].

\n\n

You're given the startTime, endTime and profit arrays, return the maximum profit you can take such that there are no two jobs in the subset with overlapping time range.

\n\n

If you choose a job that ends at time X you will be able to start another job that starts at time X.

\n\n

 

\n

Example 1:

\n\n

\"\"

\n\n
Input: startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]\nOutput: 120\nExplanation: The subset chosen is the first and fourth job. \nTime range [1-3]+[3-6] , we get profit of 120 = 50 + 70.\n
\n\n

Example 2:

\n\n

\"\"

\n\n
Input: startTime = [1,2,3,4,6], endTime = [3,5,10,6,9], profit = [20,20,100,70,60]\nOutput: 150\nExplanation: The subset chosen is the first, fourth and fifth job. \nProfit obtained 150 = 20 + 70 + 60.\n
\n\n

Example 3:

\n\n

\"\"

\n\n
Input: startTime = [1,1,1], endTime = [2,3,4], profit = [5,6,4]\nOutput: 6\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= startTime.length == endTime.length == profit.length <= 5 * 104
    • \n\t
  • 1 <= startTime[i] < endTime[i] <= 109
    • \n\t
  • 1 <= profit[i] <= 104
    • \n
\n
" }, { "path": "1239-maximum-length-of-a-concatenated-string-with-unique-characters/1239-maximum-length-of-a-concatenated-string-with-unique-characters.java", "content": "class Solution {\n public int solve(String strs[], int no, int a[], int index, int c) {\n if(index==c)\n return 0;\n int x=no & a[index];\n if(x==0) \n return Math.max(strs[index].length()+solve(strs,no^a[index],a,index+1,c),solve(strs,no,a,index+1,c));\n else\n return solve(strs,no,a,index+1,c);\n }\n public int maxLength(List arr) {\n int a[]=new int[arr.size()];int c=0;String strs[]=new String[a.length];\n for(String s:arr) {\n int x=0,fl=0;\n for(char ch:s.toCharArray()) \n {\n int z=x|(1<<(ch-96));\n if(x==z)\n {\n fl=1;break; \n }\n x=z;\n }\n if(fl==0)\n {\n a[c]=x;\n strs[c++]=s;\n }\n }\n return solve(strs,0,a,0,c);\n }\n}" }, { "path": "1239-maximum-length-of-a-concatenated-string-with-unique-characters/NOTES.md", "content": "​" }, { "path": "1239-maximum-length-of-a-concatenated-string-with-unique-characters/README.md", "content": "

1239. Maximum Length of a Concatenated String with Unique Characters

Medium

You are given an array of strings arr. A string s is formed by the concatenation of a subsequence of arr that has unique characters.

\n\n

Return the maximum possible length of s.

\n\n

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

\n\n

 

\n

Example 1:

\n\n
Input: arr = [\"un\",\"iq\",\"ue\"]\nOutput: 4\nExplanation: All the valid concatenations are:\n- \"\"\n- \"un\"\n- \"iq\"\n- \"ue\"\n- \"uniq\" (\"un\" + \"iq\")\n- \"ique\" (\"iq\" + \"ue\")\nMaximum length is 4.\n
\n\n

Example 2:

\n\n
Input: arr = [\"cha\",\"r\",\"act\",\"ers\"]\nOutput: 6\nExplanation: Possible longest valid concatenations are \"chaers\" (\"cha\" + \"ers\") and \"acters\" (\"act\" + \"ers\").\n
\n\n

Example 3:

\n\n
Input: arr = [\"abcdefghijklmnopqrstuvwxyz\"]\nOutput: 26\nExplanation: The only string in arr has all 26 characters.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= arr.length <= 16
    • \n\t
  • 1 <= arr[i].length <= 26
    • \n\t
  • arr[i] contains only lowercase English letters.
    • \n
\n
" }, { "path": "126-word-ladder-ii/126-word-ladder-ii.java", "content": "class Solution {\n public List> findLadders(String beginWord, String endWord, List wordList) {\n this.beginWord = beginWord;\n this.endWord = endWord;\n if (!sanityCheck(wordList)) {\n return new ArrayList<>();\n }\n prepare(wordList);\n minTrans();\n return trans;\n }\n\n private String beginWord;\n private String endWord;\n private Map w2p;\n private Map> p2w;\n\n private void minTrans() {\n Map minLens = new HashMap<>();\n Map> prev = new HashMap<>();\n List queue = new ArrayList<>();\n int minLen = -1;\n\n minLens.put(endWord, 0);\n queue.add(endWord);\n int count = 0;\n while (count < queue.size()) {\n String node = queue.get(count++);\n int len = minLens.get(node) + 1;\n if (minLen != -1 && len > minLen) {\n break;\n }\n\n for (String pattern : w2p.get(node)) {\n for (String word : p2w.get(pattern)) {\n if (!minLens.containsKey(word)) {\n minLens.put(word, len);\n queue.add(word);\n prev.put(word, new HashSet<>());\n if (word.equals(beginWord)) {\n minLen = len;\n }\n } else if (minLens.get(word) < len) {\n continue;\n }\n prev.get(word).add(node);\n }\n }\n }\n\n makeTrans(prev, minLens.getOrDefault(beginWord, -1));\n }\n\n private List> trans;\n private Map> paths;\n\n private void makeTrans(Map> paths, int maxLen) {\n this.trans = new ArrayList<>();\n this.paths = paths;\n if (maxLen == -1) {\n return;\n }\n String[] path = new String[maxLen + 1];\n path[0] = beginWord;\n makeTransInternal(beginWord, 1, path);\n }\n\n void makeTransInternal(String start, int depth, String[] path) {\n if (depth == path.length - 1) {\n path[depth] = endWord;\n List result = new ArrayList<>();\n for (String word : path) {\n result.add(word);\n }\n this.trans.add(result);\n return;\n }\n for (String word : paths.get(start)) {\n path[depth] = word;\n makeTransInternal(word, depth + 1, path);\n }\n }\n\n private boolean sanityCheck(List wordList) {\n for (String word : wordList) {\n if (word.equals(endWord)) {\n return true;\n }\n }\n return false;\n }\n\n private void prepare(List wordList) {\n // Prepare a word -> patterns map.\n w2p = new HashMap<>();\n w2p.put(beginWord, getPatterns(beginWord));\n for (String word : wordList) {\n w2p.put(word, getPatterns(word));\n }\n\n // Prepare a pattern -> words map.\n p2w = new HashMap<>();\n for (String word : w2p.keySet()) {\n for (String pattern : w2p.get(word)) {\n if (!p2w.containsKey(pattern)) {\n p2w.put(pattern, new ArrayList<>());\n }\n p2w.get(pattern).add(word);\n }\n }\n }\n\n private String[] getPatterns(String word) {\n char[] wc = word.toCharArray();\n char original;\n String[] patterns = new String[wc.length];\n for (int i = 0; i < wc.length; ++i) {\n original = wc[i];\n wc[i] = '*';\n patterns[i] = new String(wc);\n wc[i] = original;\n }\n return patterns;\n }\n}" }, { "path": "126-word-ladder-ii/NOTES.md", "content": "​" }, { "path": "126-word-ladder-ii/README.md", "content": "

126. Word Ladder II

Hard

A transformation sequence from word beginWord to word endWord using a dictionary wordList is a sequence of words beginWord -> s1 -> s2 -> ... -> sk such that:

\n\n
    \n\t
  • Every adjacent pair of words differs by a single letter.
    • \n\t
  • Every si for 1 <= i <= k is in wordList. Note that beginWord does not need to be in wordList.
    • \n\t
  • sk == endWord
    • \n
\n\n

Given two words, beginWord and endWord, and a dictionary wordList, return all the shortest transformation sequences from beginWord to endWord, or an empty list if no such sequence exists. Each sequence should be returned as a list of the words [beginWord, s1, s2, ..., sk].

\n\n

 

\n

Example 1:

\n\n
Input: beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\",\"cog\"]\nOutput: [[\"hit\",\"hot\",\"dot\",\"dog\",\"cog\"],[\"hit\",\"hot\",\"lot\",\"log\",\"cog\"]]\nExplanation: There are 2 shortest transformation sequences:\n\"hit\" -> \"hot\" -> \"dot\" -> \"dog\" -> \"cog\"\n\"hit\" -> \"hot\" -> \"lot\" -> \"log\" -> \"cog\"\n
\n\n

Example 2:

\n\n
Input: beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\"]\nOutput: []\nExplanation: The endWord \"cog\" is not in wordList, therefore there is no valid transformation sequence.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= beginWord.length <= 5
    • \n\t
  • endWord.length == beginWord.length
    • \n\t
  • 1 <= wordList.length <= 500
    • \n\t
  • wordList[i].length == beginWord.length
    • \n\t
  • beginWord, endWord, and wordList[i] consist of lowercase English letters.
    • \n\t
  • beginWord != endWord
    • \n\t
  • All the words in wordList are unique.
    • \n
\n
" }, { "path": "1260-shift-2d-grid/1260-shift-2d-grid.java", "content": "class Solution {\n public List> shiftGrid(int[][] grid, int k) {\n int rowCount = grid.length;// Number of rows in grid.\n int colCount = grid[0].length;// Number of columns in grid.\n int gridCount = rowCount * colCount;// Number of cells (i.e. values) in grid.\n k = k % gridCount;// Limit k to max number of cells in grid. Avoid negatives in next lines.\n int kCol = (gridCount - k) % colCount;// Column to start copying from.\n int kRow = ((gridCount - k) % gridCount) / colCount;// Row to start copying from.\n int[] innRow = grid[kRow]; // Array for the row to start copying from.\n int[][] result = new int[rowCount][colCount]; // Create result matrix, to hold shifted values.\n for (int r = 0; r < rowCount; r++) { // Loop through \"to\" rows.\n int[] outRow = result[r];// Get row array to copy into, so only faster 1D reference in inner loop.\n for (int c = 0; c < colCount; c++) {// Loop through \"to\" columns.\n outRow[c] = innRow[kCol]; // Copy value from grid to result, shifting by copying.\n if (++kCol >= colCount) { // Next \"from\" column. If at end of row...\n kCol = 0; // Then start \"from\" columns at first column.\n if (++kRow >= rowCount) // When starting new column, next \"from\" row. If at end of grid...\n kRow = 0; // Then start \"from\" rows at first row.\n innRow = grid[kRow]; // Get row array to copy from, so only faster 1D reference when copying.\n }\n }\n }\n return (List)Arrays.asList(result); // Return result matrix, converting it to a List>.\n }\n}" }, { "path": "1260-shift-2d-grid/NOTES.md", "content": "​" }, { "path": "1260-shift-2d-grid/README.md", "content": "

1260. Shift 2D Grid

Easy

Given a 2D grid of size m x n and an integer k. You need to shift the grid k times.

\n\n

In one shift operation:

\n\n
    \n\t
  • Element at grid[i][j] moves to grid[i][j + 1].
    • \n\t
  • Element at grid[i][n - 1] moves to grid[i + 1][0].
    • \n\t
  • Element at grid[m - 1][n - 1] moves to grid[0][0].
    • \n
\n\n

Return the 2D grid after applying shift operation k times.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: grid = [[1,2,3],[4,5,6],[7,8,9]], k = 1\nOutput: [[9,1,2],[3,4,5],[6,7,8]]\n
\n\n

Example 2:

\n\"\"\n
Input: grid = [[3,8,1,9],[19,7,2,5],[4,6,11,10],[12,0,21,13]], k = 4\nOutput: [[12,0,21,13],[3,8,1,9],[19,7,2,5],[4,6,11,10]]\n
\n\n

Example 3:

\n\n
Input: grid = [[1,2,3],[4,5,6],[7,8,9]], k = 9\nOutput: [[1,2,3],[4,5,6],[7,8,9]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == grid.length
    • \n\t
  • n == grid[i].length
    • \n\t
  • 1 <= m <= 50
    • \n\t
  • 1 <= n <= 50
    • \n\t
  • -1000 <= grid[i][j] <= 1000
    • \n\t
  • 0 <= k <= 100
    • \n
\n
" }, { "path": "1268-search-suggestions-system/1268-search-suggestions-system.java", "content": "class Solution {\n public List> suggestedProducts(String[] products, String searchWord) {\n List> ret = new ArrayList();\n Arrays.sort(products);\n for(int i = 1; i <= searchWord.length(); i++) {\n List toAdd = new ArrayList();\n String key = searchWord.substring(0,i);\n for(String product : products) {\n if(product.length() >= i && product.indexOf(key) == 0) {\n toAdd.add(product);\n if(toAdd.size() == 3) break;\n }\n }\n ret.add(toAdd);\n }\n return ret;\n }\n}" }, { "path": "1268-search-suggestions-system/NOTES.md", "content": "​" }, { "path": "1268-search-suggestions-system/README.md", "content": "

1268. Search Suggestions System

Medium

You are given an array of strings products and a string searchWord.

\n\n

Design a system that suggests at most three product names from products after each character of searchWord is typed. Suggested products should have common prefix with searchWord. If there are more than three products with a common prefix return the three lexicographically minimums products.

\n\n

Return a list of lists of the suggested products after each character of searchWord is typed.

\n\n

 

\n

Example 1:

\n\n
Input: products = [\"mobile\",\"mouse\",\"moneypot\",\"monitor\",\"mousepad\"], searchWord = \"mouse\"\nOutput: [\n[\"mobile\",\"moneypot\",\"monitor\"],\n[\"mobile\",\"moneypot\",\"monitor\"],\n[\"mouse\",\"mousepad\"],\n[\"mouse\",\"mousepad\"],\n[\"mouse\",\"mousepad\"]\n]\nExplanation: products sorted lexicographically = [\"mobile\",\"moneypot\",\"monitor\",\"mouse\",\"mousepad\"]\nAfter typing m and mo all products match and we show user [\"mobile\",\"moneypot\",\"monitor\"]\nAfter typing mou, mous and mouse the system suggests [\"mouse\",\"mousepad\"]\n
\n\n

Example 2:

\n\n
Input: products = [\"havana\"], searchWord = \"havana\"\nOutput: [[\"havana\"],[\"havana\"],[\"havana\"],[\"havana\"],[\"havana\"],[\"havana\"]]\n
\n\n

Example 3:

\n\n
Input: products = [\"bags\",\"baggage\",\"banner\",\"box\",\"cloths\"], searchWord = \"bags\"\nOutput: [[\"baggage\",\"bags\",\"banner\"],[\"baggage\",\"bags\",\"banner\"],[\"baggage\",\"bags\"],[\"bags\"]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= products.length <= 1000
    • \n\t
  • 1 <= products[i].length <= 3000
    • \n\t
  • 1 <= sum(products[i].length) <= 2 * 104
    • \n\t
  • All the strings of products are unique.
    • \n\t
  • products[i] consists of lowercase English letters.
    • \n\t
  • 1 <= searchWord.length <= 1000
    • \n\t
  • searchWord consists of lowercase English letters.
    • \n
\n
" }, { "path": "128-longest-consecutive-sequence/128-longest-consecutive-sequence.java", "content": "class Solution {\n public int longestConsecutive(int[] nums) {\n Set num_set = new HashSet();\n for (int num : nums) {\n num_set.add(num);\n }\n\n int longestStreak = 0;\n\n for (int num : nums) {\n if (!num_set.contains(num-1)){\n int currentNum = num;\n int currentStreak = 1;\n\n while (num_set.contains(currentNum+1)) {\n currentNum += 1;\n currentStreak += 1;\n }\n\n longestStreak = Math.max(longestStreak, currentStreak);\n }\n }\n\n return longestStreak;\n }\n}" }, { "path": "128-longest-consecutive-sequence/NOTES.md", "content": "​" }, { "path": "128-longest-consecutive-sequence/README.md", "content": "

128. Longest Consecutive Sequence

Medium

Given an unsorted array of integers nums, return the length of the longest consecutive elements sequence.

\n\n

You must write an algorithm that runs in O(n) time.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [100,4,200,1,3,2]\nOutput: 4\nExplanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefore its length is 4.\n
\n\n

Example 2:

\n\n
Input: nums = [0,3,7,2,5,8,4,6,0,1]\nOutput: 9\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= nums.length <= 105
    • \n\t
  • -109 <= nums[i] <= 109
    • \n
\n
" }, { "path": "1293-shortest-path-in-a-grid-with-obstacles-elimination/1293-shortest-path-in-a-grid-with-obstacles-elimination.java", "content": "class Solution {\n class Node {\n int row;\n int col;\n int obstacles;\n\n Node(int row, int col, int obstacles){\n this.row = row;\n this.col = col;\n this.obstacles = obstacles;\n }\n }\n \n private int[][] directions = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};\n \n public int shortestPath(int[][] grid, int k) {\n int rows = grid.length;\n int cols = grid[0].length;\n int[][] visited = new int[rows][cols];\n for(int i = 0; i < rows; i++) {\n Arrays.fill(visited[i], Integer.MAX_VALUE);\n }\n \n visited[0][0] = grid[0][0];\n Queue queue = new LinkedList<>();\n queue.add(new Node(0, 0, grid[0][0]));\n int result = 0;\n \n while(!queue.isEmpty()) {\n int size = queue.size();\n for(int i = 0; i < size; i++) {\n Node node = queue.poll();\n if(node.row == rows-1 && node.col == cols-1) {\n return result;\n }\n for(int t = 0; t < directions.length; t++) {\n int newRow = node.row + directions[t][0];\n int newCol = node.col + directions[t][1];\n \n if(newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols) {\n\n int obstacles = node.obstacles + grid[newRow][newCol];\n if(obstacles > k) {\n continue;\n }\n if(visited[newRow][newCol] > obstacles) {\n visited[newRow][newCol] = obstacles;\n queue.add(new Node(newRow, newCol, obstacles));\n }\n }\n }\n }\n result++;\n }\n return -1;\n }\n}" }, { "path": "1293-shortest-path-in-a-grid-with-obstacles-elimination/NOTES.md", "content": "​" }, { "path": "1293-shortest-path-in-a-grid-with-obstacles-elimination/README.md", "content": "

1293. Shortest Path in a Grid with Obstacles Elimination

Hard

You are given an m x n integer matrix grid where each cell is either 0 (empty) or 1 (obstacle). You can move up, down, left, or right from and to an empty cell in one step.

\n\n

Return the minimum number of steps to walk from the upper left corner (0, 0) to the lower right corner (m - 1, n - 1) given that you can eliminate at most k obstacles. If it is not possible to find such walk return -1.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: grid = [[0,0,0],[1,1,0],[0,0,0],[0,1,1],[0,0,0]], k = 1\nOutput: 6\nExplanation: \nThe shortest path without eliminating any obstacle is 10.\nThe shortest path with one obstacle elimination at position (3,2) is 6. Such path is (0,0) -> (0,1) -> (0,2) -> (1,2) -> (2,2) -> (3,2) -> (4,2).\n
\n\n

Example 2:

\n\"\"\n
Input: grid = [[0,1,1],[1,1,1],[1,0,0]], k = 1\nOutput: -1\nExplanation: We need to eliminate at least two obstacles to find such a walk.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == grid.length
    • \n\t
  • n == grid[i].length
    • \n\t
  • 1 <= m, n <= 40
    • \n\t
  • 1 <= k <= m * n
    • \n\t
  • grid[i][j] is either 0 or 1.
    • \n\t
  • grid[0][0] == grid[m - 1][n - 1] == 0
    • \n
\n
" }, { "path": "13-roman-to-integer/13-roman-to-integer.cpp", "content": "class Solution {\npublic:\n int romanToInt(string s) {\n unordered_map mp{{'I',1},{'V',5},{'X',10},{'L',50},{'C',100,},{'D',500},{'M',1000}};\n int ans = mp[s.back()];\n for(int i=s.size()-2;i>=0;i--){\n if(mp[s[i]] < mp[s[i+1]]) ans -= mp[s[i]];\n else ans += mp[s[i]];\n }\n return ans;\n }\n};\n" }, { "path": "13-roman-to-integer/13-roman-to-integer.java", "content": "public class Solution {\n public int romanToInt(String A) {\n int ans=0;\n int i=0;\n while(igetValue(A.charAt(i))){\n ans+=getValue(A.charAt(i+1))-getValue(A.charAt(i));\n i+=2;\n }else{\n ans+=getValue(A.charAt(i));\n i++;\n }\n }else{\n ans+=getValue(A.charAt(i));\n i++;\n }\n }\n return ans;\n }\n int getValue(char ch){\n switch(ch){\n case 'I':\n return 1;\n case 'V':\n return 5;\n case 'X':\n return 10;\n case 'L':\n return 50;\n case 'C':\n return 100;\n case 'D':\n return 500;\n case 'M':\n return 1000;\n default:\n return -1;\n }\n }\n}" }, { "path": "13-roman-to-integer/NOTES.md", "content": "​" }, { "path": "13-roman-to-integer/README.md", "content": "

13. Roman to Integer

Easy

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

\n\n
Symbol       Value\nI             1\nV             5\nX             10\nL             50\nC             100\nD             500\nM             1000
\n\n

For example, 2 is written as II in Roman numeral, just two ones added together. 12 is written as XII, which is simply X + II. The number 27 is written as XXVII, which is XX + V + II.

\n\n

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

\n\n
    \n\t
  • I can be placed before V (5) and X (10) to make 4 and 9. 
    • \n\t
  • X can be placed before L (50) and C (100) to make 40 and 90. 
    • \n\t
  • C can be placed before D (500) and M (1000) to make 400 and 900.
    • \n
\n\n

Given a roman numeral, convert it to an integer.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"III\"\nOutput: 3\nExplanation: III = 3.\n
\n\n

Example 2:

\n\n
Input: s = \"LVIII\"\nOutput: 58\nExplanation: L = 50, V= 5, III = 3.\n
\n\n

Example 3:

\n\n
Input: s = \"MCMXCIV\"\nOutput: 1994\nExplanation: M = 1000, CM = 900, XC = 90 and IV = 4.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 15
    • \n\t
  • s contains only the characters ('I', 'V', 'X', 'L', 'C', 'D', 'M').
    • \n\t
  • It is guaranteed that s is a valid roman numeral in the range [1, 3999].
    • \n
\n
" }, { "path": "1302-deepest-leaves-sum/1302-deepest-leaves-sum.java", "content": "class Solution {\n int deepestLevel = 0;\n int sum;\n \n public int deepestLeavesSum(TreeNode root) {\n deepestLeavesSum(root, 0);\n return sum;\n }\n \n public void deepestLeavesSum(TreeNode root,int level) {\n if (root == null) {\n return;\n }\n \n if (root.left == null && root.right == null && level == deepestLevel) {\n sum = sum + root.val;\n }\n \n if (root.left == null && root.right == null && level > deepestLevel) {\n deepestLevel = level;\n sum = root.val;\n }\n \n deepestLeavesSum(root.left, level + 1);\n deepestLeavesSum(root.right, level + 1);\n }\n}" }, { "path": "1302-deepest-leaves-sum/NOTES.md", "content": "​" }, { "path": "1302-deepest-leaves-sum/README.md", "content": "

1302. Deepest Leaves Sum

Medium

Given the root of a binary tree, return the sum of values of its deepest leaves.\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,3,4,5,null,6,7,null,null,null,null,8]\nOutput: 15\n
\n\n

Example 2:

\n\n
Input: root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]\nOutput: 19\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 104].
    • \n\t
  • 1 <= Node.val <= 100
    • \n
\n
" }, { "path": "1323-maximum-69-number/1323-maximum-69-number.java", "content": "class Solution {\n public int maximum69Number (int num) {\n char[] arr=(String.valueOf(num)).toCharArray();\n for(int i=0;i1323. Maximum 69 Number

Easy

You are given a positive integer num consisting only of digits 6 and 9.

\n\n

Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).

\n\n

 

\n

Example 1:

\n\n
Input: num = 9669\nOutput: 9969\nExplanation: \nChanging the first digit results in 6669.\nChanging the second digit results in 9969.\nChanging the third digit results in 9699.\nChanging the fourth digit results in 9666.\nThe maximum number is 9969.\n
\n\n

Example 2:

\n\n
Input: num = 9996\nOutput: 9999\nExplanation: Changing the last digit 6 to 9 results in the maximum number.\n
\n\n

Example 3:

\n\n
Input: num = 9999\nOutput: 9999\nExplanation: It is better not to apply any change.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= num <= 104
    • \n\t
  • num consists of only 6 and 9 digits.
    • \n
\n
" }, { "path": "1328-break-a-palindrome/1328-break-a-palindrome.java", "content": "class Solution {\n public String breakPalindrome(String palindrome) {\n if (palindrome.length() == 1){\n return \"\";\n }\n else\n {\n char[] arr = palindrome.toCharArray();\n for (int i=0; i1328. Break a Palindrome

Medium

Given a palindromic string of lowercase English letters palindrome, replace exactly one character with any lowercase English letter so that the resulting string is not a palindrome and that it is the lexicographically smallest one possible.

\n\n

Return the resulting string. If there is no way to replace a character to make it not a palindrome, return an empty string.

\n\n

A string a is lexicographically smaller than a string b (of the same length) if in the first position where a and b differ, a has a character strictly smaller than the corresponding character in b. For example, \"abcc\" is lexicographically smaller than \"abcd\" because the first position they differ is at the fourth character, and 'c' is smaller than 'd'.

\n\n

 

\n

Example 1:

\n\n
Input: palindrome = \"abccba\"\nOutput: \"aaccba\"\nExplanation: There are many ways to make \"abccba\" not a palindrome, such as \"zbccba\", \"aaccba\", and \"abacba\".\nOf all the ways, \"aaccba\" is the lexicographically smallest.\n
\n\n

Example 2:

\n\n
Input: palindrome = \"a\"\nOutput: \"\"\nExplanation: There is no way to replace a single character to make \"a\" not a palindrome, so return an empty string.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= palindrome.length <= 1000
    • \n\t
  • palindrome consists of only lowercase English letters.
    • \n
\n
" }, { "path": "1329-sort-the-matrix-diagonally/1329-sort-the-matrix-diagonally.cpp", "content": "class Solution {\npublic:\n vector> diagonalSort(vector>& mat) { \n\n// // Explanation\n// // A[i][j] on the same diagonal have same value of i - j\n// // For each diagonal,\n// // put its elements together, sort, and set them back.\n\n\n// // Complexity\n// // Time O(MNlogD), where D is the length of diagonal with D = min(M,N).\n// // Space O(MN)\n\n // solving with priority queue, 20ms\n// int n = mat.size(), m = mat[0].size();\n// unordered_map, greater>> mp;\n// for(int i=0;i t;\n while(p < r and q < c){\n t.push_back(mat[p][q]);\n p++;q++;\n }\n sort(t.begin(), t.end());\n // placing back\n p=0,q=i,j=0;\n while(p t;\n p=i,q=0;\n while(p0){\n int cnt=values[i];\n while(cnt-->0){\n mat[r][c]=i;\n r++;c++;\n }\n }\n }\n }\n}" }, { "path": "1329-sort-the-matrix-diagonally/NOTES.md", "content": "​" }, { "path": "1329-sort-the-matrix-diagonally/README.md", "content": "

1329. Sort the Matrix Diagonally

Medium

A matrix diagonal is a diagonal line of cells starting from some cell in either the topmost row or leftmost column and going in the bottom-right direction until reaching the matrix's end. For example, the matrix diagonal starting from mat[2][0], where mat is a 6 x 3 matrix, includes cells mat[2][0], mat[3][1], and mat[4][2].

\n\n

Given an m x n matrix mat of integers, sort each matrix diagonal in ascending order and return the resulting matrix.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: mat = [[3,3,1,1],[2,2,1,2],[1,1,1,2]]\nOutput: [[1,1,1,1],[1,2,2,2],[1,2,3,3]]\n
\n\n

Example 2:

\n\n
Input: mat = [[11,25,66,1,69,7],[23,55,17,45,15,52],[75,31,36,44,58,8],[22,27,33,25,68,4],[84,28,14,11,5,50]]\nOutput: [[5,17,4,1,52,7],[11,11,25,45,8,69],[14,23,25,44,58,15],[22,27,31,36,50,66],[84,28,75,33,55,68]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == mat.length
    • \n\t
  • n == mat[i].length
    • \n\t
  • 1 <= m, n <= 100
    • \n\t
  • 1 <= mat[i][j] <= 100
    • \n
\n
" }, { "path": "1329-sort-the-matrix-diagonally/SolutionCode.cpp", "content": "class Solution {\npublic:\n void sortIt(int r,int c,int m,int n,vector> &v){\n int i = r, j = c;\n vector a;\n while(i> diagonalSort(vector>& mat) {\n if(mat.size()==1) return mat;\n \n int m = mat.size(), n = mat[0].size();\n \n //0 row\n for(int col = 0;col1332. Remove Palindromic Subsequences

Easy

You are given a string s consisting only of letters 'a' and 'b'. In a single step you can remove one palindromic subsequence from s.

\n\n

Return the minimum number of steps to make the given string empty.

\n\n

A string is a subsequence of a given string if it is generated by deleting some characters of a given string without changing its order. Note that a subsequence does not necessarily need to be contiguous.

\n\n

A string is called palindrome if is one that reads the same backward as well as forward.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"ababa\"\nOutput: 1\nExplanation: s is already a palindrome, so its entirety can be removed in a single step.\n
\n\n

Example 2:

\n\n
Input: s = \"abb\"\nOutput: 2\nExplanation: \"abb\" -> \"bb\" -> \"\". \nRemove palindromic subsequence \"a\" then \"bb\".\n
\n\n

Example 3:

\n\n
Input: s = \"baabb\"\nOutput: 2\nExplanation: \"baabb\" -> \"b\" -> \"\". \nRemove palindromic subsequence \"baab\" then \"b\".\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 1000
    • \n\t
  • s[i] is either 'a' or 'b'.
    • \n
\n
" }, { "path": "1335-minimum-difficulty-of-a-job-schedule/1335-minimum-difficulty-of-a-job-schedule.java", "content": "class Solution {\n \n Integer[][] dp;\n int n;\n \n public int Helper(int idx, int[] arr, int d){\n \n if(idx == n && d == 0) return 0;\n if(n - idx < d) return (int)1e5; // only for optimization not necessary\n if(d < 0) return (int)1e5;\n\t\t\n if(dp[idx][d] != null) return dp[idx][d];\n \n int max = 0;\n int res = Integer.MAX_VALUE;\n \n for(int i = idx; i < n; ++i){\n max = Math.max(arr[i], max);\n res = Math.min(res, max + Helper(i + 1, arr, d - 1));\n }\n \n return dp[idx][d] = res;\n }\n \n public int minDifficulty(int[] jobDifficulty, int d) {\n this.n = jobDifficulty.length;\n\t\tthis.dp = new Integer[n][d + 1]; \n\t\t\n if(n < d) return -1;\n \n return Helper(0, jobDifficulty, d);\n }\n}" }, { "path": "1335-minimum-difficulty-of-a-job-schedule/NOTES.md", "content": "​" }, { "path": "1335-minimum-difficulty-of-a-job-schedule/README.md", "content": "

1335. Minimum Difficulty of a Job Schedule

Hard

You want to schedule a list of jobs in d days. Jobs are dependent (i.e To work on the ith job, you have to finish all the jobs j where 0 <= j < i).

\n\n

You have to finish at least one task every day. The difficulty of a job schedule is the sum of difficulties of each day of the d days. The difficulty of a day is the maximum difficulty of a job done on that day.

\n\n

You are given an integer array jobDifficulty and an integer d. The difficulty of the ith job is jobDifficulty[i].

\n\n

Return the minimum difficulty of a job schedule. If you cannot find a schedule for the jobs return -1.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: jobDifficulty = [6,5,4,3,2,1], d = 2\nOutput: 7\nExplanation: First day you can finish the first 5 jobs, total difficulty = 6.\nSecond day you can finish the last job, total difficulty = 1.\nThe difficulty of the schedule = 6 + 1 = 7 \n
\n\n

Example 2:

\n\n
Input: jobDifficulty = [9,9,9], d = 4\nOutput: -1\nExplanation: If you finish a job per day you will still have a free day. you cannot find a schedule for the given jobs.\n
\n\n

Example 3:

\n\n
Input: jobDifficulty = [1,1,1], d = 3\nOutput: 3\nExplanation: The schedule is one job per day. total difficulty will be 3.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= jobDifficulty.length <= 300
    • \n\t
  • 0 <= jobDifficulty[i] <= 1000
    • \n\t
  • 1 <= d <= 10
    • \n
\n
" }, { "path": "1337-the-k-weakest-rows-in-a-matrix/1337-the-k-weakest-rows-in-a-matrix.java", "content": "class Solution {\n public int[] kWeakestRows(int[][] mat, int k) {\n int[]ans=new int[k];\n int[][]freq=new int[mat.length][2];\n for(int i=0;io1[0]-o2[0]);\n for(int i=0;i1337. The K Weakest Rows in a Matrix

Easy

You are given an m x n binary matrix mat of 1's (representing soldiers) and 0's (representing civilians). The soldiers are positioned in front of the civilians. That is, all the 1's will appear to the left of all the 0's in each row.

\n\n

A row i is weaker than a row j if one of the following is true:

\n\n
    \n\t
  • The number of soldiers in row i is less than the number of soldiers in row j.
    • \n\t
  • Both rows have the same number of soldiers and i < j.
    • \n
\n\n

Return the indices of the k weakest rows in the matrix ordered from weakest to strongest.

\n\n

 

\n

Example 1:

\n\n
Input: mat = \n[[1,1,0,0,0],\n [1,1,1,1,0],\n [1,0,0,0,0],\n [1,1,0,0,0],\n [1,1,1,1,1]], \nk = 3\nOutput: [2,0,3]\nExplanation: \nThe number of soldiers in each row is: \n- Row 0: 2 \n- Row 1: 4 \n- Row 2: 1 \n- Row 3: 2 \n- Row 4: 5 \nThe rows ordered from weakest to strongest are [2,0,3,1,4].\n
\n\n

Example 2:

\n\n
Input: mat = \n[[1,0,0,0],\n [1,1,1,1],\n [1,0,0,0],\n [1,0,0,0]], \nk = 2\nOutput: [0,2]\nExplanation: \nThe number of soldiers in each row is: \n- Row 0: 1 \n- Row 1: 4 \n- Row 2: 1 \n- Row 3: 1 \nThe rows ordered from weakest to strongest are [0,2,3,1].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == mat.length
    • \n\t
  • n == mat[i].length
    • \n\t
  • 2 <= n, m <= 100
    • \n\t
  • 1 <= k <= m
    • \n\t
  • matrix[i][j] is either 0 or 1.
    • \n
\n
" }, { "path": "1338-reduce-array-size-to-the-half/1338-reduce-array-size-to-the-half.cpp", "content": "int minSetSize(vector& arr) {\n mapmp;\n \n for(int i=0;i>pq;\n \n for(auto it:mp)\n {\n pq.push({it.second,it.first});\n }\n \n int size=arr.size()/2;\n int count=0;\n \n while(size>0 && !pq.empty())\n {\n if(size pq=new PriorityQueue<>((a,b)->b.freq-a.freq);\n Map map=new HashMap<>();\n for(int i:arr){\n map.put(i,map.getOrDefault(i,0)+1);\n }\n for(Map.Entry entry : map.entrySet()){\n pq.add(new Pair(entry.getKey(),entry.getValue()));\n }\n \n int ans=0;\n int size=arr.length;\n int sz=arr.length;\n while(sz>size/2){\n ans++;\n Pair p=pq.remove();\n sz-=p.freq;\n }\n return ans;\n }\n}" }, { "path": "1338-reduce-array-size-to-the-half/README.md", "content": "

1338. Reduce Array Size to The Half

Medium

You are given an integer array arr. You can choose a set of integers and remove all the occurrences of these integers in the array.

\n\n

Return the minimum size of the set so that at least half of the integers of the array are removed.

\n\n

 

\n

Example 1:

\n\n
Input: arr = [3,3,3,3,5,5,5,2,2,7]\nOutput: 2\nExplanation: Choosing {3,7} will make the new array [5,5,5,2,2] which has size 5 (i.e equal to half of the size of the old array).\nPossible sets of size 2 are {3,5},{3,2},{5,2}.\nChoosing set {2,7} is not possible as it will make the new array [3,3,3,3,5,5,5] which has a size greater than half of the size of the old array.\n
\n\n

Example 2:

\n\n
Input: arr = [7,7,7,7,7,7]\nOutput: 1\nExplanation: The only possible set you can choose is {7}. This will make the new array empty.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= arr.length <= 105
    • \n\t
  • arr.length is even.
    • \n\t
  • 1 <= arr[i] <= 105
    • \n
\n
" }, { "path": "1339-maximum-product-of-splitted-binary-tree/1339-maximum-product-of-splitted-binary-tree.java", "content": "class Solution {\n int mod = 1000000007;\n long max = 0;\n long total;\n public int maxProduct(TreeNode root) {\n this.total = dfs(root);\n traverse(root);\n return (int)(max%mod);\n }\n \n private int dfs(TreeNode root)\n {\n if(root==null)\n return 0;\n return root.val += dfs(root.left) + dfs(root.right);\n }\n \n private void traverse(TreeNode root)\n {\n if(root==null)\n return;\n max = Math.max(root.val*(total-root.val),max);\n traverse(root.left);\n traverse(root.right);\n }\n}" }, { "path": "1339-maximum-product-of-splitted-binary-tree/NOTES.md", "content": "​" }, { "path": "1339-maximum-product-of-splitted-binary-tree/README.md", "content": "

1339. Maximum Product of Splitted Binary Tree

Medium

Given the root of a binary tree, split the binary tree into two subtrees by removing one edge such that the product of the sums of the subtrees is maximized.

\n\n

Return the maximum product of the sums of the two subtrees. Since the answer may be too large, return it modulo 109 + 7.

\n\n

Note that you need to maximize the answer before taking the mod and not after taking it.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,3,4,5,6]\nOutput: 110\nExplanation: Remove the red edge and get 2 binary trees with sum 11 and 10. Their product is 110 (11*10)\n
\n\n

Example 2:

\n\"\"\n
Input: root = [1,null,2,3,4,null,null,5,6]\nOutput: 90\nExplanation: Remove the red edge and get 2 binary trees with sum 15 and 6.Their product is 90 (15*6)\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [2, 5 * 104].
    • \n\t
  • 1 <= Node.val <= 104
    • \n
\n
" }, { "path": "1342-number-of-steps-to-reduce-a-number-to-zero/1342-number-of-steps-to-reduce-a-number-to-zero.java", "content": "class Solution {\n public int numberOfSteps(int num) {\n \n int count = 1;\n if(num == 0){return 0;}\n if( num / 2== 0 || num - 1 == 0){return count;}\n \n if(num % 2 == 0){ return count + numberOfSteps(num/2);}\n \n return count + numberOfSteps(num-1);\n \n }\n}" }, { "path": "1342-number-of-steps-to-reduce-a-number-to-zero/NOTES.md", "content": "​" }, { "path": "1342-number-of-steps-to-reduce-a-number-to-zero/README.md", "content": "

1342. Number of Steps to Reduce a Number to Zero

Easy

Given an integer num, return the number of steps to reduce it to zero.

\n\n

In one step, if the current number is even, you have to divide it by 2, otherwise, you have to subtract 1 from it.

\n\n

 

\n

Example 1:

\n\n
Input: num = 14\nOutput: 6\nExplanation: \nStep 1) 14 is even; divide by 2 and obtain 7. \nStep 2) 7 is odd; subtract 1 and obtain 6.\nStep 3) 6 is even; divide by 2 and obtain 3. \nStep 4) 3 is odd; subtract 1 and obtain 2. \nStep 5) 2 is even; divide by 2 and obtain 1. \nStep 6) 1 is odd; subtract 1 and obtain 0.\n
\n\n

Example 2:

\n\n
Input: num = 8\nOutput: 4\nExplanation: \nStep 1) 8 is even; divide by 2 and obtain 4. \nStep 2) 4 is even; divide by 2 and obtain 2. \nStep 3) 2 is even; divide by 2 and obtain 1. \nStep 4) 1 is odd; subtract 1 and obtain 0.\n
\n\n

Example 3:

\n\n
Input: num = 123\nOutput: 12\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= num <= 106
    • \n
\n
" }, { "path": "135-candy/135-candy.java", "content": "public class Solution {\n public int candy(int[] ratings) {\n int[] candies = new int[ratings.length];\n Arrays.fill(candies, 1);\n for (int i = 1; i < ratings.length; i++) {\n if (ratings[i] > ratings[i - 1]) {\n candies[i] = candies[i - 1] + 1;\n }\n }\n int sum = candies[ratings.length - 1];\n for (int i = ratings.length - 2; i >= 0; i--) {\n if (ratings[i] > ratings[i + 1]) {\n candies[i] = Math.max(candies[i], candies[i + 1] + 1);\n }\n sum += candies[i];\n }\n return sum;\n }\n}" }, { "path": "135-candy/NOTES.md", "content": "​" }, { "path": "135-candy/README.md", "content": "

135. Candy

Hard

There are n children standing in a line. Each child is assigned a rating value given in the integer array ratings.

\n\n

You are giving candies to these children subjected to the following requirements:

\n\n
    \n\t
  • Each child must have at least one candy.
    • \n\t
  • Children with a higher rating get more candies than their neighbors.
    • \n
\n\n

Return the minimum number of candies you need to have to distribute the candies to the children.

\n\n

 

\n

Example 1:

\n\n
Input: ratings = [1,0,2]\nOutput: 5\nExplanation: You can allocate to the first, second and third child with 2, 1, 2 candies respectively.\n
\n\n

Example 2:

\n\n
Input: ratings = [1,2,2]\nOutput: 4\nExplanation: You can allocate to the first, second and third child with 1, 2, 1 candies respectively.\nThe third child gets 1 candy because it satisfies the above two conditions.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == ratings.length
    • \n\t
  • 1 <= n <= 2 * 104
    • \n\t
  • 0 <= ratings[i] <= 2 * 104
    • \n
\n
" }, { "path": "1354-construct-target-array-with-multiple-sums/1354-construct-target-array-with-multiple-sums.java", "content": "class Solution {\n public boolean isPossible(int[] target) {\n long sum=0;\n int n=target.length;\n Queue pq=new PriorityQueue<>(Collections.reverseOrder());\n for(int i:target){\n sum+=i;\n pq.add(i);\n }\n while(sum!=n){\n int largest=pq.remove();\n sum-=largest;\n if(sum==1 || largest==1)return true;\n if(sum>largest || sum==0 || largest%sum==0)return false;\n largest%=sum;\n sum+=largest;\n pq.add(largest);\n }\n return true;\n }\n}" }, { "path": "1354-construct-target-array-with-multiple-sums/NOTES.md", "content": "​" }, { "path": "1354-construct-target-array-with-multiple-sums/README.md", "content": "

1354. Construct Target Array With Multiple Sums

Hard

You are given an array target of n integers. From a starting array arr consisting of n 1's, you may perform the following procedure :

\n\n
    \n\t
  • let x be the sum of all elements currently in your array.
    • \n\t
  • choose index i, such that 0 <= i < n and set the value of arr at index i to x.
    • \n\t
  • You may repeat this procedure as many times as needed.
    • \n
\n\n

Return true if it is possible to construct the target array from arr, otherwise, return false.

\n\n

 

\n

Example 1:

\n\n
Input: target = [9,3,5]\nOutput: true\nExplanation: Start with arr = [1, 1, 1] \n[1, 1, 1], sum = 3 choose index 1\n[1, 3, 1], sum = 5 choose index 2\n[1, 3, 5], sum = 9 choose index 0\n[9, 3, 5] Done\n
\n\n

Example 2:

\n\n
Input: target = [1,1,1,2]\nOutput: false\nExplanation: Impossible to create target array from [1,1,1,1].\n
\n\n

Example 3:

\n\n
Input: target = [8,5]\nOutput: true\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == target.length
    • \n\t
  • 1 <= n <= 5 * 104
    • \n\t
  • 1 <= target[i] <= 109
    • \n
\n
" }, { "path": "1379-find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/1379-find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\n\nclass Solution {\n TreeNode ans;\n TreeNode tar;\n public final TreeNode getTargetCopy(final TreeNode original, final TreeNode cloned, final TreeNode target) {\n tar=target;\n dfs(original,cloned);\n return ans;\n }\n public void dfs(TreeNode a,TreeNode b){\n if(a==null)return;\n if(a==tar){\n ans=b;\n return;\n }\n dfs(a.left,b.left);\n dfs(a.right,b.right);\n }\n}" }, { "path": "1379-find-a-corresponding-node-of-a-binary-tree-in-a-clone-of-that-tree/README.md", "content": "

1379. Find a Corresponding Node of a Binary Tree in a Clone of That Tree

Medium

Given two binary trees original and cloned and given a reference to a node target in the original tree.

\n\n

The cloned tree is a copy of the original tree.

\n\n

Return a reference to the same node in the cloned tree.

\n\n

Note that you are not allowed to change any of the two trees or the target node and the answer must be a reference to a node in the cloned tree.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: tree = [7,4,3,null,null,6,19], target = 3\nOutput: 3\nExplanation: In all examples the original and cloned trees are shown. The target node is a green node from the original tree. The answer is the yellow node from the cloned tree.\n
\n\n

Example 2:

\n\"\"\n
Input: tree = [7], target =  7\nOutput: 7\n
\n\n

Example 3:

\n\"\"\n
Input: tree = [8,null,6,null,5,null,4,null,3,null,2,null,1], target = 4\nOutput: 4\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 104].
    • \n\t
  • The values of the nodes of the tree are unique.
    • \n\t
  • target node is a node from the original tree and is not null.
    • \n
\n\n

 

\n

Follow up: Could you solve the problem if repeated values on the tree are allowed?

\n
" }, { "path": "1381. Design a Stack With Increment Operation/1381-Design-a-Stack-With-Increment-Operation.cpp", "content": "class CustomStack {\npublic:\n \n // 1.\n// stack st;\n// int n;\n// CustomStack(int maxSize){\n// n = maxSize;\n// }\n \n// void push(int x){\n// if(st.size() < n){\n// st.push(x);\n// }\n// }\n \n// int pop(){\n// int t = -1;\n// if(!st.empty()){\n// t = st.top();\n// st.pop(); \n// }\n// return t;\n// }\n \n// void increment(int k, int val){\n// stack ts;\n// int m;\n// if(k < st.size()){\n// m = st.size() - k;\n// for(int i=0;i stack, inc;\n int n;\n CustomStack(int maxSize) {\n n = maxSize;\n }\n\n void push(int x) {\n if (stack.size() == n) return;\n stack.push_back(x);\n inc.push_back(0);\n }\n\n // jo bhi ho raha hain pop function m ho raha hain\n int pop() {\n int i = stack.size() - 1;\n if (i < 0) return -1; // if stack is empty\n if (i > 0) inc[i - 1] += inc[i]; // here if we have added more to current then increment to the previous values too.\n // like in case of 5, 100 and again 2, 100\n // do dry run you will understand better.\n int res = stack[i] + inc[i];\n stack.pop_back();\n inc.pop_back();\n return res;\n }\n\n void increment(int k, int val) {\n int i = min(k, (int)stack.size()) - 1;\n if (i >= 0) inc[i] += val; // here comes the use of increment vector\n } \n};\n" }, { "path": "1383 Maximum Performance of a Team lc hard.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\n // TC: O(N * (logN + logK)) \n// SC: O(N + K)\n// where N = total number of candidates & K = size of team\npublic:\n int maxPerformance(int n, vector& speed, vector& efficiency, int k) {\n int MOD = 1e9 + 7;\n vector> candidates(n);\n // building pair { efficiency, speed } to sort it later\n for (int i = 0; i < n; i++) candidates[i] = { efficiency[i], speed[i] };\n // sort candidates in dsc\n sort(candidates.rbegin(), candidates.rend());\n // Using Example 1: \n // speed: [2, 10, 3, 1 ,5, 8] and efficiency: [5, 4, 3, 9, 7, 2]\n // after sort, it becomes\n // candidates: [{9, 1}, {7 ,5}, {5, 2}, {4, 10}, {3, 3}, {2, 8}]\n long speedSum = 0, ans = 0;\n // we use priority queue here with greater to store the sum\n // i.e min heap (the smallest element goes on the top)\n priority_queue , greater> pq;\n // iterate each pair\n for (auto& [e, s] : candidates) {\n // put the speed to priority queue\n pq.push(s);\n // add to speedSum\n speedSum += s;\n // we only need to choose at most k engineers\n // hence if the queue size is greater than k\n // we need to remove a candidate\n if (pq.size() > k) {\n // who to remove? of course the one with smallest speed\n speedSum -= pq.top();\n pq.pop();\n }\n // a team is formed now, calculate the performance\n ans = max(ans, speedSum * e);\n }\n return ans % MOD;\n }\n};" }, { "path": "1383-maximum-performance-of-a-team/1383-maximum-performance-of-a-team.java", "content": "class Solution {\n public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {\n int[][] players = new int[n][2];\n for (int i=0; i (p2[0] - p1[0]));\n\n\t\t// Priority-Queue to maintain players with highest relative speeds with efficiencies greater than the one under iteration.\n PriorityQueue speedQueue = new PriorityQueue<>(k);\n long teamPerformance = 0, teamSpeed = 0;\n\n for (int i=0; i= k) {\n teamSpeed -= speedQueue.remove();\n }\n speedQueue.add(players[i][1]);\n teamSpeed += players[i][1];\n\n teamPerformance = Math.max(teamPerformance, teamSpeed * players[i][0]);\n }\n return (int) (teamPerformance % 1000000007);\n }\n}" }, { "path": "1383-maximum-performance-of-a-team/README.md", "content": "

1383. Maximum Performance of a Team

Hard

You are given two integers n and k and two integer arrays speed and efficiency both of length n. There are n engineers numbered from 1 to n. speed[i] and efficiency[i] represent the speed and efficiency of the ith engineer respectively.

\n\n

Choose at most k different engineers out of the n engineers to form a team with the maximum performance.

\n\n

The performance of a team is the sum of their engineers' speeds multiplied by the minimum efficiency among their engineers.

\n\n

Return the maximum performance of this team. Since the answer can be a huge number, return it modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2\nOutput: 60\nExplanation: \nWe have the maximum performance of the team by selecting engineer 2 (with speed=10 and efficiency=4) and engineer 5 (with speed=5 and efficiency=7). That is, performance = (10 + 5) * min(4, 7) = 60.\n
\n\n

Example 2:

\n\n
Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3\nOutput: 68\nExplanation:\nThis is the same example as the first but k = 3. We can select engineer 1, engineer 2 and engineer 5 to get the maximum performance of the team. That is, performance = (2 + 10 + 5) * min(5, 4, 7) = 68.\n
\n\n

Example 3:

\n\n
Input: n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4\nOutput: 72\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= k <= n <= 105
    • \n\t
  • speed.length == n
    • \n\t
  • efficiency.length == n
    • \n\t
  • 1 <= speed[i] <= 105
    • \n\t
  • 1 <= efficiency[i] <= 108
    • \n
\n
" }, { "path": "1396-design-underground-system/1396-design-underground-system.java", "content": "class UndergroundSystem {\n class Pair{\n String place;\n int time;\n Pair(String p,int t){\n place=p;\n time=t;\n }\n }\n Map inMap;\n Map> map;\n public UndergroundSystem() {\n inMap=new HashMap<>();\n map=new HashMap<>();\n }\n \n public void checkIn(int id, String p, int t) {\n inMap.put(id,new Pair(p,t));\n }\n \n public void checkOut(int id, String stationName, int t) {\n Pair pair=inMap.get(id);\n String start=pair.place;\n int inTime=pair.time;\n String route=start+\"-\"+stationName;\n int avgTime=t-inTime;\n if(map.containsKey(route)){\n ArrayList arr=map.get(route);\n arr.add(avgTime);\n map.put(route,arr);\n }else{\n ArrayList arr=new ArrayList<>();\n arr.add(avgTime);\n map.put(route,arr);\n }\n }\n \n public double getAverageTime(String start, String end) {\n String route=start+\"-\"+end;\n ArrayList arr=map.get(route);\n int len=arr.size();\n double sum=0;\n for(int i:arr){\n sum+=i;\n }\n return sum/len;\n }\n}\n\n/**\n * Your UndergroundSystem object will be instantiated and called as such:\n * UndergroundSystem obj = new UndergroundSystem();\n * obj.checkIn(id,stationName,t);\n * obj.checkOut(id,stationName,t);\n * double param_3 = obj.getAverageTime(startStation,endStation);\n */" }, { "path": "1396-design-underground-system/NOTES.md", "content": "​" }, { "path": "1396-design-underground-system/README.md", "content": "

1396. Design Underground System

Medium

An underground railway system is keeping track of customer travel times between different stations. They are using this data to calculate the average time it takes to travel from one station to another.

\n\n

Implement the UndergroundSystem class:

\n\n
    \n\t
  • void checkIn(int id, string stationName, int t)\n\n\t
      \n\t\t
    • A customer with a card ID equal to id, checks in at the station stationName at time t.
      • \n\t\t
    • A customer can only be checked into one place at a time.
      • \n\t
    \n\t
    • \n\t
  • void checkOut(int id, string stationName, int t)\n\t
      \n\t\t
    • A customer with a card ID equal to id, checks out from the station stationName at time t.
      • \n\t
    \n\t
    • \n\t
  • double getAverageTime(string startStation, string endStation)\n\t
      \n\t\t
    • Returns the average time it takes to travel from startStation to endStation.
      • \n\t\t
    • The average time is computed from all the previous traveling times from startStation to endStation that happened directly, meaning a check in at startStation followed by a check out from endStation.
      • \n\t\t
    • The time it takes to travel from startStation to endStation may be different from the time it takes to travel from endStation to startStation.
      • \n\t\t
    • There will be at least one customer that has traveled from startStation to endStation before getAverageTime is called.
      • \n\t
    \n\t
    • \n
\n\n

You may assume all calls to the checkIn and checkOut methods are consistent. If a customer checks in at time t1 then checks out at time t2, then t1 < t2. All events happen in chronological order.

\n\n

 

\n

Example 1:

\n\n
Input\n[\"UndergroundSystem\",\"checkIn\",\"checkIn\",\"checkIn\",\"checkOut\",\"checkOut\",\"checkOut\",\"getAverageTime\",\"getAverageTime\",\"checkIn\",\"getAverageTime\",\"checkOut\",\"getAverageTime\"]\n[[],[45,\"Leyton\",3],[32,\"Paradise\",8],[27,\"Leyton\",10],[45,\"Waterloo\",15],[27,\"Waterloo\",20],[32,\"Cambridge\",22],[\"Paradise\",\"Cambridge\"],[\"Leyton\",\"Waterloo\"],[10,\"Leyton\",24],[\"Leyton\",\"Waterloo\"],[10,\"Waterloo\",38],[\"Leyton\",\"Waterloo\"]]\n\nOutput\n[null,null,null,null,null,null,null,14.00000,11.00000,null,11.00000,null,12.00000]\n\nExplanation\nUndergroundSystem undergroundSystem = new UndergroundSystem();\nundergroundSystem.checkIn(45, \"Leyton\", 3);\nundergroundSystem.checkIn(32, \"Paradise\", 8);\nundergroundSystem.checkIn(27, \"Leyton\", 10);\nundergroundSystem.checkOut(45, \"Waterloo\", 15);  // Customer 45 \"Leyton\" -> \"Waterloo\" in 15-3 = 12\nundergroundSystem.checkOut(27, \"Waterloo\", 20);  // Customer 27 \"Leyton\" -> \"Waterloo\" in 20-10 = 10\nundergroundSystem.checkOut(32, \"Cambridge\", 22); // Customer 32 \"Paradise\" -> \"Cambridge\" in 22-8 = 14\nundergroundSystem.getAverageTime(\"Paradise\", \"Cambridge\"); // return 14.00000. One trip \"Paradise\" -> \"Cambridge\", (14) / 1 = 14\nundergroundSystem.getAverageTime(\"Leyton\", \"Waterloo\");    // return 11.00000. Two trips \"Leyton\" -> \"Waterloo\", (10 + 12) / 2 = 11\nundergroundSystem.checkIn(10, \"Leyton\", 24);\nundergroundSystem.getAverageTime(\"Leyton\", \"Waterloo\");    // return 11.00000\nundergroundSystem.checkOut(10, \"Waterloo\", 38);  // Customer 10 \"Leyton\" -> \"Waterloo\" in 38-24 = 14\nundergroundSystem.getAverageTime(\"Leyton\", \"Waterloo\");    // return 12.00000. Three trips \"Leyton\" -> \"Waterloo\", (10 + 12 + 14) / 3 = 12\n
\n\n

Example 2:

\n\n
Input\n[\"UndergroundSystem\",\"checkIn\",\"checkOut\",\"getAverageTime\",\"checkIn\",\"checkOut\",\"getAverageTime\",\"checkIn\",\"checkOut\",\"getAverageTime\"]\n[[],[10,\"Leyton\",3],[10,\"Paradise\",8],[\"Leyton\",\"Paradise\"],[5,\"Leyton\",10],[5,\"Paradise\",16],[\"Leyton\",\"Paradise\"],[2,\"Leyton\",21],[2,\"Paradise\",30],[\"Leyton\",\"Paradise\"]]\n\nOutput\n[null,null,null,5.00000,null,null,5.50000,null,null,6.66667]\n\nExplanation\nUndergroundSystem undergroundSystem = new UndergroundSystem();\nundergroundSystem.checkIn(10, \"Leyton\", 3);\nundergroundSystem.checkOut(10, \"Paradise\", 8); // Customer 10 \"Leyton\" -> \"Paradise\" in 8-3 = 5\nundergroundSystem.getAverageTime(\"Leyton\", \"Paradise\"); // return 5.00000, (5) / 1 = 5\nundergroundSystem.checkIn(5, \"Leyton\", 10);\nundergroundSystem.checkOut(5, \"Paradise\", 16); // Customer 5 \"Leyton\" -> \"Paradise\" in 16-10 = 6\nundergroundSystem.getAverageTime(\"Leyton\", \"Paradise\"); // return 5.50000, (5 + 6) / 2 = 5.5\nundergroundSystem.checkIn(2, \"Leyton\", 21);\nundergroundSystem.checkOut(2, \"Paradise\", 30); // Customer 2 \"Leyton\" -> \"Paradise\" in 30-21 = 9\nundergroundSystem.getAverageTime(\"Leyton\", \"Paradise\"); // return 6.66667, (5 + 6 + 9) / 3 = 6.66667\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= id, t <= 106
    • \n\t
  • 1 <= stationName.length, startStation.length, endStation.length <= 10
    • \n\t
  • All strings consist of uppercase and lowercase English letters and digits.
    • \n\t
  • There will be at most 2 * 104 calls in total to checkIn, checkOut, and getAverageTime.
    • \n\t
  • Answers within 10-5 of the actual value will be accepted.
    • \n
\n
" }, { "path": "14. Longest Common Prefix.py", "content": " def longestCommonPrefix(self, strs: List[str]) -> str:\n sub = \"\"\n counter = 0\n for i in range(len(strs[0])):\n for j in range(len(strs)):\n if len(strs[j]) <= i:\n return sub\n if strs[j][i] == strs[0][i]:\n counter += 1\n \n if counter == len(strs):\n sub += strs[0][i]\n counter = 0\n else:\n return sub\n return sub\n \n \n" }, { "path": "1423-maximum-points-you-can-obtain-from-cards/1423-maximum-points-you-can-obtain-from-cards.java", "content": "class Solution {\n public int maxScore(int[] cardPoints, int k) {\n int n = cardPoints.length, l= 0, r = n - k ;\n \n int total = 0;\n for (int i = r; i1423. Maximum Points You Can Obtain from Cards

Medium

There are several cards arranged in a row, and each card has an associated number of points. The points are given in the integer array cardPoints.

\n\n

In one step, you can take one card from the beginning or from the end of the row. You have to take exactly k cards.

\n\n

Your score is the sum of the points of the cards you have taken.

\n\n

Given the integer array cardPoints and the integer k, return the maximum score you can obtain.

\n\n

 

\n

Example 1:

\n\n
Input: cardPoints = [1,2,3,4,5,6,1], k = 3\nOutput: 12\nExplanation: After the first step, your score will always be 1. However, choosing the rightmost card first will maximize your total score. The optimal strategy is to take the three cards on the right, giving a final score of 1 + 6 + 5 = 12.\n
\n\n

Example 2:

\n\n
Input: cardPoints = [2,2,2], k = 2\nOutput: 4\nExplanation: Regardless of which two cards you take, your score will always be 4.\n
\n\n

Example 3:

\n\n
Input: cardPoints = [9,7,7,9,7,7,9], k = 7\nOutput: 55\nExplanation: You have to take all the cards. Your score is the sum of points of all cards.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= cardPoints.length <= 105
    • \n\t
  • 1 <= cardPoints[i] <= 104
    • \n\t
  • 1 <= k <= cardPoints.length
    • \n
\n
" }, { "path": "143-Reorder List.java", "content": "// Runtime: 11 ms, faster than 10.15% of Java online submissions for Reorder List.\n// Memory Usage: 54.4 MB, less than 29.31% of Java online submissions for Reorder List.\nclass Solution {\n public void reorderList(ListNode head) {\n ListNode curr = head;\n \n Stack s = new Stack<>();\n\n while(curr != null) {\n s.push(curr);\n curr = curr.next;\n }\n curr = head;\n int n = s.size();\n if(n<=2) return;\n ListNode next;\n for(int i = 0; i < n/2; i++) {\n next = curr.next;\n curr.next = s.peek();\n s.pop();\n curr = curr.next;\n curr.next = next;\n curr = curr.next;\n }\n curr.next = null;\n }\n}\n" }, { "path": "1443-minimum-time-to-collect-all-apples-in-a-tree/1443-minimum-time-to-collect-all-apples-in-a-tree.java", "content": "class Solution {\n public int dfs(int node, int parent, Map> adj,\n List hasApple) {\n if (!adj.containsKey(node))\n return 0;\n\n int totalTime = 0, childTime = 0;\n for (int child : adj.get(node)) {\n if (child == parent)\n continue;\n childTime = dfs(child, node, adj, hasApple);\n // childTime > 0 indicates subtree of child has apples. Since the root node of the\n // subtree does not contribute to the time, even if it has an apple, we have to check it\n // independently.\n if (childTime > 0 || hasApple.get(child))\n totalTime += childTime + 2;\n }\n return totalTime;\n }\n\n public int minTime(int n, int[][] edges, List hasApple) {\n Map> adj = new HashMap<>();\n for (int[] edge : edges) {\n int a = edge[0], b = edge[1];\n adj.computeIfAbsent(a, value -> new ArrayList()).add(b);\n adj.computeIfAbsent(b, value -> new ArrayList()).add(a);\n }\n return dfs(0, -1, adj, hasApple);\n }\n}" }, { "path": "1443-minimum-time-to-collect-all-apples-in-a-tree/README.md", "content": "

1443. Minimum Time to Collect All Apples in a Tree

Medium

Given an undirected tree consisting of n vertices numbered from 0 to n-1, which has some apples in their vertices. You spend 1 second to walk over one edge of the tree. Return the minimum time in seconds you have to spend to collect all apples in the tree, starting at vertex 0 and coming back to this vertex.

\n\n

The edges of the undirected tree are given in the array edges, where edges[i] = [ai, bi] means that exists an edge connecting the vertices ai and bi. Additionally, there is a boolean array hasApple, where hasApple[i] = true means that vertex i has an apple; otherwise, it does not have any apple.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,true,true,false]\nOutput: 8 \nExplanation: The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  \n
\n\n

Example 2:

\n\"\"\n
Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,true,false,false,true,false]\nOutput: 6\nExplanation: The figure above represents the given tree where red vertices have an apple. One optimal path to collect all apples is shown by the green arrows.  \n
\n\n

Example 3:

\n\n
Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], hasApple = [false,false,false,false,false,false,false]\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 105
    • \n\t
  • edges.length == n - 1
    • \n\t
  • edges[i].length == 2
    • \n\t
  • 0 <= ai < bi <= n - 1
    • \n\t
  • fromi < toi
    • \n\t
  • hasApple.length == n
    • \n
\n
" }, { "path": "1448-count-good-nodes-in-binary-tree/1448-count-good-nodes-in-binary-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n \n int count;\n public int goodNodes(TreeNode root) {\n \n if(root.left==null && root.right==null ){\n return 1;\n }\n \n count=0;\n int curr=root.val;\n \n helper(root,curr);\n \n return count;\n }\n \n public void helper(TreeNode root,int curr){\n \n if(root==null)\n return;\n \n if(root.val>=curr){\n count++;\n curr=root.val;\n }\n \n helper(root.left,curr);\n helper(root.right,curr);\n }\n}" }, { "path": "1448-count-good-nodes-in-binary-tree/NOTES.md", "content": "​" }, { "path": "1448-count-good-nodes-in-binary-tree/README.md", "content": "

1448. Count Good Nodes in Binary Tree

Medium

Given a binary tree root, a node X in the tree is named good if in the path from root to X there are no nodes with a value greater than X.

\n\n

Return the number of good nodes in the binary tree.

\n\n

 

\n

Example 1:

\n\n

\"\"

\n\n
Input: root = [3,1,4,3,null,1,5]\nOutput: 4\nExplanation: Nodes in blue are good.\nRoot Node (3) is always a good node.\nNode 4 -> (3,4) is the maximum value in the path starting from the root.\nNode 5 -> (3,4,5) is the maximum value in the path\nNode 3 -> (3,1,3) is the maximum value in the path.
\n\n

Example 2:

\n\n

\"\"

\n\n
Input: root = [3,3,null,4,2]\nOutput: 3\nExplanation: Node 2 -> (3, 3, 2) is not good, because \"3\" is higher than it.
\n\n

Example 3:

\n\n
Input: root = [1]\nOutput: 1\nExplanation: Root is considered as good.
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the binary tree is in the range [1, 10^5].
    • \n\t
  • Each node's value is between [-10^4, 10^4].
    • \n
\n" }, { "path": "1457 Pseudo-Palindromic Paths in a Binary Tree lc.cpp", "content": "class Solution {\npublic:\n vector a; //map count nodes with same value\n int ans; // store ans\n bool checkPalin(){\n int cnt=0;\n for(int i=1;i<10;i++){ \n if(a[i]&1){\n cnt++;\n }\n }\n if(cnt>1) return false;\n else return true;\n }\n void solve(TreeNode *root){\n if(!root) return;\n if(!root->left && !root->right){\n a[root->val]++;\n if(checkPalin()) ans++;\n a[root->val]--;\n \n return ;\n }\n a[root->val]++;\n solve(root->left);\n solve(root->right);\n a[root->val]--;\n }\n int pseudoPalindromicPaths (TreeNode* root) {\n ans=0;\n a.resize(10,0);\n solve(root);\n return ans;\n }\n};" }, { "path": "1457-pseudo-palindromic-paths-in-a-binary-tree/1457-pseudo-palindromic-paths-in-a-binary-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n int ans;\n public int pseudoPalindromicPaths (TreeNode root) {\n int[] freq=new int[10];\n ans=0;\n dfs(root,freq);\n return ans;\n }\n void dfs(TreeNode root,int[]freq){\n if(root.left==null && root.right==null){\n freq[root.val]++;\n boolean odd=false;\n for(int i=0;i<10;i++){\n if(freq[i]%2!=0){\n if(!odd){\n odd=true;\n }else{\n freq[root.val]--;\n return;\n }\n }\n }\n ans++;\n freq[root.val]--;\n return;\n }\n freq[root.val]++;\n if(root.left!=null)dfs(root.left,freq);\n if(root.right!=null)dfs(root.right,freq);\n freq[root.val]--;\n }\n}" }, { "path": "1457-pseudo-palindromic-paths-in-a-binary-tree/README.md", "content": "

1457. Pseudo-Palindromic Paths in a Binary Tree

Medium

Given a binary tree where node values are digits from 1 to 9. A path in the binary tree is said to be pseudo-palindromic if at least one permutation of the node values in the path is a palindrome.

\n\n

Return the number of pseudo-palindromic paths going from the root node to leaf nodes.

\n\n

 

\n

Example 1:

\n\n

\"\"

\n\n
Input: root = [2,3,1,3,1,null,1]\nOutput: 2 \nExplanation: The figure above represents the given binary tree. There are three paths going from the root node to leaf nodes: the red path [2,3,3], the green path [2,1,1], and the path [2,3,1]. Among these paths only red path and green path are pseudo-palindromic paths since the red path [2,3,3] can be rearranged in [3,2,3] (palindrome) and the green path [2,1,1] can be rearranged in [1,2,1] (palindrome).\n
\n\n

Example 2:

\n\n

\"\"

\n\n
Input: root = [2,1,1,1,3,null,null,null,null,null,1]\nOutput: 1 \nExplanation: The figure above represents the given binary tree. There are three paths going from the root node to leaf nodes: the green path [2,1,1], the path [2,1,3,1], and the path [2,1]. Among these paths only the green path is pseudo-palindromic since [2,1,1] can be rearranged in [1,2,1] (palindrome).\n
\n\n

Example 3:

\n\n
Input: root = [9]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 105].
    • \n\t
  • 1 <= Node.val <= 9
    • \n
\n
" }, { "path": "1461-check-if-a-string-contains-all-binary-codes-of-size-k/1461-check-if-a-string-contains-all-binary-codes-of-size-k.java", "content": "class Solution {\n public static boolean hasAllCodes(String s, int k) {\n int need = 1 << k;\n boolean[] got = new boolean[need];\n int allOne = need - 1;\n int hashVal = 0;\n\n for (int i = 0; i < s.length(); i++) {\n // calculate hash for s.substr(i-k+1,i+1)\n hashVal = ((hashVal << 1) & allOne) | (s.charAt(i) - '0');\n // hash only available when i-k+1 > 0\n if (i >= k - 1 && !got[hashVal]) {\n got[hashVal] = true;\n need--;\n if (need == 0) {\n return true;\n }\n }\n }\n return false;\n }\n}" }, { "path": "1461-check-if-a-string-contains-all-binary-codes-of-size-k/NOTES.md", "content": "​" }, { "path": "1461-check-if-a-string-contains-all-binary-codes-of-size-k/README.md", "content": "

1461. Check If a String Contains All Binary Codes of Size K

Medium

Given a binary string s and an integer k, return true if every binary code of length k is a substring of s. Otherwise, return false.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"00110110\", k = 2\nOutput: true\nExplanation: The binary codes of length 2 are \"00\", \"01\", \"10\" and \"11\". They can be all found as substrings at indices 0, 1, 3 and 2 respectively.\n
\n\n

Example 2:

\n\n
Input: s = \"0110\", k = 1\nOutput: true\nExplanation: The binary codes of length 1 are \"0\" and \"1\", it is clear that both exist as a substring. \n
\n\n

Example 3:

\n\n
Input: s = \"0110\", k = 2\nOutput: false\nExplanation: The binary code \"00\" is of length 2 and does not exist in the array.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 5 * 105
    • \n\t
  • s[i] is either '0' or '1'.
    • \n\t
  • 1 <= k <= 20
    • \n
\n
" }, { "path": "1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.java", "content": "class Solution {\n public int maxArea(int h, int w, int[] hc, int[] vc) {\n return (int)((getMax(h,hc)*getMax(w,vc))%1000000007);\n }\n public long getMax(int len,int[] cuts){\n Arrays.sort(cuts);\n long from=0,max=0;\n for(int c:cuts){\n max=Math.max(max,c-from);\n from=c;\n }\n return Math.max(max,len-from);\n }\n}" }, { "path": "1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/NOTES.md", "content": "​" }, { "path": "1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts/README.md", "content": "

1465. Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts

Medium

You are given a rectangular cake of size h x w and two arrays of integers horizontalCuts and verticalCuts where:

\n\n
    \n\t
  • horizontalCuts[i] is the distance from the top of the rectangular cake to the ith horizontal cut and similarly, and
    • \n\t
  • verticalCuts[j] is the distance from the left of the rectangular cake to the jth vertical cut.
    • \n
\n\n

Return the maximum area of a piece of cake after you cut at each horizontal and vertical position provided in the arrays horizontalCuts and verticalCuts. Since the answer can be a large number, return this modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3]\nOutput: 4 \nExplanation: The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green piece of cake has the maximum area.\n
\n\n

Example 2:

\n\"\"\n
Input: h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1]\nOutput: 6\nExplanation: The figure above represents the given rectangular cake. Red lines are the horizontal and vertical cuts. After you cut the cake, the green and yellow pieces of cake have the maximum area.\n
\n\n

Example 3:

\n\n
Input: h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3]\nOutput: 9\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= h, w <= 109
    • \n\t
  • 1 <= horizontalCuts.length <= min(h - 1, 105)
    • \n\t
  • 1 <= verticalCuts.length <= min(w - 1, 105)
    • \n\t
  • 1 <= horizontalCuts[i] < h
    • \n\t
  • 1 <= verticalCuts[i] < w
    • \n\t
  • All the elements in horizontalCuts are distinct.
    • \n\t
  • All the elements in verticalCuts are distinct.
    • \n
\n
" }, { "path": "1473-paint-house-iii/1473-paint-house-iii.java", "content": "class Solution {\n \n static final int MAX_COST = 1000001;\n \n public int minCost(int[] houses, int[][] cost, int m, int n, int target) {\n // dp(i, j, k): house, color, group\n int[][][] dp = new int[m][n][target]; \n \n for (int i = 0; i < m; i++) {\n for (int j = 0; j < n; j++) {\n for (int k = 0; k < target; k++) {\n dp[i][j][k] = MAX_COST;\n }\n }\n }\n \n if (houses[0] == 0) {\n for (int j = 0; j < n; j++) {\n dp[0][j][target - 1] = cost[0][j];\n } \n } else {\n int j = houses[0] - 1;\n dp[0][j][target - 1] = 0;\n }\n \n \n int lr = target - 1;\n \n for (int i = 1; i < m; i++) {\n int hr = m - i;\n if (hr >= target) {\n hr = target - 1;\n }\n \n if (houses[i] > 0) {\n int j = houses[i] - 1;\n for (int remaining = hr; remaining >= lr; remaining--) {\n // not change\n dp[i][j][remaining] = Math.min(dp[i][j][remaining], dp[i - 1][j][remaining]);\n \n // change\n if (houses[i - 1] > 0 && houses[i - 1] - 1 != j) {\n dp[i][j][remaining - 1] = Math.min(dp[i][j][remaining - 1], dp[i - 1][houses[i - 1] - 1][remaining]);\n } else {\n dp[i][j][remaining - 1] = Math.min(dp[i][j][remaining - 1], min(dp[i - 1], j, remaining));\n }\n }\n \n if (lr == 1) {\n dp[i][j][0] = Math.min(dp[i][j][0], dp[i - 1][j][0]);\n }\n } else {\n for (int j = 0; j < n; j++) {\n for (int remaining = hr; remaining >= lr; remaining--) {\n // not change\n int a = dp[i - 1][j][remaining];\n int b = cost[i][j];\n dp[i][j][remaining] = Math.min(dp[i][j][remaining], dp[i - 1][j][remaining] + cost[i][j]);\n\n // change\n if (houses[i - 1] > 0 && houses[i - 1] - 1 != j) {\n dp[i][j][remaining - 1] = Math.min(dp[i][j][remaining - 1], dp[i - 1][houses[i - 1] - 1][remaining] + cost[i][j]);\n } else {\n dp[i][j][remaining - 1] = Math.min(dp[i][j][remaining - 1], min(dp[i - 1], j, remaining) + cost[i][j]);\n }\n }\n\n if (lr == 1) {\n dp[i][j][0] = Math.min(dp[i][j][0], dp[i - 1][j][0] + cost[i][j]);\n }\n }\n }\n \n if (lr > 1) {\n lr--;\n }\n }\n \n int min = dp[m - 1][0][0];\n for (int j = 1; j < n; j++) {\n if (dp[m - 1][j][0] < min) {\n min = dp[m - 1][j][0];\n }\n }\n\n return min < MAX_COST ? min : -1;\n }\n \n private int min(int[][] minCost, int j, int remaining) {\n int min = Integer.MAX_VALUE;\n for (int k = 0; k < minCost.length; k++) {\n if (k != j && minCost[k][remaining] < min) {\n min = minCost[k][remaining];\n }\n }\n \n return min;\n }\n \n}" }, { "path": "1473-paint-house-iii/NOTES.md", "content": "​" }, { "path": "1473-paint-house-iii/README.md", "content": "

1473. Paint House III

Hard

There is a row of m houses in a small city, each house must be painted with one of the n colors (labeled from 1 to n), some houses that have been painted last summer should not be painted again.

\n\n

A neighborhood is a maximal group of continuous houses that are painted with the same color.

\n\n
    \n\t
  • For example: houses = [1,2,2,3,3,2,1,1] contains 5 neighborhoods [{1}, {2,2}, {3,3}, {2}, {1,1}].
    • \n
\n\n

Given an array houses, an m x n matrix cost and an integer target where:

\n\n
    \n\t
  • houses[i]: is the color of the house i, and 0 if the house is not painted yet.
    • \n\t
  • cost[i][j]: is the cost of paint the house i with the color j + 1.
    • \n
\n\n

Return the minimum cost of painting all the remaining houses in such a way that there are exactly target neighborhoods. If it is not possible, return -1.

\n\n

 

\n

Example 1:

\n\n
Input: houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3\nOutput: 9\nExplanation: Paint houses of this way [1,2,2,1,1]\nThis array contains target = 3 neighborhoods, [{1}, {2,2}, {1,1}].\nCost of paint all houses (1 + 1 + 1 + 1 + 5) = 9.\n
\n\n

Example 2:

\n\n
Input: houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3\nOutput: 11\nExplanation: Some houses are already painted, Paint the houses of this way [2,2,1,2,2]\nThis array contains target = 3 neighborhoods, [{2,2}, {1}, {2,2}]. \nCost of paint the first and last house (10 + 1) = 11.\n
\n\n

Example 3:

\n\n
Input: houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3\nOutput: -1\nExplanation: Houses are already painted with a total of 4 neighborhoods [{3},{1},{2},{3}] different of target = 3.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == houses.length == cost.length
    • \n\t
  • n == cost[i].length
    • \n\t
  • 1 <= m <= 100
    • \n\t
  • 1 <= n <= 20
    • \n\t
  • 1 <= target <= m
    • \n\t
  • 0 <= houses[i] <= n
    • \n\t
  • 1 <= cost[i][j] <= 104
    • \n
\n
" }, { "path": "1480-running-sum-of-1d-array/1480-running-sum-of-1d-array.java", "content": "class Solution {\n public int[] runningSum(int[] nums) {\n for(int i=1;i1480. Running Sum of 1d Array

Easy

Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i]).

\n\n

Return the running sum of nums.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3,4]\nOutput: [1,3,6,10]\nExplanation: Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].
\n\n

Example 2:

\n\n
Input: nums = [1,1,1,1,1]\nOutput: [1,2,3,4,5]\nExplanation: Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].
\n\n

Example 3:

\n\n
Input: nums = [3,1,2,10,1]\nOutput: [3,4,6,16,17]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 1000
    • \n\t
  • -10^6 <= nums[i] <= 10^6
    • \n
" }, { "path": "15. 3Sum/SolutionCode.cpp", "content": "class Solution {\npublic:\n vector> threeSum(vector& nums) {\n set> s;\n \n sort(nums.begin(), nums.end());\n int n = nums.size();\n \n if(nums[0]==0 && nums[n-1]==0){\n return {{0,0,0}};\n }\n \n for(int i=0; i< n-2; i++){\n int l = i + 1, r = n - 1;\n \n while(l < r){\n int sum = nums[i] + nums[l] + nums[r];\n \n if(sum == 0){ \n s.insert({nums[i], nums[l], nums[r]});\n l++;\n }else if(sum<0){\n l++;\n }else{\n r--;\n }\n }\n }\n \n vector> v;\n \n for(auto i = s.begin(); i!=s.end(); i++){\n v.push_back(*i);\n }\n \n return v;\n }\n};\n\n\n// Second Better Approach : \n\nclass Solution {\npublic:\n vector> threeSum(vector& nums) {\n sort(nums.begin(), nums.end());\n vector> res;\n for (unsigned int i=0; i0) && (nums[i]==nums[i-1]))\n continue;\n int l = i+1, r = nums.size()-1;\n while (l0) r--;\n else if (s<0) l++;\n else {\n res.push_back(vector {nums[i], nums[l], nums[r]});\n while (l < r && nums[l]==nums[l+1]) l++;\n while (l < r && nums[r]==nums[r-1]) r--;\n l++; r--;\n }\n }\n }\n return res;\n }\n};\n" }, { "path": "151. Reverse Words in a String.java", "content": "//151. Reverse Words in a String Leetcode\nclass Solution {\n public String reverseWords(String s) {\n int len = s.length();\n String k = \"\", a = \"\";\n\n for (int i = len - 1; i >= 0; i--) {\n char currentChar = s.charAt(i);\n if (currentChar != ' ' && currentChar != '.' && currentChar != ',') {\n k = currentChar + k;\n } else {\n if (!k.isEmpty()) {\n a += (a.isEmpty() ? \"\" : \" \") + k;\n k = \"\";\n }\n }\n }\n\n if (!k.isEmpty()) {\n a += (a.isEmpty() ? \"\" : \" \") + k;\n }\n\n return a;\n }\n}\n" }, { "path": "1519-number-of-nodes-in-the-sub-tree-with-the-same-label/1519-number-of-nodes-in-the-sub-tree-with-the-same-label.java", "content": "class Solution {\n public int[] dfs(int node, int parent, Map> adj,\n char[] labels, int[] ans) {\n // Store count of all alphabets in the subtree of the node.\n int[] nodeCounts = new int[26];\n nodeCounts[labels[node] - 'a'] = 1;\n\n if (!adj.containsKey(node))\n return nodeCounts;\n for (int child : adj.get(node)) {\n if (child == parent) {\n continue;\n }\n int[] childCounts = dfs(child, node, adj, labels, ans);\n // Add frequencies of the child node in the parent node's frequency array.\n for (int i = 0; i < 26; i++) {\n nodeCounts[i] += childCounts[i];\n }\n }\n\n ans[node] = nodeCounts[labels[node] - 'a'];\n return nodeCounts;\n }\n\n public int[] countSubTrees(int n, int[][] edges, String labels) {\n Map> adj = new HashMap<>();\n for (int[] edge : edges) {\n int a = edge[0], b = edge[1];\n adj.computeIfAbsent(a, value -> new ArrayList()).add(b);\n adj.computeIfAbsent(b, value -> new ArrayList()).add(a);\n }\n\n int[] ans = new int[n];\n char[] label = labels.toCharArray();\n dfs(0, -1, adj, label, ans);\n return ans;\n }\n}" }, { "path": "1519-number-of-nodes-in-the-sub-tree-with-the-same-label/NOTES.md", "content": "​" }, { "path": "1519-number-of-nodes-in-the-sub-tree-with-the-same-label/README.md", "content": "

1519. Number of Nodes in the Sub-Tree With the Same Label

Medium

You are given a tree (i.e. a connected, undirected graph that has no cycles) consisting of n nodes numbered from 0 to n - 1 and exactly n - 1 edges. The root of the tree is the node 0, and each node of the tree has a label which is a lower-case character given in the string labels (i.e. The node with the number i has the label labels[i]).

\n\n

The edges array is given on the form edges[i] = [ai, bi], which means there is an edge between nodes ai and bi in the tree.

\n\n

Return an array of size n where ans[i] is the number of nodes in the subtree of the ith node which have the same label as node i.

\n\n

A subtree of a tree T is the tree consisting of a node in T and all of its descendant nodes.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 7, edges = [[0,1],[0,2],[1,4],[1,5],[2,3],[2,6]], labels = \"abaedcd\"\nOutput: [2,1,1,1,1,1,1]\nExplanation: Node 0 has label 'a' and its sub-tree has node 2 with label 'a' as well, thus the answer is 2. Notice that any node is part of its sub-tree.\nNode 1 has a label 'b'. The sub-tree of node 1 contains nodes 1,4 and 5, as nodes 4 and 5 have different labels than node 1, the answer is just 1 (the node itself).\n
\n\n

Example 2:

\n\"\"\n
Input: n = 4, edges = [[0,1],[1,2],[0,3]], labels = \"bbbb\"\nOutput: [4,2,1,1]\nExplanation: The sub-tree of node 2 contains only node 2, so the answer is 1.\nThe sub-tree of node 3 contains only node 3, so the answer is 1.\nThe sub-tree of node 1 contains nodes 1 and 2, both have label 'b', thus the answer is 2.\nThe sub-tree of node 0 contains nodes 0, 1, 2 and 3, all with label 'b', thus the answer is 4.\n
\n\n

Example 3:

\n\"\"\n
Input: n = 5, edges = [[0,1],[0,2],[1,3],[0,4]], labels = \"aabab\"\nOutput: [3,2,1,1,1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 105
    • \n\t
  • edges.length == n - 1
    • \n\t
  • edges[i].length == 2
    • \n\t
  • 0 <= ai, bi < n
    • \n\t
  • ai != bi
    • \n\t
  • labels.length == n
    • \n\t
  • labels is consisting of only of lowercase English letters.
    • \n
\n
" }, { "path": "1531-string-compression-ii/1531-string-compression-ii.java", "content": "/*\nWe define the state dp[i][j]: The best solution for the first i chars in the string after at most j chars\nbeing removed; i.e., the minimum length after at most j chars being removed from s.substring(0, i).\n\nFor each such substring, we can either delete or keep the last char, s[i - 1]\n- To delete, dp[i][j] = dp[i - 1][j - 1].\n- To keep, we delete at most j chars in s.substring(0, i) that are different from the last character.\n- We then take the min value of them for dp[i][j]\n*/\nclass Solution {\n public int getLengthOfOptimalCompression(String s, int k) {\n int n = s.length();\n \n // dp[i][j]: the minimum length for the first i chars after at most j chars being removed.\n int[][] dp = new int[n + 1][k + 1];\n // Initialize each cell of the dp 2-D array to n, the max value that each cell can have. This\n // is OK, as each dp[i][j] will have the min value bewteen dp[i][j] and its calculate value.\n // for (int[] i : dp) Arrays.fill(i, n); // this is a bit slower (100ms)\n for (int i = 0; i <= n; i++) {\n for (int j = 0; j <= k; j++) {\n dp[i][j] = n;\n }\n }\n\t\t\n // Minimum length of empty string after 0 removal is 0\n dp[0][0] = 0;\n \n // iterate from 1 character substring to n-character substring\n for(int i = 1; i <= n; i++) {\n // We can delete at most i characters if i < k or k characters if i >= k.\n // Using \"j <= k\" alone here is OK but \"j <= i && j <= k\" speeds up a lot\n for(int j = 0; j <= i && j <= k; j++) { \n int count = 0;\n int del = 0;\n \n // delete the last character of the substring (j has to be greater than 1 to delete 1 character)\n if (j > 0) {\n dp[i][j] = dp[i - 1][j - 1];\n }\n \n // Keep the last character of the substring, and starting from the end of the \n // substring, count the same characters as the last character, and remove characters\n // that are different.\n char lastChar = s.charAt(i - 1);\n for(int p = i; p >= 1; p--) { \n if (s.charAt(p - 1) == lastChar) {\n count++;\n } else {\n del++;\n \n // Bail out if no more removal is available\n if (del > j) {\n break;\n }\n }\n \n // After del number of removals from the end of substring we have \"p - 1\" characters left\n // in the substring and AT MOST \"j - del\" removals available\n dp[i][j] = Math.min(dp[i][j], dp[p - 1][j - del] + 1 + length(count));\n }\n }\n }\n \n return dp[n][k];\n }\n \n // Constraints is \"1 <= s.length <= 100\", then the max count is 100 when all 100 characters are the same\n // Note we don't add '1' after single characters.\n private int length(int count) {\n return count == 100 ? 3 : count >= 10 ? 2 : count > 1 ? 1 : 0;\n }\n}" }, { "path": "1531-string-compression-ii/NOTES.md", "content": "​" }, { "path": "1531-string-compression-ii/README.md", "content": "

1531. String Compression II

Hard

Run-length encoding is a string compression method that works by replacing consecutive identical characters (repeated 2 or more times) with the concatenation of the character and the number marking the count of the characters (length of the run). For example, to compress the string \"aabccc\" we replace \"aa\" by \"a2\" and replace \"ccc\" by \"c3\". Thus the compressed string becomes \"a2bc3\".

\n\n

Notice that in this problem, we are not adding '1' after single characters.

\n\n

Given a string s and an integer k. You need to delete at most k characters from s such that the run-length encoded version of s has minimum length.

\n\n

Find the minimum length of the run-length encoded version of s after deleting at most k characters.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"aaabcccd\", k = 2\nOutput: 4\nExplanation: Compressing s without deleting anything will give us \"a3bc3d\" of length 6. Deleting any of the characters 'a' or 'c' would at most decrease the length of the compressed string to 5, for instance delete 2 'a' then we will have s = \"abcccd\" which compressed is abc3d. Therefore, the optimal way is to delete 'b' and 'd', then the compressed version of s will be \"a3c3\" of length 4.
\n\n

Example 2:

\n\n
Input: s = \"aabbaa\", k = 2\nOutput: 2\nExplanation: If we delete both 'b' characters, the resulting compressed string would be \"a4\" of length 2.\n
\n\n

Example 3:

\n\n
Input: s = \"aaaaaaaaaaa\", k = 0\nOutput: 3\nExplanation: Since k is zero, we cannot delete anything. The compressed string is \"a11\" of length 3.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 100
    • \n\t
  • 0 <= k <= s.length
    • \n\t
  • s contains only lowercase English letters.
    • \n
\n
" }, { "path": "1544-make-the-string-great/1544-make-the-string-great.java", "content": "class Solution {\n public String makeGood(String s) {\n Stack st=new Stack<>();\n st.push(s.charAt(0));\n for(int i=1;i1544. Make The String Great

Easy

Given a string s of lower and upper case English letters.

\n\n

A good string is a string which doesn't have two adjacent characters s[i] and s[i + 1] where:

\n\n
    \n\t
  • 0 <= i <= s.length - 2
    • \n\t
  • s[i] is a lower-case letter and s[i + 1] is the same letter but in upper-case or vice-versa.
    • \n
\n\n

To make the string good, you can choose two adjacent characters that make the string bad and remove them. You can keep doing this until the string becomes good.

\n\n

Return the string after making it good. The answer is guaranteed to be unique under the given constraints.

\n\n

Notice that an empty string is also good.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"leEeetcode\"\nOutput: \"leetcode\"\nExplanation: In the first step, either you choose i = 1 or i = 2, both will result \"leEeetcode\" to be reduced to \"leetcode\".\n
\n\n

Example 2:

\n\n
Input: s = \"abBAcC\"\nOutput: \"\"\nExplanation: We have many possible scenarios, and all lead to the same answer. For example:\n\"abBAcC\" --> \"aAcC\" --> \"cC\" --> \"\"\n\"abBAcC\" --> \"abBA\" --> \"aA\" --> \"\"\n
\n\n

Example 3:

\n\n
Input: s = \"s\"\nOutput: \"s\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 100
    • \n\t
  • s contains only lower and upper case English letters.
    • \n
\n
" }, { "path": "1578-minimum-time-to-make-rope-colorful/1578-minimum-time-to-make-rope-colorful.java", "content": "class Solution {\n public int minCost(String colors, int[] neededTime) {\n int prev = 0;\n int res = 0;\n char arr[] = colors.toCharArray();\n for (int i = 1; i < arr.length; i++) {\n if (arr[prev] != arr[i])\n prev = i;\n \n else {\n if (neededTime[prev] < neededTime[i]) {\n res += neededTime[prev];\n prev = i;\n }\n \n else {\n res += neededTime[i];\n }\n }\n }\n return res;\n }\n}" }, { "path": "1578-minimum-time-to-make-rope-colorful/NOTES.md", "content": "​" }, { "path": "1578-minimum-time-to-make-rope-colorful/README.md", "content": "

1578. Minimum Time to Make Rope Colorful

Medium

Alice has n balloons arranged on a rope. You are given a 0-indexed string colors where colors[i] is the color of the ith balloon.

\n\n

Alice wants the rope to be colorful. She does not want two consecutive balloons to be of the same color, so she asks Bob for help. Bob can remove some balloons from the rope to make it colorful. You are given a 0-indexed integer array neededTime where neededTime[i] is the time (in seconds) that Bob needs to remove the ith balloon from the rope.

\n\n

Return the minimum time Bob needs to make the rope colorful.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: colors = \"abaac\", neededTime = [1,2,3,4,5]\nOutput: 3\nExplanation: In the above image, 'a' is blue, 'b' is red, and 'c' is green.\nBob can remove the blue balloon at index 2. This takes 3 seconds.\nThere are no longer two consecutive balloons of the same color. Total time = 3.
\n\n

Example 2:

\n\"\"\n
Input: colors = \"abc\", neededTime = [1,2,3]\nOutput: 0\nExplanation: The rope is already colorful. Bob does not need to remove any balloons from the rope.\n
\n\n

Example 3:

\n\"\"\n
Input: colors = \"aabaa\", neededTime = [1,2,3,4,1]\nOutput: 2\nExplanation: Bob will remove the ballons at indices 0 and 4. Each ballon takes 1 second to remove.\nThere are no longer two consecutive balloons of the same color. Total time = 1 + 1 = 2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == colors.length == neededTime.length
    • \n\t
  • 1 <= n <= 105
    • \n\t
  • 1 <= neededTime[i] <= 104
    • \n\t
  • colors contains only lowercase English letters.
    • \n
\n
" }, { "path": "1584-min-cost-to-connect-all-points/1584-min-cost-to-connect-all-points.java", "content": "class Solution {\n public int minCostConnectPoints(int[][] points) {\n int n = points.length;\n \n // Min-heap to store minimum weight edge at top.\n PriorityQueue> heap = new PriorityQueue<>((a, b) -> (a.getKey() - b.getKey()));;\n \n // Track nodes which are included in MST.\n boolean[] inMST = new boolean[n];\n \n heap.add(new Pair(0, 0));\n int mstCost = 0;\n int edgesUsed = 0;\n \n while (edgesUsed < n) {\n Pair topElement = heap.poll();\n \n int weight = topElement.getKey();\n int currNode = topElement.getValue();\n \n // If node was already included in MST we will discard this edge.\n if (inMST[currNode]) {\n continue;\n }\n \n inMST[currNode] = true;\n mstCost += weight;\n edgesUsed++;\n \n for (int nextNode = 0; nextNode < n; ++nextNode) {\n // If next node is not in MST, then edge from curr node\n // to next node can be pushed in the priority queue.\n if (!inMST[nextNode]){\n int nextWeight = Math.abs(points[currNode][0] - points[nextNode][0]) + Math.abs(points[currNode][1] - points[nextNode][1]);\n \n heap.add(new Pair(nextWeight, nextNode));\n }\n }\n }\n return mstCost;\n }\n}" }, { "path": "1584-min-cost-to-connect-all-points/NOTES.md", "content": "​" }, { "path": "1584-min-cost-to-connect-all-points/README.md", "content": "

1584. Min Cost to Connect All Points

Medium

You are given an array points representing integer coordinates of some points on a 2D-plane, where points[i] = [xi, yi].

\n\n

The cost of connecting two points [xi, yi] and [xj, yj] is the manhattan distance between them: |xi - xj| + |yi - yj|, where |val| denotes the absolute value of val.

\n\n

Return the minimum cost to make all points connected. All points are connected if there is exactly one simple path between any two points.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: points = [[0,0],[2,2],[3,10],[5,2],[7,0]]\nOutput: 20\nExplanation: \n\"\"\nWe can connect the points as shown above to get the minimum cost of 20.\nNotice that there is a unique path between every pair of points.\n
\n\n

Example 2:

\n\n
Input: points = [[3,12],[-2,5],[-4,1]]\nOutput: 18\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= points.length <= 1000
    • \n\t
  • -106 <= xi, yi <= 106
    • \n\t
  • All pairs (xi, yi) are distinct.
    • \n
\n
" }, { "path": "16-3sum-closest/16-3sum-closest.java", "content": "class Solution {\n public int threeSumClosest(int[] nums, int target) {\n Arrays.sort(nums);\n int n = nums.length;\n int minDiff = Integer.MAX_VALUE;\n int result = Integer.MAX_VALUE;\n \n for(int i = 0; i < nums.length; i++) {\n int start = i + 1;\n int end = n - 1;\n \n while(start < end) {\n \n int sum = nums[i] + nums[start] + nums[end];\n \n if(sum == target) {\n return sum;\n } \n \n int diff = Math.abs(target - sum);\n \n if(diff < minDiff) {\n minDiff = diff;\n result = sum;\n }\n \n if(sum > target) {\n end--;\n } else {\n start++;\n }\n }\n }\n \n return result;\n }\n}" }, { "path": "16-3sum-closest/NOTES.md", "content": "​" }, { "path": "16-3sum-closest/README.md", "content": "

16. 3Sum Closest

Medium

Given an integer array nums of length n and an integer target, find three integers in nums such that the sum is closest to target.

\n\n

Return the sum of the three integers.

\n\n

You may assume that each input would have exactly one solution.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [-1,2,1,-4], target = 1\nOutput: 2\nExplanation: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).\n
\n\n

Example 2:

\n\n
Input: nums = [0,0,0], target = 1\nOutput: 0\nExplanation: The sum that is closest to the target is 0. (0 + 0 + 0 = 0).\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 3 <= nums.length <= 1000
    • \n\t
  • -1000 <= nums[i] <= 1000
    • \n\t
  • -104 <= target <= 104
    • \n
\n
" }, { "path": "16. 3Sum Closest - leetcode/SolutionCode.cpp", "content": "class Solution {\npublic:\n int threeSumClosest(vector& nums, int target) {\n sort(nums.begin(), nums.end());\n int closestSum = nums[0] + nums[1] + nums[2], n = nums.size();\n \n for(int i=0; i diff) closestSum = tmpSum;\n }\n }\n \n return closestSum;\n }\n};\n" }, { "path": "160-intersection-of-two-linked-lists/160-intersection-of-two-linked-lists.java", "content": "public class Solution {\n public ListNode getIntersectionNode(ListNode headA, ListNode headB) {\n ListNode t1=headA;\n ListNode t2=headB;\n int n=0,m=0;\n while(t1!=null){\n m++;\n t1=t1.next;\n }\n while(t2!=null){\n n++;\n t2=t2.next;\n }\n t1=headA;\n t2=headB;\n int t=m-n;\n if(t>0){\n m-=t;\n while(t>0){\n t1=t1.next;\n t--;\n }\n }else{\n t=-t;\n n-=t;\n while(t>0){\n t2=t2.next;\n t--;\n }\n }\n \n while(n>0){\n if(t1==t2)\n break;\n n--;\n t1=t1.next;\n t2=t2.next;\n }\n return t1;\n \n }\n}" }, { "path": "160-intersection-of-two-linked-lists/NOTES.md", "content": "​" }, { "path": "160-intersection-of-two-linked-lists/README.md", "content": "

160. Intersection of Two Linked Lists

Easy

Given the heads of two singly linked-lists headA and headB, return the node at which the two lists intersect. If the two linked lists have no intersection at all, return null.

\n\n

For example, the following two linked lists begin to intersect at node c1:

\n\"\"\n

The test cases are generated such that there are no cycles anywhere in the entire linked structure.

\n\n

Note that the linked lists must retain their original structure after the function returns.

\n\n

Custom Judge:

\n\n

The inputs to the judge are given as follows (your program is not given these inputs):

\n\n
    \n\t
  • intersectVal - The value of the node where the intersection occurs. This is 0 if there is no intersected node.
    • \n\t
  • listA - The first linked list.
    • \n\t
  • listB - The second linked list.
    • \n\t
  • skipA - The number of nodes to skip ahead in listA (starting from the head) to get to the intersected node.
    • \n\t
  • skipB - The number of nodes to skip ahead in listB (starting from the head) to get to the intersected node.
    • \n
\n\n

The judge will then create the linked structure based on these inputs and pass the two heads, headA and headB to your program. If you correctly return the intersected node, then your solution will be accepted.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3\nOutput: Intersected at '8'\nExplanation: The intersected node's value is 8 (note that this must not be 0 if the two lists intersect).\nFrom the head of A, it reads as [4,1,8,4,5]. From the head of B, it reads as [5,6,1,8,4,5]. There are 2 nodes before the intersected node in A; There are 3 nodes before the intersected node in B.\n
\n\n

Example 2:

\n\"\"\n
Input: intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1\nOutput: Intersected at '2'\nExplanation: The intersected node's value is 2 (note that this must not be 0 if the two lists intersect).\nFrom the head of A, it reads as [1,9,1,2,4]. From the head of B, it reads as [3,2,4]. There are 3 nodes before the intersected node in A; There are 1 node before the intersected node in B.\n
\n\n

Example 3:

\n\"\"\n
Input: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2\nOutput: No intersection\nExplanation: From the head of A, it reads as [2,6,4]. From the head of B, it reads as [1,5]. Since the two lists do not intersect, intersectVal must be 0, while skipA and skipB can be arbitrary values.\nExplanation: The two lists do not intersect, so return null.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes of listA is in the m.
    • \n\t
  • The number of nodes of listB is in the n.
    • \n\t
  • 1 <= m, n <= 3 * 104
    • \n\t
  • 1 <= Node.val <= 105
    • \n\t
  • 0 <= skipA < m
    • \n\t
  • 0 <= skipB < n
    • \n\t
  • intersectVal is 0 if listA and listB do not intersect.
    • \n\t
  • intersectVal == listA[skipA] == listB[skipB] if listA and listB intersect.
    • \n
\n\n

 

\nFollow up: Could you write a solution that runs in O(m + n) time and use only O(1) memory?
" }, { "path": "1631-path-with-minimum-effort/1631-path-with-minimum-effort.java", "content": "class Solution {\n public int minimumEffortPath(int[][] heights) {\n int[][] dirs = new int[][]{{-1,0},{1,0},{0,1},{0,-1}};\n int numR = heights.length; int numC = heights[0].length;\n int[][] ans = new int[numR][numC];\n for (int[] row : ans) {\n Arrays.fill(row,Integer.MAX_VALUE);\n }\n PriorityQueue queue = new PriorityQueue<>((a,b)->a[2]-b[2]);\n queue.offer(new int[]{0,0,0});\n ans[0][0] = 0;\n while (!queue.isEmpty()) {\n int[] curr = queue.poll();\n if (curr[0]==numR-1 && curr[1]==numC-1) return curr[2];\n for (int i=0; i<4; i++) {\n int nextR = curr[0]+dirs[i][0];\n int nextC = curr[1]+dirs[i][1];\n if (nextR<0 || nextC<0 || nextR>=numR || nextC>=numC) continue;\n int diff = Math.abs(heights[nextR][nextC]-heights[curr[0]][curr[1]]);\n int max = Math.max(diff,curr[2]);\n if (max1631. Path With Minimum Effort

Medium

You are a hiker preparing for an upcoming hike. You are given heights, a 2D array of size rows x columns, where heights[row][col] represents the height of cell (row, col). You are situated in the top-left cell, (0, 0), and you hope to travel to the bottom-right cell, (rows-1, columns-1) (i.e., 0-indexed). You can move up, down, left, or right, and you wish to find a route that requires the minimum effort.

\n\n

A route's effort is the maximum absolute difference in heights between two consecutive cells of the route.

\n\n

Return the minimum effort required to travel from the top-left cell to the bottom-right cell.

\n\n

 

\n

Example 1:

\n\n

\"\"

\n\n
Input: heights = [[1,2,2],[3,8,2],[5,3,5]]\nOutput: 2\nExplanation: The route of [1,3,5,3,5] has a maximum absolute difference of 2 in consecutive cells.\nThis is better than the route of [1,2,2,2,5], where the maximum absolute difference is 3.\n
\n\n

Example 2:

\n\n

\"\"

\n\n
Input: heights = [[1,2,3],[3,8,4],[5,3,5]]\nOutput: 1\nExplanation: The route of [1,2,3,4,5] has a maximum absolute difference of 1 in consecutive cells, which is better than route [1,3,5,3,5].\n
\n\n

Example 3:

\n\"\"\n
Input: heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]\nOutput: 0\nExplanation: This route does not require any effort.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • rows == heights.length
    • \n\t
  • columns == heights[i].length
    • \n\t
  • 1 <= rows, columns <= 100
    • \n\t
  • 1 <= heights[i][j] <= 106
    • \n
" }, { "path": "1641-count-sorted-vowel-strings/1641-count-sorted-vowel-strings.java", "content": "class Solution {\n public int countVowelStrings(int n) {\n int[] countOfEach = new int[] { 1, 1, 1, 1, 1 };\n \n for (int i = 0; i < n - 1; i++) {\n for (int j = 1; j < countOfEach.length; j++) {\n countOfEach[j] = countOfEach[j - 1] + countOfEach[j];\n } \n }\n \n return sum(countOfEach);\n }\n \n private int sum(int[] arr) {\n int amount = 0;\n for (int num : arr) {\n amount += num;\n }\n return amount;\n }\n}" }, { "path": "1641-count-sorted-vowel-strings/NOTES.md", "content": "​" }, { "path": "1641-count-sorted-vowel-strings/README.md", "content": "

1641. Count Sorted Vowel Strings

Medium

Given an integer n, return the number of strings of length n that consist only of vowels (a, e, i, o, u) and are lexicographically sorted.

\n\n

A string s is lexicographically sorted if for all valid i, s[i] is the same as or comes before s[i+1] in the alphabet.

\n\n

 

\n

Example 1:

\n\n
Input: n = 1\nOutput: 5\nExplanation: The 5 sorted strings that consist of vowels only are [\"a\",\"e\",\"i\",\"o\",\"u\"].\n
\n\n

Example 2:

\n\n
Input: n = 2\nOutput: 15\nExplanation: The 15 sorted strings that consist of vowels only are\n[\"aa\",\"ae\",\"ai\",\"ao\",\"au\",\"ee\",\"ei\",\"eo\",\"eu\",\"ii\",\"io\",\"iu\",\"oo\",\"ou\",\"uu\"].\nNote that \"ea\" is not a valid string since 'e' comes after 'a' in the alphabet.\n
\n\n

Example 3:

\n\n
Input: n = 33\nOutput: 66045\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 50 
    • \n
\n
" }, { "path": "1642-furthest-building-you-can-reach/1642-furthest-building-you-can-reach.java", "content": "class Solution {\n public int furthestBuilding(int[] h, int bricks, int l) {\n PriorityQueue pq=new PriorityQueue<>();\n int n=h.length;\n for(int i=1;i0){\n if(pq.size()0 && pq.peek()=br){\n bricks-=br;\n }else{\n return i-1;\n }\n }\n }\n }\n return n-1;\n }\n}" }, { "path": "1642-furthest-building-you-can-reach/NOTES.md", "content": "​" }, { "path": "1642-furthest-building-you-can-reach/README.md", "content": "

1642. Furthest Building You Can Reach

Medium

You are given an integer array heights representing the heights of buildings, some bricks, and some ladders.

\n\n

You start your journey from building 0 and move to the next building by possibly using bricks or ladders.

\n\n

While moving from building i to building i+1 (0-indexed),

\n\n
    \n\t
  • If the current building's height is greater than or equal to the next building's height, you do not need a ladder or bricks.
    • \n\t
  • If the current building's height is less than the next building's height, you can either use one ladder or (h[i+1] - h[i]) bricks.
    • \n
\n\n

Return the furthest building index (0-indexed) you can reach if you use the given ladders and bricks optimally.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: heights = [4,2,7,6,9,14,12], bricks = 5, ladders = 1\nOutput: 4\nExplanation: Starting at building 0, you can follow these steps:\n- Go to building 1 without using ladders nor bricks since 4 >= 2.\n- Go to building 2 using 5 bricks. You must use either bricks or ladders because 2 < 7.\n- Go to building 3 without using ladders nor bricks since 7 >= 6.\n- Go to building 4 using your only ladder. You must use either bricks or ladders because 6 < 9.\nIt is impossible to go beyond building 4 because you do not have any more bricks or ladders.\n
\n\n

Example 2:

\n\n
Input: heights = [4,12,2,7,3,18,20,3,19], bricks = 10, ladders = 2\nOutput: 7\n
\n\n

Example 3:

\n\n
Input: heights = [14,3,19,3], bricks = 17, ladders = 0\nOutput: 3\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= heights.length <= 105
    • \n\t
  • 1 <= heights[i] <= 106
    • \n\t
  • 0 <= bricks <= 109
    • \n\t
  • 0 <= ladders <= heights.length
    • \n
\n
" }, { "path": "1647-minimum-deletions-to-make-character-frequencies-unique/1647-minimum-deletions-to-make-character-frequencies-unique.java", "content": "class Solution {\n public int minDeletions(String s) {\n Set set = new HashSet<>();\n int[] alpha = new int[26];\n char[] arr =s.toCharArray();\n for(char c:arr)\n {\n alpha[c-'a']++;\n }\n int count = 0;\n for(int i=0;i<26;i++) {\n if(alpha[i] != 0) {\n while(set.contains(alpha[i]) && alpha[i]>0) {\n alpha[i]--;\n count++;\n }\n set.add(alpha[i]);\n } \n }\n \n return count;\n }\n}" }, { "path": "1647-minimum-deletions-to-make-character-frequencies-unique/NOTES.md", "content": "​" }, { "path": "1647-minimum-deletions-to-make-character-frequencies-unique/README.md", "content": "

1647. Minimum Deletions to Make Character Frequencies Unique

Medium

A string s is called good if there are no two different characters in s that have the same frequency.

\n\n

Given a string s, return the minimum number of characters you need to delete to make s good.

\n\n

The frequency of a character in a string is the number of times it appears in the string. For example, in the string \"aab\", the frequency of 'a' is 2, while the frequency of 'b' is 1.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"aab\"\nOutput: 0\nExplanation: s is already good.\n
\n\n

Example 2:

\n\n
Input: s = \"aaabbbcc\"\nOutput: 2\nExplanation: You can delete two 'b's resulting in the good string \"aaabcc\".\nAnother way it to delete one 'b' and one 'c' resulting in the good string \"aaabbc\".
\n\n

Example 3:

\n\n
Input: s = \"ceabaacb\"\nOutput: 2\nExplanation: You can delete both 'c's resulting in the good string \"eabaab\".\nNote that we only care about characters that are still in the string at the end (i.e. frequency of 0 is ignored).\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 105
    • \n\t
  • s contains only lowercase English letters.
    • \n
\n
" }, { "path": "1657-determine-if-two-strings-are-close/1657-determine-if-two-strings-are-close.java", "content": "class Solution {\n public boolean closeStrings(String s1, String s2) {\n \n var freqs1 = new int[26];\n for(var c1: s1.toCharArray()) {\n freqs1[c1 - 'a']++;\n }\n var freqs2 = new int[26];\n for(var c2: s2.toCharArray()) {\n freqs2[c2 - 'a']++;\n }\n for(int i = 0; i < 26; i++) {\n if(freqs1[i] > 0 && freqs2[i] == 0) {\n return false;\n }\n if(freqs1[i] == 0 && freqs2[i] > 0) {\n return false; \n }\n }\n Arrays.sort(freqs1);\n Arrays.sort(freqs2);\n return Arrays.equals(freqs1, freqs2); \n }\n}" }, { "path": "1657-determine-if-two-strings-are-close/NOTES.md", "content": "​" }, { "path": "1657-determine-if-two-strings-are-close/README.md", "content": "

1657. Determine if Two Strings Are Close

Medium

Two strings are considered close if you can attain one from the other using the following operations:

\n\n
    \n\t
  • Operation 1: Swap any two existing characters.\n\n\t
      \n\t\t
    • For example, abcde -> aecdb
      • \n\t
    \n\t
    • \n\t
  • Operation 2: Transform every occurrence of one existing character into another existing character, and do the same with the other character.\n\t
      \n\t\t
    • For example, aacabb -> bbcbaa (all a's turn into b's, and all b's turn into a's)
      • \n\t
    \n\t
    • \n
\n\n

You can use the operations on either string as many times as necessary.

\n\n

Given two strings, word1 and word2, return true if word1 and word2 are close, and false otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: word1 = \"abc\", word2 = \"bca\"\nOutput: true\nExplanation: You can attain word2 from word1 in 2 operations.\nApply Operation 1: \"abc\" -> \"acb\"\nApply Operation 1: \"acb\" -> \"bca\"\n
\n\n

Example 2:

\n\n
Input: word1 = \"a\", word2 = \"aa\"\nOutput: false\nExplanation: It is impossible to attain word2 from word1, or vice versa, in any number of operations.\n
\n\n

Example 3:

\n\n
Input: word1 = \"cabbba\", word2 = \"abbccc\"\nOutput: true\nExplanation: You can attain word2 from word1 in 3 operations.\nApply Operation 1: \"cabbba\" -> \"caabbb\"\nApply Operation 2: \"caabbb\" -> \"baaccc\"\nApply Operation 2: \"baaccc\" -> \"abbccc\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= word1.length, word2.length <= 105
    • \n\t
  • word1 and word2 contain only lowercase English letters.
    • \n
\n
" }, { "path": "1658-minimum-operations-to-reduce-x-to-zero/1658-minimum-operations-to-reduce-x-to-zero.java", "content": "class Solution {\n public int minOperations(int[] nums, int x) {\n \n int k = 0;\n\t\tfor(int i = 0; i < nums.length; ++i)k += nums[i];\n\t\tk -= x;\n\t\t\n\t\tint globalMax = -1;\n\t\tint windowSum = 0;\n\t\tint left = 0;\n\n\t\tfor (int i = 0; i < nums.length; i++) {\n\t\t\twindowSum += nums[i];\n\t\t\twhile (left <= i && windowSum > k) {\n\t\t\t\twindowSum -= nums[left];\n\t\t\t\t++left;\n\t\t\t}\n if(windowSum == k)globalMax = Math.max(globalMax, i - left + 1);\n\t\t}\n\t\treturn globalMax==-1?-1:nums.length - globalMax;\n }\n}" }, { "path": "1658-minimum-operations-to-reduce-x-to-zero/NOTES.md", "content": "​" }, { "path": "1658-minimum-operations-to-reduce-x-to-zero/README.md", "content": "

1658. Minimum Operations to Reduce X to Zero

Medium

You are given an integer array nums and an integer x. In one operation, you can either remove the leftmost or the rightmost element from the array nums and subtract its value from x. Note that this modifies the array for future operations.

\n\n

Return the minimum number of operations to reduce x to exactly 0 if it is possible, otherwise, return -1.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,1,4,2,3], x = 5\nOutput: 2\nExplanation: The optimal solution is to remove the last two elements to reduce x to zero.\n
\n\n

Example 2:

\n\n
Input: nums = [5,6,7,8,9], x = 4\nOutput: -1\n
\n\n

Example 3:

\n\n
Input: nums = [3,2,20,1,1,3], x = 10\nOutput: 5\nExplanation: The optimal solution is to remove the last three elements and the first two elements (5 operations in total) to reduce x to zero.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • 1 <= nums[i] <= 104
    • \n\t
  • 1 <= x <= 109
    • \n
\n
" }, { "path": "1662-check-if-two-string-arrays-are-equivalent/1662-check-if-two-string-arrays-are-equivalent.java", "content": "class Solution {\n public boolean arrayStringsAreEqual(String[] word1, String[] word2) {\n StringBuilder s1 = new StringBuilder();\n StringBuilder s2 = new StringBuilder();\n \n for(int i = 0 ; i < Math.max(word1.length , word2.length) ; i++){\n if(i < word1.length){\n s1.append(word1[i]);\n }\n if(i1662. Check If Two String Arrays are Equivalent

Easy

Given two string arrays word1 and word2, return true if the two arrays represent the same string, and false otherwise.

\n\n

A string is represented by an array if the array elements concatenated in order forms the string.

\n\n

 

\n

Example 1:

\n\n
Input: word1 = [\"ab\", \"c\"], word2 = [\"a\", \"bc\"]\nOutput: true\nExplanation:\nword1 represents string \"ab\" + \"c\" -> \"abc\"\nword2 represents string \"a\" + \"bc\" -> \"abc\"\nThe strings are the same, so return true.
\n\n

Example 2:

\n\n
Input: word1 = [\"a\", \"cb\"], word2 = [\"ab\", \"c\"]\nOutput: false\n
\n\n

Example 3:

\n\n
Input: word1  = [\"abc\", \"d\", \"defg\"], word2 = [\"abcddefg\"]\nOutput: true\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= word1.length, word2.length <= 103
    • \n\t
  • 1 <= word1[i].length, word2[i].length <= 103
    • \n\t
  • 1 <= sum(word1[i].length), sum(word2[i].length) <= 103
    • \n\t
  • word1[i] and word2[i] consist of lowercase letters.
    • \n
\n
" }, { "path": "1663-smallest-string-with-a-given-numeric-value/1663-smallest-string-with-a-given-numeric-value.java", "content": "class Solution {\n public String getSmallestString(int n, int k) {\n char ch[]=new char[n];\n int i=0;\n while(i=k){\n ch[i]='a';\n i++;\n k--;\n }else{\n break;\n }\n }\n i--;\n ch[i]=(char)(k%26+'a');\n i++;\n while(i1663. Smallest String With A Given Numeric Value

Medium

The numeric value of a lowercase character is defined as its position (1-indexed) in the alphabet, so the numeric value of a is 1, the numeric value of b is 2, the numeric value of c is 3, and so on.

\n\n

The numeric value of a string consisting of lowercase characters is defined as the sum of its characters' numeric values. For example, the numeric value of the string \"abe\" is equal to 1 + 2 + 5 = 8.

\n\n

You are given two integers n and k. Return the lexicographically smallest string with length equal to n and numeric value equal to k.

\n\n

Note that a string x is lexicographically smaller than string y if x comes before y in dictionary order, that is, either x is a prefix of y, or if i is the first position such that x[i] != y[i], then x[i] comes before y[i] in alphabetic order.

\n\n

 

\n

Example 1:

\n\n
Input: n = 3, k = 27\nOutput: \"aay\"\nExplanation: The numeric value of the string is 1 + 1 + 25 = 27, and it is the smallest string with such a value and length equal to 3.\n
\n\n

Example 2:

\n\n
Input: n = 5, k = 73\nOutput: \"aaszz\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 105
    • \n\t
  • n <= k <= 26 * n
    • \n
\n
" }, { "path": "167-two-sum-ii-input-array-is-sorted/167-two-sum-ii-input-array-is-sorted.java", "content": "class Solution {\n public int[] twoSum(int[] numbers, int target) {\n int left = 0;\n int right = numbers.length - 1;\n boolean targetLocated = false;\n while (left < right && !targetLocated) {\n int mid = left + (right - left) / 2;\n int midVal = numbers[mid];\n int curr = numbers[left] + numbers[right];\n if(curr == target) {\n targetLocated = true;\n } else if (curr < target) {\n if (midVal + numbers[right] < target) {\n left = mid + 1;\n } else {\n left++;\n }\n \n } else {\n \n if (midVal + numbers[left] > target) {\n right = mid - 1;\n } else {\n right--;\n }\n \n \n }\n \n }\n \n int[] vals = new int[2];\n vals[0] = left + 1;\n vals[1] = right + 1;\n \n return vals;\n \n }\n}" }, { "path": "167-two-sum-ii-input-array-is-sorted/NOTES.md", "content": "​" }, { "path": "167-two-sum-ii-input-array-is-sorted/README.md", "content": "

167. Two Sum II - Input Array Is Sorted

Medium

Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Let these two numbers be numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length.

\n\n

Return the indices of the two numbers, index1 and index2, added by one as an integer array [index1, index2] of length 2.

\n\n

The tests are generated such that there is exactly one solution. You may not use the same element twice.

\n\n

Your solution must use only constant extra space.

\n\n

 

\n

Example 1:

\n\n
Input: numbers = [2,7,11,15], target = 9\nOutput: [1,2]\nExplanation: The sum of 2 and 7 is 9. Therefore, index1 = 1, index2 = 2. We return [1, 2].\n
\n\n

Example 2:

\n\n
Input: numbers = [2,3,4], target = 6\nOutput: [1,3]\nExplanation: The sum of 2 and 4 is 6. Therefore index1 = 1, index2 = 3. We return [1, 3].\n
\n\n

Example 3:

\n\n
Input: numbers = [-1,0], target = -1\nOutput: [1,2]\nExplanation: The sum of -1 and 0 is -1. Therefore index1 = 1, index2 = 2. We return [1, 2].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= numbers.length <= 3 * 104
    • \n\t
  • -1000 <= numbers[i] <= 1000
    • \n\t
  • numbers is sorted in non-decreasing order.
    • \n\t
  • -1000 <= target <= 1000
    • \n\t
  • The tests are generated such that there is exactly one solution.
    • \n
\n
" }, { "path": "1679-max-number-of-k-sum-pairs/1679-max-number-of-k-sum-pairs.java", "content": "class Solution {\n public int maxOperations(int[] nums, int k) {\n int ans=0;\n Arrays.sort(nums);\n int i=0;\n int j=nums.length-1;\n while(i\nusing namespace std;;\n\nclass Solution {\npublic:\n // using bit manipulation TC: O(N), SC: O(1)\n int concatenatedBinary(int n) {\n int m = 1e9+7, l=0; // l is bit length to be shifted\n long res =0;\n for(int i =1; i<=n; i++){\n if ((i & (i - 1)) == 0) l += 1;\n res = ((res << l) | i) % m;\n }\n return res;\n \n }\n};" }, { "path": "1680-concatenation-of-consecutive-binary-numbers/1680-concatenation-of-consecutive-binary-numbers.java", "content": "class Solution {\n static String arr[] = new String[100001];\n\nstatic int ans[] = new int[100001];\n\npublic void build() {\n for(int i=1; i<=100000; i++) {\n arr[i] = Integer.toBinaryString(i);\n }\n}\n\nint mod = 1000000007;\n\npublic int getVal(int n) {\n int val = 0;\n for(int i=1; i<=n; i++) {\n for(int j=0; j1680. Concatenation of Consecutive Binary Numbers

Medium

Given an integer n, return the decimal value of the binary string formed by concatenating the binary representations of 1 to n in order, modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: n = 1\nOutput: 1\nExplanation: \"1\" in binary corresponds to the decimal value 1. \n
\n\n

Example 2:

\n\n
Input: n = 3\nOutput: 27\nExplanation: In binary, 1, 2, and 3 corresponds to \"1\", \"10\", and \"11\".\nAfter concatenating them, we have \"11011\", which corresponds to the decimal value 27.\n
\n\n

Example 3:

\n\n
Input: n = 12\nOutput: 505379714\nExplanation: The concatenation results in \"1101110010111011110001001101010111100\".\nThe decimal value of that is 118505380540.\nAfter modulo 109 + 7, the result is 505379714.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 105
    • \n
\n
" }, { "path": "1689-partitioning-into-minimum-number-of-deci-binary-numbers/1689-partitioning-into-minimum-number-of-deci-binary-numbers.java", "content": "class Solution {\n public int minPartitions(String n) {\n for(int i=9; i>=1; i--) {\n String ch = Integer.toString(i);\n if( n.contains(ch) )return i;\n }\n return 0;\n \n }\n}" }, { "path": "1689-partitioning-into-minimum-number-of-deci-binary-numbers/NOTES.md", "content": "​" }, { "path": "1689-partitioning-into-minimum-number-of-deci-binary-numbers/README.md", "content": "

1689. Partitioning Into Minimum Number Of Deci-Binary Numbers

Medium

A decimal number is called deci-binary if each of its digits is either 0 or 1 without any leading zeros. For example, 101 and 1100 are deci-binary, while 112 and 3001 are not.

\n\n

Given a string n that represents a positive decimal integer, return the minimum number of positive deci-binary numbers needed so that they sum up to n.

\n\n

 

\n

Example 1:

\n\n
Input: n = \"32\"\nOutput: 3\nExplanation: 10 + 11 + 11 = 32\n
\n\n

Example 2:

\n\n
Input: n = \"82734\"\nOutput: 8\n
\n\n

Example 3:

\n\n
Input: n = \"27346209830709182346\"\nOutput: 9\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n.length <= 105
    • \n\t
  • n consists of only digits.
    • \n\t
  • n does not contain any leading zeros and represents a positive integer.
    • \n
\n
" }, { "path": "1695-maximum-erasure-value/1695-maximum-erasure-value.java", "content": "class Solution {\n public int maximumUniqueSubarray(int[] arr) {\n int res = 0;\n boolean[] check = new boolean[10001];\n int l = 0;\n int r = 0;\n int temp=0;\n while(r1695. Maximum Erasure Value

Medium

You are given an array of positive integers nums and want to erase a subarray containing unique elements. The score you get by erasing the subarray is equal to the sum of its elements.

\n\n

Return the maximum score you can get by erasing exactly one subarray.

\n\n

An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).

\n\n

 

\n

Example 1:

\n\n
Input: nums = [4,2,4,5,6]\nOutput: 17\nExplanation: The optimal subarray here is [2,4,5,6].\n
\n\n

Example 2:

\n\n
Input: nums = [5,2,1,2,5,2,1,2,5]\nOutput: 8\nExplanation: The optimal subarray here is [5,2,1] or [1,2,5].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • 1 <= nums[i] <= 104
    • \n
\n
" }, { "path": "1696-jump-game-vi/1696-jump-game-vi.java", "content": "class Solution {\n public int maxResult(int[] nums, int k) {\n \n int n = nums.length;\n int result = 0;\n \n if(k > n) {\n k = n;\n }\n \n if(k < 1) {\n for(int i = 0; i < n; i++) {\n result += nums[i];\n }\n return result;\n }\n \n \n int[] dp = new int[n];\n \n dp[0] = nums[0];\n \n for(int i = 1; i < n; i++) {\n dp[i] = Integer.MIN_VALUE;\n }\n \n int maxIndex = 0;\n \n for(int i = 1; i < n; i++) {\n if(maxIndex < i - k) {\n \n int max = Integer.MIN_VALUE;\n for(int j = maxIndex+1; j < n && j <= maxIndex+k; j++) {\n if(max <= dp[j]) {\n max = dp[j];\n maxIndex = j;\n }\n }\n }\n \n dp[i] = Math.max(nums[i] + dp[maxIndex], dp[i]);\n if(dp[i] >= dp[maxIndex]) {\n maxIndex = i;\n }\n \n }\n return dp[n-1];\n }\n}" }, { "path": "1696-jump-game-vi/NOTES.md", "content": "​" }, { "path": "1696-jump-game-vi/README.md", "content": "

1696. Jump Game VI

Medium

You are given a 0-indexed integer array nums and an integer k.

\n\n

You are initially standing at index 0. In one move, you can jump at most k steps forward without going outside the boundaries of the array. That is, you can jump from index i to any index in the range [i + 1, min(n - 1, i + k)] inclusive.

\n\n

You want to reach the last index of the array (index n - 1). Your score is the sum of all nums[j] for each index j you visited in the array.

\n\n

Return the maximum score you can get.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,-1,-2,4,-7,3], k = 2\nOutput: 7\nExplanation: You can choose your jumps forming the subsequence [1,-1,4,3] (underlined above). The sum is 7.\n
\n\n

Example 2:

\n\n
Input: nums = [10,-5,-2,4,0,3], k = 3\nOutput: 17\nExplanation: You can choose your jumps forming the subsequence [10,4,3] (underlined above). The sum is 17.\n
\n\n

Example 3:

\n\n
Input: nums = [1,-5,-20,4,-1,3,-6,-3], k = 2\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length, k <= 105
    • \n\t
  • -104 <= nums[i] <= 104
    • \n
\n
" }, { "path": "17-letter-combinations-of-a-phone-number/17-letter-combinations-of-a-phone-number.java", "content": "class Solution {\n public static String[] map = {\"\", \"\", \"abc\", \"def\", \"ghi\", \"jkl\", \"mno\", \"pqrs\", \"tuv\", \"wxyz\"};\n public List letterCombinations(String digits) {\n List res = new ArrayList<>();\n if(digits == null || digits.length() == 0){\n return res;\n }\n dfs(digits, 0, new StringBuilder(), res);\n return res;\n }\n \n public void dfs(String digits, int index, StringBuilder sb, List res){\n if(index == digits.length()){\n res.add(sb.toString());\n return;\n }\n \n String str = map[digits.charAt(index) - '0'];\n for(int i = 0; i < str.length(); i++){\n sb.append(str.charAt(i));\n dfs(digits, index + 1, sb, res);\n sb.deleteCharAt(sb.length() - 1);\n }\n }\n}" }, { "path": "17-letter-combinations-of-a-phone-number/NOTES.md", "content": "​" }, { "path": "17-letter-combinations-of-a-phone-number/README.md", "content": "

17. Letter Combinations of a Phone Number

Medium

Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. Return the answer in any order.

\n\n

A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.

\n\n

\n\n

 

\n

Example 1:

\n\n
Input: digits = \"23\"\nOutput: [\"ad\",\"ae\",\"af\",\"bd\",\"be\",\"bf\",\"cd\",\"ce\",\"cf\"]\n
\n\n

Example 2:

\n\n
Input: digits = \"\"\nOutput: []\n
\n\n

Example 3:

\n\n
Input: digits = \"2\"\nOutput: [\"a\",\"b\",\"c\"]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= digits.length <= 4
    • \n\t
  • digits[i] is a digit in the range ['2', '9'].
    • \n
\n
" }, { "path": "1704-determine-if-string-halves-are-alike/1704-determine-if-string-halves-are-alike.java", "content": "class Solution {\n public boolean halvesAreAlike(String s) {\n char[] ch=s.toCharArray();\n int len=s.length();\n int mid=len/2;\n int l=check(ch,0,mid-1);\n int r=check(ch,mid,len-1);\n if(l==r)\n {\n return true;\n }\n return false;\n \n }\n public int check(char[] ch,int start,int end){\n int count=0;\n for(int i=start;i<=end;i++)\n {\n if(ch[i]=='a'||ch[i]=='e'||ch[i]=='i'||ch[i]=='o'||ch[i]=='u'||ch[i]=='A'||ch[i]=='E'||ch[i]=='I'||ch[i]=='O'||ch[i]=='U')\n {\n count++; \n }\n }\n return count;\n }\n}" }, { "path": "1704-determine-if-string-halves-are-alike/NOTES.md", "content": "​" }, { "path": "1704-determine-if-string-halves-are-alike/README.md", "content": "

1704. Determine if String Halves Are Alike

Easy

You are given a string s of even length. Split this string into two halves of equal lengths, and let a be the first half and b be the second half.

\n\n

Two strings are alike if they have the same number of vowels ('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'). Notice that s contains uppercase and lowercase letters.

\n\n

Return true if a and b are alike. Otherwise, return false.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"book\"\nOutput: true\nExplanation: a = \"bo\" and b = \"ok\". a has 1 vowel and b has 1 vowel. Therefore, they are alike.\n
\n\n

Example 2:

\n\n
Input: s = \"textbook\"\nOutput: false\nExplanation: a = \"text\" and b = \"book\". a has 1 vowel whereas b has 2. Therefore, they are not alike.\nNotice that the vowel o is counted twice.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= s.length <= 1000
    • \n\t
  • s.length is even.
    • \n\t
  • s consists of uppercase and lowercase letters.
    • \n
\n
" }, { "path": "1706-where-will-the-ball-fall/1706-where-will-the-ball-fall.java", "content": "class Solution {\n public int[] findBall(int[][] grid) {\n int result[] = new int[grid[0].length];\n for (int i = 0; i < grid[0].length; i++) {\n result[i] = findBallDropColumn(0, i, grid);\n }\n return result;\n }\n\n public int findBallDropColumn(int row, int col, int[][] grid) {\n // base case; ball reached the last row\n if (row == grid.length)\n return col;\n int nextColumn = col + grid[row][col];\n if (nextColumn < 0 ||\n nextColumn > grid[0].length - 1 ||\n grid[row][col] != grid[row][nextColumn]) {\n return -1;\n }\n return findBallDropColumn(row + 1, nextColumn, grid);\n }\n}" }, { "path": "1706-where-will-the-ball-fall/NOTES.md", "content": "​" }, { "path": "1706-where-will-the-ball-fall/README.md", "content": "

1706. Where Will the Ball Fall

Medium

You have a 2-D grid of size m x n representing a box, and you have n balls. The box is open on the top and bottom sides.

\n\n

Each cell in the box has a diagonal board spanning two corners of the cell that can redirect a ball to the right or to the left.

\n\n
    \n\t
  • A board that redirects the ball to the right spans the top-left corner to the bottom-right corner and is represented in the grid as 1.
    • \n\t
  • A board that redirects the ball to the left spans the top-right corner to the bottom-left corner and is represented in the grid as -1.
    • \n
\n\n

We drop one ball at the top of each column of the box. Each ball can get stuck in the box or fall out of the bottom. A ball gets stuck if it hits a \"V\" shaped pattern between two boards or if a board redirects the ball into either wall of the box.

\n\n

Return an array answer of size n where answer[i] is the column that the ball falls out of at the bottom after dropping the ball from the ith column at the top, or -1 if the ball gets stuck in the box.

\n\n

 

\n

Example 1:

\n\n

\"\"

\n\n
Input: grid = [[1,1,1,-1,-1],[1,1,1,-1,-1],[-1,-1,-1,1,1],[1,1,1,1,-1],[-1,-1,-1,-1,-1]]\nOutput: [1,-1,-1,-1,-1]\nExplanation: This example is shown in the photo.\nBall b0 is dropped at column 0 and falls out of the box at column 1.\nBall b1 is dropped at column 1 and will get stuck in the box between column 2 and 3 and row 1.\nBall b2 is dropped at column 2 and will get stuck on the box between column 2 and 3 and row 0.\nBall b3 is dropped at column 3 and will get stuck on the box between column 2 and 3 and row 0.\nBall b4 is dropped at column 4 and will get stuck on the box between column 2 and 3 and row 1.\n
\n\n

Example 2:

\n\n
Input: grid = [[-1]]\nOutput: [-1]\nExplanation: The ball gets stuck against the left wall.\n
\n\n

Example 3:

\n\n
Input: grid = [[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1],[1,1,1,1,1,1],[-1,-1,-1,-1,-1,-1]]\nOutput: [0,1,2,3,4,-1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == grid.length
    • \n\t
  • n == grid[i].length
    • \n\t
  • 1 <= m, n <= 100
    • \n\t
  • grid[i][j] is 1 or -1.
    • \n
\n
" }, { "path": "1710-maximum-units-on-a-truck/1710-maximum-units-on-a-truck.java", "content": "class Solution {\n public int maximumUnits(int[][] boxTypes, int truckSize) {\n int units = 0;\n \n int [] unitsVsBoxesCount = new int[1001];//value = number of boxes with i units per box\n for(int [] boxType : boxTypes) { //O(N)\n unitsVsBoxesCount[ boxType[1] ] += boxType[0];\n }\n for(int i = 1000; i > 0; i--) { //O(1001) = O(1)\n if(unitsVsBoxesCount[i] > truckSize) {\n units += (truckSize * i);\n break;\n } else if (unitsVsBoxesCount[i] > 0) {\n units += (unitsVsBoxesCount[i] * i);\n truckSize -= unitsVsBoxesCount[i];\n }\n }\n return units;\n }\n}" }, { "path": "1710-maximum-units-on-a-truck/NOTES.md", "content": "​" }, { "path": "1710-maximum-units-on-a-truck/README.md", "content": "

1710. Maximum Units on a Truck

Easy

You are assigned to put some amount of boxes onto one truck. You are given a 2D array boxTypes, where boxTypes[i] = [numberOfBoxesi, numberOfUnitsPerBoxi]:

\n\n
    \n\t
  • numberOfBoxesi is the number of boxes of type i.
    • \n\t
  • numberOfUnitsPerBoxi is the number of units in each box of the type i.
    • \n
\n\n

You are also given an integer truckSize, which is the maximum number of boxes that can be put on the truck. You can choose any boxes to put on the truck as long as the number of boxes does not exceed truckSize.

\n\n

Return the maximum total number of units that can be put on the truck.

\n\n

 

\n

Example 1:

\n\n
Input: boxTypes = [[1,3],[2,2],[3,1]], truckSize = 4\nOutput: 8\nExplanation: There are:\n- 1 box of the first type that contains 3 units.\n- 2 boxes of the second type that contain 2 units each.\n- 3 boxes of the third type that contain 1 unit each.\nYou can take all the boxes of the first and second types, and one box of the third type.\nThe total number of units will be = (1 * 3) + (2 * 2) + (1 * 1) = 8.\n
\n\n

Example 2:

\n\n
Input: boxTypes = [[5,10],[2,5],[4,7],[3,9]], truckSize = 10\nOutput: 91\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= boxTypes.length <= 1000
    • \n\t
  • 1 <= numberOfBoxesi, numberOfUnitsPerBoxi <= 1000
    • \n\t
  • 1 <= truckSize <= 106
    • \n
\n
" }, { "path": "1721-swapping-nodes-in-a-linked-list/1721-swapping-nodes-in-a-linked-list.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode swapNodes(ListNode head, int k) {\n \n ListNode fast=head; \n ListNode slow=head; \n int count=1;\n while(fast !=null && count 1721. Swapping Nodes in a Linked List

Medium

You are given the head of a linked list, and an integer k.

\n\n

Return the head of the linked list after swapping the values of the kth node from the beginning and the kth node from the end (the list is 1-indexed).

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,3,4,5], k = 2\nOutput: [1,4,3,2,5]\n
\n\n

Example 2:

\n\n
Input: head = [7,9,6,6,7,8,3,0,9,5], k = 5\nOutput: [7,9,6,6,8,7,3,0,9,5]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is n.
    • \n\t
  • 1 <= k <= n <= 105
    • \n\t
  • 0 <= Node.val <= 100
    • \n
\n
" }, { "path": "173-binary-search-tree-iterator/173-binary-search-tree-iterator.java", "content": "class BSTIterator {\n \n Deque stack = new ArrayDeque<>();\n\n public BSTIterator(TreeNode root) {\n pushLeft(root);\n }\n \n public int next() {\n TreeNode node = stack.pollFirst();\n pushLeft(node.right);\n return node.val;\n }\n \n public boolean hasNext() {\n return !stack.isEmpty();\n }\n \n private void pushLeft(TreeNode root) {\n while (root != null) {\n stack.addFirst(root);\n root = root.left;\n }\n }\n}" }, { "path": "173-binary-search-tree-iterator/NOTES.md", "content": "​" }, { "path": "173-binary-search-tree-iterator/binary-search-tree-iterator.cpp", "content": "#include\nclass BSTIterator { \n//I use Stack to store directed left children from root. \n// When next() be called, I just pop one element and process its right child as new root.\n stack stack;\npublic: \n BSTIterator(TreeNode* root) {\n addElements(root);\n }\n \n int next() {\n TreeNode* temp = stack.top();\n stack.pop();\n addElements(temp->right);\n return temp->val;\n }\n \n bool hasNext() {\n return !stack.empty();\n }\nprivate:\n void addElements(TreeNode* node){\n for(;node != NULL; stack.push(node), node=node->left);\n }\n};\n" }, { "path": "1742. Maximum Number of Balls in a Box(leetcode)", "content": "class Solution {\n public int countBalls(int lowLimit, int highLimit) {\n Mapmap=new HashMap<>();\n int res=0;\n for(int i=lowLimit;i<=highLimit;i++){\n int d=digitSum(i);\n map.put(d,map.getOrDefault(d,0)+1);\n res=Math.max(res,map.get(d));\n }return res;\n }\n \n public int digitSum(int num){\n int sum=0;\n while(num!=0){\n sum=sum+(num%10);\n num=num/10;\n }return sum;\n }\n}\n" }, { "path": "1770 Maximum Score from Performing Multiplication Operations lc.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n int m, n;\n int dfs(vector& nums, vector& mult, vector>& dp, int i, int j) {\n // i : *ptr at nums\n // j : *ptr at mult\n // if performed all oper, return 0\n if (j == m) return 0;\n // memoizated before - return the value here\n if (dp[i][j] != INT_MIN) return dp[i][j];\n return dp[i][j] = max(\n mult[j] * nums[i] + dfs(nums, mult, dp, i + 1, j + 1),\n mult[j] * nums[n - 1 - j + i] + dfs(nums, mult, dp, i, j + 1)\n ); \n }\n int maximumScore(vector& nums, vector& multipliers) {\n n = (int) nums.size(), m = (int) multipliers.size();\n\t\t// init values that couldn't be reached. -1 will cause TLE. -2 would pass but it's not supposed to pass.\n vector> dp(m, vector(m, INT_MIN));\n // or u can return dp[0][0] after running dfs\n return dfs(nums, multipliers, dp, 0, 0);\n }\n};" }, { "path": "1770-maximum-score-from-performing-multiplication-operations/1770-maximum-score-from-performing-multiplication-operations.java", "content": "class Solution {\n public int maximumScore(int[] nums, int[] multipliers) {\n // For Right Pointer\n int n = nums.length;\n // Number of Operations\n int m = multipliers.length;\n int[][] dp = new int[m + 1][m + 1];\n \n for (int op = m - 1; op >= 0; op--) {\n for (int left = op; left >= 0; left--) {\n dp[op][left] = Math.max(multipliers[op] * nums[left] + dp[op + 1][left + 1],\n multipliers[op] * nums[n - 1 - (op - left)] + dp[op + 1][left]);\n }\n }\n \n return dp[0][0];\n }\n}" }, { "path": "1770-maximum-score-from-performing-multiplication-operations/NOTES.md", "content": "​" }, { "path": "1770-maximum-score-from-performing-multiplication-operations/README.md", "content": "

1770. Maximum Score from Performing Multiplication Operations

Medium

You are given two integer arrays nums and multipliers of size n and m respectively, where n >= m. The arrays are 1-indexed.

\n\n

You begin with a score of 0. You want to perform exactly m operations. On the ith operation (1-indexed), you will:

\n\n
    \n\t
  • Choose one integer x from either the start or the end of the array nums.
    • \n\t
  • Add multipliers[i] * x to your score.
    • \n\t
  • Remove x from the array nums.
    • \n
\n\n

Return the maximum score after performing m operations.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3], multipliers = [3,2,1]\nOutput: 14\nExplanation: An optimal solution is as follows:\n- Choose from the end, [1,2,3], adding 3 * 3 = 9 to the score.\n- Choose from the end, [1,2], adding 2 * 2 = 4 to the score.\n- Choose from the end, [1], adding 1 * 1 = 1 to the score.\nThe total score is 9 + 4 + 1 = 14.
\n\n

Example 2:

\n\n
Input: nums = [-5,-3,-3,-2,7,1], multipliers = [-10,-5,3,4,6]\nOutput: 102\nExplanation: An optimal solution is as follows:\n- Choose from the start, [-5,-3,-3,-2,7,1], adding -5 * -10 = 50 to the score.\n- Choose from the start, [-3,-3,-2,7,1], adding -3 * -5 = 15 to the score.\n- Choose from the start, [-3,-2,7,1], adding -3 * 3 = -9 to the score.\n- Choose from the end, [-2,7,1], adding 1 * 4 = 4 to the score.\n- Choose from the end, [-2,7], adding 7 * 6 = 42 to the score. \nThe total score is 50 + 15 - 9 + 4 + 42 = 102.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == nums.length
    • \n\t
  • m == multipliers.length
    • \n\t
  • 1 <= m <= 103
    • \n\t
  • m <= n <= 105
    • \n\t
  • -1000 <= nums[i], multipliers[i] <= 1000
    • \n
\n
" }, { "path": "179-Largest Number.java", "content": "// Heres the simple solution:\n\n// Runtime: 6ms\n// Memory: 42 MB\n// Faster than: 81.48%\n\nclass Solution {\n public String largestNumber(int[] nums) {\n int n= nums.length;\n String [] s = new String[n];\n for(int i = 0; i < n; i++)\n s[i] = \"\"+nums[i];\n \n Arrays.sort(s, (a, b) -> (b+a).compareTo(a+b));\n \n StringBuilder sb = new StringBuilder();\n for(String str: s)\n sb.append(str);\n \n String result = sb+\"\";\n return result.startsWith(\"0\")? \"0\" : result;\n }\n}\n" }, { "path": "1791. Find Center of Star Graph.java", "content": "class Solution {\n public int findCenter(int[][] edges) {\n int n=edges.length;\n List> adj=new ArrayList<>();\n \n for(int i=0;i<=n+1;i++){\n ArrayList list=new ArrayList<>();\n adj.add(list);\n }\n \n for(int i=0;i1832. Check if the Sentence Is Pangram

Easy

A pangram is a sentence where every letter of the English alphabet appears at least once.

\n\n

Given a string sentence containing only lowercase English letters, return true if sentence is a pangram, or false otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: sentence = \"thequickbrownfoxjumpsoverthelazydog\"\nOutput: true\nExplanation: sentence contains at least one of every letter of the English alphabet.\n
\n\n

Example 2:

\n\n
Input: sentence = \"leetcode\"\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= sentence.length <= 1000
    • \n\t
  • sentence consists of lowercase English letters.
    • \n
\n
" }, { "path": "1833-maximum-ice-cream-bars/1833-maximum-ice-cream-bars.java", "content": "class Solution {\n public int maxIceCream(int[] costs, int coins) {\n int maxCost = 0;\n\n for (int cost : costs) {\n if (cost > maxCost) {\n maxCost = cost;\n }\n }\n\n int[] numOfCosts = new int[maxCost + 1];\n\n for (int cost : costs) {\n numOfCosts[cost]++;\n }\n\n int iceCreamBars = 0;\n\n for (int cost = 1; cost <= maxCost; cost++) {\n if (numOfCosts[cost] == 0) {\n continue;\n }\n\n if (coins < cost) {\n break;\n }\n\n int count = Math.min(numOfCosts[cost], coins / cost);\n coins -= count * cost;\n iceCreamBars += count;\n }\n\n return iceCreamBars;\n }\n}" }, { "path": "1833-maximum-ice-cream-bars/NOTES.md", "content": "​" }, { "path": "1833-maximum-ice-cream-bars/README.md", "content": "

1833. Maximum Ice Cream Bars

Medium

It is a sweltering summer day, and a boy wants to buy some ice cream bars.

\n\n

At the store, there are n ice cream bars. You are given an array costs of length n, where costs[i] is the price of the ith ice cream bar in coins. The boy initially has coins coins to spend, and he wants to buy as many ice cream bars as possible. 

\n\n

Return the maximum number of ice cream bars the boy can buy with coins coins.

\n\n

Note: The boy can buy the ice cream bars in any order.

\n\n

 

\n

Example 1:

\n\n
Input: costs = [1,3,2,4,1], coins = 7\nOutput: 4\nExplanation: The boy can buy ice cream bars at indices 0,1,2,4 for a total price of 1 + 3 + 2 + 1 = 7.\n
\n\n

Example 2:

\n\n
Input: costs = [10,6,8,7,7,8], coins = 5\nOutput: 0\nExplanation: The boy cannot afford any of the ice cream bars.\n
\n\n

Example 3:

\n\n
Input: costs = [1,6,3,1,2,5], coins = 20\nOutput: 6\nExplanation: The boy can buy all the ice cream bars for a total price of 1 + 6 + 3 + 1 + 2 + 5 = 18.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • costs.length == n
    • \n\t
  • 1 <= n <= 105
    • \n\t
  • 1 <= costs[i] <= 105
    • \n\t
  • 1 <= coins <= 108
    • \n
" }, { "path": "1834-single-threaded-cpu/1834-single-threaded-cpu.java", "content": "class Solution {\n public int[] getOrder(int[][] tasks) {\n \n // Sort based on min task processing time or min task index.\n // Store enqueue time, processing time, task index.\n PriorityQueue nextTask = new PriorityQueue((a, b) -> (a[1] != b[1] ? (a[1] - b[1]) : (a[2] - b[2])));\n \n // Store task enqueue time, processing time, index.\n int sortedTasks[][] = new int[tasks.length][3];\n for (int i = 0; i < tasks.length; ++i) {\n sortedTasks[i][0] = tasks[i][0];\n sortedTasks[i][1] = tasks[i][1];\n sortedTasks[i][2] = i;\n }\n \n Arrays.sort(sortedTasks, (a, b) -> Integer.compare(a[0], b[0]));\n int tasksProcessingOrder[] = new int[tasks.length];\n \n long currTime = 0;\n int taskIndex = 0;\n int ansIndex = 0;\n \n // Stop when no tasks are left in array and heap.\n while (taskIndex < tasks.length || !nextTask.isEmpty()) {\n if (nextTask.isEmpty() && currTime < sortedTasks[taskIndex][0]) {\n // When the heap is empty, try updating currTime to next task's enqueue time. \n currTime = sortedTasks[taskIndex][0];\n }\n \n // Push all the tasks whose enqueueTime <= currtTime into the heap.\n while (taskIndex < tasks.length && currTime >= sortedTasks[taskIndex][0]) { \n nextTask.add(sortedTasks[taskIndex]);\n ++taskIndex;\n }\n \n int processTime = nextTask.peek()[1];\n int index = nextTask.peek()[2];\n nextTask.remove();\n \n // Complete this task and increment currTime.\n currTime += processTime; \n tasksProcessingOrder[ansIndex++] = index;\n }\n \n return tasksProcessingOrder;\n }\n}" }, { "path": "1834-single-threaded-cpu/NOTES.md", "content": "​" }, { "path": "1834-single-threaded-cpu/README.md", "content": "

1834. Single-Threaded CPU

Medium

You are given n​​​​​​ tasks labeled from 0 to n - 1 represented by a 2D integer array tasks, where tasks[i] = [enqueueTimei, processingTimei] means that the i​​​​​​th​​​​ task will be available to process at enqueueTimei and will take processingTimei to finish processing.

\n\n

You have a single-threaded CPU that can process at most one task at a time and will act in the following way:

\n\n
    \n\t
  • If the CPU is idle and there are no available tasks to process, the CPU remains idle.
    • \n\t
  • If the CPU is idle and there are available tasks, the CPU will choose the one with the shortest processing time. If multiple tasks have the same shortest processing time, it will choose the task with the smallest index.
    • \n\t
  • Once a task is started, the CPU will process the entire task without stopping.
    • \n\t
  • The CPU can finish a task then start a new one instantly.
    • \n
\n\n

Return the order in which the CPU will process the tasks.

\n\n

 

\n

Example 1:

\n\n
Input: tasks = [[1,2],[2,4],[3,2],[4,1]]\nOutput: [0,2,3,1]\nExplanation: The events go as follows: \n- At time = 1, task 0 is available to process. Available tasks = {0}.\n- Also at time = 1, the idle CPU starts processing task 0. Available tasks = {}.\n- At time = 2, task 1 is available to process. Available tasks = {1}.\n- At time = 3, task 2 is available to process. Available tasks = {1, 2}.\n- Also at time = 3, the CPU finishes task 0 and starts processing task 2 as it is the shortest. Available tasks = {1}.\n- At time = 4, task 3 is available to process. Available tasks = {1, 3}.\n- At time = 5, the CPU finishes task 2 and starts processing task 3 as it is the shortest. Available tasks = {1}.\n- At time = 6, the CPU finishes task 3 and starts processing task 1. Available tasks = {}.\n- At time = 10, the CPU finishes task 1 and becomes idle.\n
\n\n

Example 2:

\n\n
Input: tasks = [[7,10],[7,12],[7,5],[7,4],[7,2]]\nOutput: [4,3,2,0,1]\nExplanation: The events go as follows:\n- At time = 7, all the tasks become available. Available tasks = {0,1,2,3,4}.\n- Also at time = 7, the idle CPU starts processing task 4. Available tasks = {0,1,2,3}.\n- At time = 9, the CPU finishes task 4 and starts processing task 3. Available tasks = {0,1,2}.\n- At time = 13, the CPU finishes task 3 and starts processing task 2. Available tasks = {0,1}.\n- At time = 18, the CPU finishes task 2 and starts processing task 0. Available tasks = {1}.\n- At time = 28, the CPU finishes task 0 and starts processing task 1. Available tasks = {}.\n- At time = 40, the CPU finishes task 1 and becomes idle.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • tasks.length == n
    • \n\t
  • 1 <= n <= 105
    • \n\t
  • 1 <= enqueueTimei, processingTimei <= 109
    • \n
\n
" }, { "path": "188-best-time-to-buy-and-sell-stock-iv/188-best-time-to-buy-and-sell-stock-iv.java", "content": "class Solution {\n \n \n public int maxProfit(int k, int[] prices) {\n return DP(prices, k);\n }\n \n private int DP(int[] prices, int k) {\n int[] costs = new int[k+1];\n int[] profits = new int[k+1];\n //costs[0] = prices[0];\n Arrays.fill(costs, Integer.MAX_VALUE);\n \n for (int currentPrice : prices) {\n for (int i = 0; i < k; i++) {\n costs[i+1] = Math.min(costs[i+1], currentPrice - profits[i]);\n profits[i+1] = Math.max(profits[i+1], currentPrice - costs[i+1]);\n }\n }\n \n return profits[k];\n \n }\n}" }, { "path": "188-best-time-to-buy-and-sell-stock-iv/NOTES.md", "content": "​" }, { "path": "188-best-time-to-buy-and-sell-stock-iv/README.md", "content": "

188. Best Time to Buy and Sell Stock IV

Hard

You are given an integer array prices where prices[i] is the price of a given stock on the ith day, and an integer k.

\n\n

Find the maximum profit you can achieve. You may complete at most k transactions.

\n\n

Note: You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).

\n\n

 

\n

Example 1:

\n\n
Input: k = 2, prices = [2,4,1]\nOutput: 2\nExplanation: Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.\n
\n\n

Example 2:

\n\n
Input: k = 2, prices = [3,2,6,5,0,3]\nOutput: 7\nExplanation: Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= k <= 100
    • \n\t
  • 0 <= prices.length <= 1000
    • \n\t
  • 0 <= prices[i] <= 1000
    • \n
\n
" }, { "path": "188. Best Time to Buy and Sell Stock IV.cpp", "content": "class Solution {\npublic:\n int maxProfit(int k, vector& prices) {\n if(k==0) return 0; // no transaction no profit \n vector> dp(k+1, vector(2));\n // initialise\n // dp[k][0] - min cost that you need to spend on a stock\n // dp[k][1] - max profit that you can gain from a stock\n for(int i=0;i<=k;i++) dp[i][0] = INT_MAX;\n for(auto &price : prices){\n for(int i=1;i<=k;i++){\n // price - dp[i - 1][1] is how much you need to spend\n // i.e use the profit you earned from previous transaction to buy the stock\n // we want to minimize it\n dp[i][0] = min(dp[i][0], price - dp[i-1][1]);\n // price - dp[i][0] is how much you can achieve from previous min cost\n // we want to maximize it\n dp[i][1] = max(dp[i][1], price - dp[i][0]);\n }\n }\n // return max profit at most k transactions\n // or you can use `return dp.back()[1];\n return dp[k][1];\n }\n};\n" }, { "path": "19-remove-nth-node-from-end-of-list/19-remove-nth-node-from-end-of-list.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode removeNthFromEnd(ListNode head, int n) {\n if(head.next==null && n==1)return null;\n ListNode temp=head;\n int length=0;\n while(temp!=null){\n length++;\n temp=temp.next;\n }\n if(length==n)return head.next;\n ListNode tem=head;\n for(int i=1;i19. Remove Nth Node From End of List

Medium

Given the head of a linked list, remove the nth node from the end of the list and return its head.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,3,4,5], n = 2\nOutput: [1,2,3,5]\n
\n\n

Example 2:

\n\n
Input: head = [1], n = 1\nOutput: []\n
\n\n

Example 3:

\n\n
Input: head = [1,2], n = 1\nOutput: [1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is sz.
    • \n\t
  • 1 <= sz <= 30
    • \n\t
  • 0 <= Node.val <= 100
    • \n\t
  • 1 <= n <= sz
    • \n
\n\n

 

\n

Follow up: Could you do this in one pass?

\n
" }, { "path": "191-number-of-1-bits/191-number-of-1-bits.java", "content": "public class Solution {\n public int hammingWeight(int n) { \n int count = 0;\n while (n != 0) {\n n=n&(n-1);\n count++;\n }\n return count;\n }\n}" }, { "path": "191-number-of-1-bits/NOTES.md", "content": "​" }, { "path": "191-number-of-1-bits/README.md", "content": "

191. Number of 1 Bits

Easy

Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the Hamming weight).

\n\n

Note:

\n\n
    \n\t
  • Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
    • \n\t
  • In Java, the compiler represents the signed integers using 2's complement notation. Therefore, in Example 3, the input represents the signed integer. -3.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input: n = 00000000000000000000000000001011\nOutput: 3\nExplanation: The input binary string 00000000000000000000000000001011 has a total of three '1' bits.\n
\n\n

Example 2:

\n\n
Input: n = 00000000000000000000000010000000\nOutput: 1\nExplanation: The input binary string 00000000000000000000000010000000 has a total of one '1' bit.\n
\n\n

Example 3:

\n\n
Input: n = 11111111111111111111111111111101\nOutput: 31\nExplanation: The input binary string 11111111111111111111111111111101 has a total of thirty one '1' bits.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The input must be a binary string of length 32.
    • \n
\n\n

 

\nFollow up: If this function is called many times, how would you optimize it?
" }, { "path": "1926-nearest-exit-from-entrance-in-maze/1926-nearest-exit-from-entrance-in-maze.java", "content": "class Solution {\n public int nearestExit(char[][] maze, int[] entrance) {\n int m = maze.length;\n int n = maze[0].length;\n \n Queue q = new LinkedList<>();\n int ei = entrance[0];\n int ej = entrance[1];\n int[][] dvs = new int[][] {\n {1, 0}, {0, 1}, {-1, 0}, {0, -1} \n };\n \n maze[ei][ej] = '+';\n q.add(new int[] {ei, ej, 0});\n \n while(!q.isEmpty()) {\n int[] val = q.poll();\n \n for (int[] d: dvs) {\n int i1 = val[0] + d[0];\n int j1 = val[1] + d[1];\n \n if (i1 < 0 || j1 < 0 || i1 >= m || j1 >= n) {\n if (val[0] == ei && val[1] == ej) continue;\n return val[2];\n }\n \n if (maze[i1][j1] == '.') {\n q.add(new int[] {i1, j1, val[2] + 1});\n maze[i1][j1] = '+';\n }\n }\n }\n \n return -1;\n }\n}" }, { "path": "1926-nearest-exit-from-entrance-in-maze/NOTES.md", "content": "​" }, { "path": "1926-nearest-exit-from-entrance-in-maze/README.md", "content": "

1926. Nearest Exit from Entrance in Maze

Medium

You are given an m x n matrix maze (0-indexed) with empty cells (represented as '.') and walls (represented as '+'). You are also given the entrance of the maze, where entrance = [entrancerow, entrancecol] denotes the row and column of the cell you are initially standing at.

\n\n

In one step, you can move one cell up, down, left, or right. You cannot step into a cell with a wall, and you cannot step outside the maze. Your goal is to find the nearest exit from the entrance. An exit is defined as an empty cell that is at the border of the maze. The entrance does not count as an exit.

\n\n

Return the number of steps in the shortest path from the entrance to the nearest exit, or -1 if no such path exists.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: maze = [[\"+\",\"+\",\".\",\"+\"],[\".\",\".\",\".\",\"+\"],[\"+\",\"+\",\"+\",\".\"]], entrance = [1,2]\nOutput: 1\nExplanation: There are 3 exits in this maze at [1,0], [0,2], and [2,3].\nInitially, you are at the entrance cell [1,2].\n- You can reach [1,0] by moving 2 steps left.\n- You can reach [0,2] by moving 1 step up.\nIt is impossible to reach [2,3] from the entrance.\nThus, the nearest exit is [0,2], which is 1 step away.\n
\n\n

Example 2:

\n\"\"\n
Input: maze = [[\"+\",\"+\",\"+\"],[\".\",\".\",\".\"],[\"+\",\"+\",\"+\"]], entrance = [1,0]\nOutput: 2\nExplanation: There is 1 exit in this maze at [1,2].\n[1,0] does not count as an exit since it is the entrance cell.\nInitially, you are at the entrance cell [1,0].\n- You can reach [1,2] by moving 2 steps right.\nThus, the nearest exit is [1,2], which is 2 steps away.\n
\n\n

Example 3:

\n\"\"\n
Input: maze = [[\".\",\"+\"]], entrance = [0,0]\nOutput: -1\nExplanation: There are no exits in this maze.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • maze.length == m
    • \n\t
  • maze[i].length == n
    • \n\t
  • 1 <= m, n <= 100
    • \n\t
  • maze[i][j] is either '.' or '+'.
    • \n\t
  • entrance.length == 2
    • \n\t
  • 0 <= entrancerow < m
    • \n\t
  • 0 <= entrancecol < n
    • \n\t
  • entrance will always be an empty cell.
    • \n
\n
" }, { "path": "1962-remove-stones-to-minimize-the-total/1962-remove-stones-to-minimize-the-total.java", "content": "public class Solution {\n public int minStoneSum(int[] piles, int k) {\n int sum = 0;\n int a[] = new int[10001];\n for (int i : piles) {\n sum += i;\n a[i]++;\n }\n for (int i = 10000; i > 0 && k > 0; i--) {\n if (a[i] > 0) {\n int b = i / 2;\n sum -= Math.min(k, a[i]) * b;\n a[i - i / 2] += a[i];\n k -= a[i];\n }\n }\n return sum;\n\n }\n}" }, { "path": "1962-remove-stones-to-minimize-the-total/NOTES.md", "content": "​" }, { "path": "1962-remove-stones-to-minimize-the-total/README.md", "content": "

1962. Remove Stones to Minimize the Total

Medium

You are given a 0-indexed integer array piles, where piles[i] represents the number of stones in the ith pile, and an integer k. You should apply the following operation exactly k times:

\n\n
    \n\t
  • Choose any piles[i] and remove floor(piles[i] / 2) stones from it.
    • \n
\n\n

Notice that you can apply the operation on the same pile more than once.

\n\n

Return the minimum possible total number of stones remaining after applying the k operations.

\n\n

floor(x) is the greatest integer that is smaller than or equal to x (i.e., rounds x down).

\n\n

 

\n

Example 1:

\n\n
Input: piles = [5,4,9], k = 2\nOutput: 12\nExplanation: Steps of a possible scenario are:\n- Apply the operation on pile 2. The resulting piles are [5,4,5].\n- Apply the operation on pile 0. The resulting piles are [3,4,5].\nThe total number of stones in [3,4,5] is 12.\n
\n\n

Example 2:

\n\n
Input: piles = [4,3,6,7], k = 3\nOutput: 12\nExplanation: Steps of a possible scenario are:\n- Apply the operation on pile 2. The resulting piles are [4,3,3,7].\n- Apply the operation on pile 3. The resulting piles are [4,3,3,4].\n- Apply the operation on pile 0. The resulting piles are [2,3,3,4].\nThe total number of stones in [2,3,3,4] is 12.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= piles.length <= 105
    • \n\t
  • 1 <= piles[i] <= 104
    • \n\t
  • 1 <= k <= 105
    • \n
\n
" }, { "path": "1971-find-if-path-exists-in-graph/1971-find-if-path-exists-in-graph.java", "content": "class Solution {\n public boolean validPath(int n, int[][] edges, int start, int end) {\n boolean[] visited = new boolean[n];\n visited[start] = true;\n \n boolean newVisited = true;\n \n while(!visited[end] && newVisited) {\n newVisited = false;\n for (int i = edges.length - 1; i > -1; i--) {\n if (visited[edges[i][0]]) {\n if (!visited[edges[i][1]]) {\n newVisited = visited[edges[i][1]] = true;\n }\n } else if (visited[edges[i][1]]){\n newVisited = visited[edges[i][0]] = true;\n }\n }\n }\n \n return visited[end];\n }\n}" }, { "path": "1971-find-if-path-exists-in-graph/README.md", "content": "

1971. Find if Path Exists in Graph

Easy

There is a bi-directional graph with n vertices, where each vertex is labeled from 0 to n - 1 (inclusive). The edges in the graph are represented as a 2D integer array edges, where each edges[i] = [ui, vi] denotes a bi-directional edge between vertex ui and vertex vi. Every vertex pair is connected by at most one edge, and no vertex has an edge to itself.

\n\n

You want to determine if there is a valid path that exists from vertex source to vertex destination.

\n\n

Given edges and the integers n, source, and destination, return true if there is a valid path from source to destination, or false otherwise.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 3, edges = [[0,1],[1,2],[2,0]], source = 0, destination = 2\nOutput: true\nExplanation: There are two paths from vertex 0 to vertex 2:\n- 0 → 1 → 2\n- 0 → 2\n
\n\n

Example 2:

\n\"\"\n
Input: n = 6, edges = [[0,1],[0,2],[3,5],[5,4],[4,3]], source = 0, destination = 5\nOutput: false\nExplanation: There is no path from vertex 0 to vertex 5.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 2 * 105
    • \n\t
  • 0 <= edges.length <= 2 * 105
    • \n\t
  • edges[i].length == 2
    • \n\t
  • 0 <= ui, vi <= n - 1
    • \n\t
  • ui != vi
    • \n\t
  • 0 <= source, destination <= n - 1
    • \n\t
  • There are no duplicate edges.
    • \n\t
  • There are no self edges.
    • \n
\n
" }, { "path": "199-binary-tree-right-side-view/199-binary-tree-right-side-view.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public List rightSideView(TreeNode root) {\n List list=new ArrayList<>();\n int level=0;\n rightView(root,list,level);\n return list;\n }\n void rightView(TreeNode root,List list,int level){\n if(root==null)return;\n \n if(level==list.size()){\n list.add(root.val);\n }\n \n rightView(root.right,list,level+1);\n rightView(root.left,list,level+1);\n } \n}" }, { "path": "199-binary-tree-right-side-view/NOTES.md", "content": "​" }, { "path": "199-binary-tree-right-side-view/README.md", "content": "

199. Binary Tree Right Side View

Medium

Given the root of a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,3,null,5,null,4]\nOutput: [1,3,4]\n
\n\n

Example 2:

\n\n
Input: root = [1,null,3]\nOutput: [1,3]\n
\n\n

Example 3:

\n\n
Input: root = []\nOutput: []\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 100].
    • \n\t
  • -100 <= Node.val <= 100
    • \n
\n
" }, { "path": "1991-find-the-middle-index-in-array/1991-find-the-middle-index-in-array.java", "content": "class Solution {\n public int findMiddleIndex(int[] nums) {\n int sum=0;\n for(int n:nums){\n sum+=n;\n }\n int left=0;\n for(int i=0;i1991. Find the Middle Index in Array

Easy

Given a 0-indexed integer array nums, find the leftmost middleIndex (i.e., the smallest amongst all the possible ones).

\n\n

A middleIndex is an index where nums[0] + nums[1] + ... + nums[middleIndex-1] == nums[middleIndex+1] + nums[middleIndex+2] + ... + nums[nums.length-1].

\n\n

If middleIndex == 0, the left side sum is considered to be 0. Similarly, if middleIndex == nums.length - 1, the right side sum is considered to be 0.

\n\n

Return the leftmost middleIndex that satisfies the condition, or -1 if there is no such index.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [2,3,-1,8,4]\nOutput: 3\nExplanation: The sum of the numbers before index 3 is: 2 + 3 + -1 = 4\nThe sum of the numbers after index 3 is: 4 = 4\n
\n\n

Example 2:

\n\n
Input: nums = [1,-1,4]\nOutput: 2\nExplanation: The sum of the numbers before index 2 is: 1 + -1 = 0\nThe sum of the numbers after index 2 is: 0\n
\n\n

Example 3:

\n\n
Input: nums = [2,5]\nOutput: -1\nExplanation: There is no valid middleIndex.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 100
    • \n\t
  • -1000 <= nums[i] <= 1000
    • \n
\n\n

 

\n

Note: This question is the same as 724: https://leetcode.com/problems/find-pivot-index/

\n
" }, { "path": "1996-the-number-of-weak-characters-in-the-game/1996-the-number-of-weak-characters-in-the-game.cpp", "content": "#include\nusing namespace std;\n\nclass Solution{\n public:\n // using hash_map + STL\n // approach\n /*\n rearrange order of attach in asc order\n count weak chars(those defense less than curr maxi defense)\n update maxidefense\n */\n int numberOfWeakCharacters(vector>& properties){\n int WC =0; // final res to be returned, WC = weak chars\n // return maxiDefense since 1 <= defense[i] <= 10^5, set inti value to x sinec x <1\n int maxiDefense =0;\n // using hash_map to map the attack and defense with greater as a key compare\n map, greater> mp;\n for(auto x : properties) mp[x[0]].push_back(x[1]);\n // foreach attack\n for(auto x : mp){\n // count num of weakchar and add it to WC, count_if() returns the number of elements in the given sequence for which the comparator function (third parameter) returns true.\n // STL iterator ==> x.second.begin() => __first, x.second.end() => __last, [&](int currDefense) => predicate \n WC+= count_if(x.second.begin(), x.second.end(), [&](int currDefense){\n return currDefense < maxiDefense;\n });\n // update maxidefense which is the maxi value of currdefense\n maxiDefense = max(maxiDefense, *max_element(x.second.begin(), x.second.end()));\n\n }\n return WC;\n\n\n }\n};\n" }, { "path": "1996-the-number-of-weak-characters-in-the-game/1996-the-number-of-weak-characters-in-the-game.java", "content": "class Solution {\n public int numberOfWeakCharacters(int[][] prop) {\n \n /** Solution\n 1. here we sort the array in the increasing order of attack\n 1.1 if two attack has a same value then we sort the decreasing order of defense\n \n 2. compare the defense value and increasing answer count\n 2.1 chnage the defense value if it is greater\n \n \n */\n //if attack same then decreasing order of defense else increasing order of attack\n Arrays.sort(prop,(a,b)-> a[0]==b[0]? b[1]-a[1] : a[0]-b[0]);\n \n int min=Integer.MIN_VALUE;\n int ans=0;\n \n for(int i=prop.length-1;i>=0;i--){\n int[] arr=prop[i];\n int att=arr[0];\n int def=arr[1];\n \n if(def= 0; i--) {\n maxDefense[i] = Math.max(maxDefense[i], maxDefense[i + 1]);\n }\n \n int weakCharacters = 0;\n for (int[] property : properties) {\n int attack = property[0];\n int defense = property[1];\n \n // If their is a greater defense for properties with greater attack\n if (defense < maxDefense[attack + 1]) {\n weakCharacters++;\n }\n }\n \n return weakCharacters;\n }\n}\n" }, { "path": "1996-the-number-of-weak-characters-in-the-game/NOTES.md", "content": "​" }, { "path": "1996-the-number-of-weak-characters-in-the-game/README.md", "content": "

1996. The Number of Weak Characters in the Game

Medium

You are playing a game that contains multiple characters, and each of the characters has two main properties: attack and defense. You are given a 2D integer array properties where properties[i] = [attacki, defensei] represents the properties of the ith character in the game.

\n\n

A character is said to be weak if any other character has both attack and defense levels strictly greater than this character's attack and defense levels. More formally, a character i is said to be weak if there exists another character j where attackj > attacki and defensej > defensei.

\n\n

Return the number of weak characters.

\n\n

 

\n

Example 1:

\n\n
Input: properties = [[5,5],[6,3],[3,6]]\nOutput: 0\nExplanation: No character has strictly greater attack and defense than the other.\n
\n\n

Example 2:

\n\n
Input: properties = [[2,2],[3,3]]\nOutput: 1\nExplanation: The first character is weak because the second character has a strictly greater attack and defense.\n
\n\n

Example 3:

\n\n
Input: properties = [[1,5],[10,4],[4,3]]\nOutput: 1\nExplanation: The third character is weak because the second character has a strictly greater attack and defense.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= properties.length <= 105
    • \n\t
  • properties[i].length == 2
    • \n\t
  • 1 <= attacki, defensei <= 105
    • \n
\n
" }, { "path": "200-number-of-islands/200-number-of-islands.java", "content": "class Solution {\n public int numIslands(char[][] grid) {\n int ans=0;\n int n=grid.length;\n int m=grid[0].length;\n for(int i=0;i= grid.length || j >= grid[i].length || grid[i][j] == '0') return;\n grid[i][j] = '0';\n dfs(grid,i+1,j);\n dfs(grid,i-1,j);\n dfs(grid,i,j+1);\n dfs(grid,i,j-1);\n }\n}" }, { "path": "200-number-of-islands/NOTES.md", "content": "​" }, { "path": "200-number-of-islands/README.md", "content": "

200. Number of Islands

Medium

Given an m x n 2D binary grid grid which represents a map of '1's (land) and '0's (water), return the number of islands.

\n\n

An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are all surrounded by water.

\n\n

 

\n

Example 1:

\n\n
Input: grid = [\n  [\"1\",\"1\",\"1\",\"1\",\"0\"],\n  [\"1\",\"1\",\"0\",\"1\",\"0\"],\n  [\"1\",\"1\",\"0\",\"0\",\"0\"],\n  [\"0\",\"0\",\"0\",\"0\",\"0\"]\n]\nOutput: 1\n
\n\n

Example 2:

\n\n
Input: grid = [\n  [\"1\",\"1\",\"0\",\"0\",\"0\"],\n  [\"1\",\"1\",\"0\",\"0\",\"0\"],\n  [\"0\",\"0\",\"1\",\"0\",\"0\"],\n  [\"0\",\"0\",\"0\",\"1\",\"1\"]\n]\nOutput: 3\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == grid.length
    • \n\t
  • n == grid[i].length
    • \n\t
  • 1 <= m, n <= 300
    • \n\t
  • grid[i][j] is '0' or '1'.
    • \n
\n
" }, { "path": "2007 Find Original Array From Doubled Array lc.cpp", "content": "class Solution {\npublic:\n vector findOriginalArray(vector& changed) {\n// hashmap approach\n// if the len of i/p is odd return {}, because double array must have even len\n \n if(changed.size() & 1) return {};\n// count the freq of each number\n unordered_mapmp;\n for(auto x : changed) mp[x]++;\n vector res;\n// sort in asc\n sort(changed.begin(), changed.end());\n// keep the unique elements only in changed \n changed.erase(unique(changed.begin(), changed.end()), changed.end());\n// so that we can iterate from smallest to largest\n for(auto x : changed){\n// if the numb of x is greater than mp[x*2], there'd be some mp[x] left therefore return {} here as a changed isn't a double array\n if(mp[x] >mp[x*2]) return {};\n for(int i =0; i q=new LinkedList<>();\n Arrays.sort(c);\n \n int i=0;\n int j=0;\n int[] ans=new int[n/2];\n \n while(i0 && q.peek()==num){\n ans[j++]=q.poll()/2;\n }else{\n q.add(2*num);\n }\n i++;\n }\n \n return q.size()>0?new int[]{}:ans;\n \n }\n}\n\n\n//without sorting\n\nclass Solution {\n public int[] findOriginalArray(int[] changed) {\n if(changed.length%2 != 0) return new int[0];\n int max = Integer.MIN_VALUE;\n for(int num : changed) max = Math.max(max, num);\n if(max%2 != 0) return new int[0];\n \n int[] cnts = new int[max+1];\n for(int num : changed) cnts[num]++;\n \n int[] res = new int[changed.length/2];\n if(cnts[0] % 2 != 0) return new int[0];\n int idx = cnts[0]/2;\n for(int i = 1; i < cnts.length; i++) {\n if(cnts[i] == 0) continue;\n if(2*i > max || cnts[i] > cnts[2*i]) return new int[0];\n int cnt = cnts[i];\n cnts[2*i] -= cnt;\n while(cnt-- > 0) res[idx++] = i;\n }\n \n return res;\n }\n}class Solution {\n public int[] findOriginalArray(int[] changed) {\n if(changed.length%2 != 0) return new int[0];\n int max = Integer.MIN_VALUE;\n for(int num : changed) max = Math.max(max, num);\n if(max%2 != 0) return new int[0];\n \n int[] cnts = new int[max+1];\n for(int num : changed) cnts[num]++;\n \n int[] res = new int[changed.length/2];\n if(cnts[0] % 2 != 0) return new int[0];\n int idx = cnts[0]/2;\n for(int i = 1; i < cnts.length; i++) {\n if(cnts[i] == 0) continue;\n if(2*i > max || cnts[i] > cnts[2*i]) return new int[0];\n int cnt = cnts[i];\n cnts[2*i] -= cnt;\n while(cnt-- > 0) res[idx++] = i;\n }\n \n return res;\n }\n}\n" }, { "path": "2007-find-original-array-from-doubled-array/NOTES.md", "content": "​" }, { "path": "2007-find-original-array-from-doubled-array/README.md", "content": "

2007. Find Original Array From Doubled Array

Medium

An integer array original is transformed into a doubled array changed by appending twice the value of every element in original, and then randomly shuffling the resulting array.

\n\n

Given an array changed, return original if changed is a doubled array. If changed is not a doubled array, return an empty array. The elements in original may be returned in any order.

\n\n

 

\n

Example 1:

\n\n
Input: changed = [1,3,4,2,6,8]\nOutput: [1,3,4]\nExplanation: One possible original array could be [1,3,4]:\n- Twice the value of 1 is 1 * 2 = 2.\n- Twice the value of 3 is 3 * 2 = 6.\n- Twice the value of 4 is 4 * 2 = 8.\nOther original arrays could be [4,3,1] or [3,1,4].\n
\n\n

Example 2:

\n\n
Input: changed = [6,3,0,1]\nOutput: []\nExplanation: changed is not a doubled array.\n
\n\n

Example 3:

\n\n
Input: changed = [1]\nOutput: []\nExplanation: changed is not a doubled array.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= changed.length <= 105
    • \n\t
  • 0 <= changed[i] <= 105
    • \n
\n
" }, { "path": "2095-delete-the-middle-node-of-a-linked-list/2095-delete-the-middle-node-of-a-linked-list.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode deleteMiddle(ListNode head) {\n if(head.next==null)return null;\n ListNode prev=null;\n ListNode slow=head;\n ListNode fast=head;\n while(fast!=null && fast.next!=null){\n prev=slow;\n slow=slow.next;\n fast=fast.next.next;\n }\n prev.next=slow.next;\n return head;\n }\n}" }, { "path": "2095-delete-the-middle-node-of-a-linked-list/NOTES.md", "content": "​" }, { "path": "2131-longest-palindrome-by-concatenating-two-letter-words/2131-longest-palindrome-by-concatenating-two-letter-words.java", "content": "class Solution {\n public int longestPalindrome(String[] words) {\n int result=0;\n int[][]freq=new int[26][26];\n \n for(String s:words){\n int i=s.charAt(0)-'a';\n int j=s.charAt(1)-'a';\n if(freq[j][i]>0){\n freq[j][i]--;\n result+=4;\n }else{\n freq[i][j]++;\n }\n }\n \n for(int i=0;i<26;i++){\n if(freq[i][i]>0){\n result+=2;\n break;\n }\n }\n return result;\n }\n}" }, { "path": "2131-longest-palindrome-by-concatenating-two-letter-words/README.md", "content": "

2131. Longest Palindrome by Concatenating Two Letter Words

Medium

You are given an array of strings words. Each element of words consists of two lowercase English letters.

\n\n

Create the longest possible palindrome by selecting some elements from words and concatenating them in any order. Each element can be selected at most once.

\n\n

Return the length of the longest palindrome that you can create. If it is impossible to create any palindrome, return 0.

\n\n

A palindrome is a string that reads the same forward and backward.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"lc\",\"cl\",\"gg\"]\nOutput: 6\nExplanation: One longest palindrome is \"lc\" + \"gg\" + \"cl\" = \"lcggcl\", of length 6.\nNote that \"clgglc\" is another longest palindrome that can be created.\n
\n\n

Example 2:

\n\n
Input: words = [\"ab\",\"ty\",\"yt\",\"lc\",\"cl\",\"ab\"]\nOutput: 8\nExplanation: One longest palindrome is \"ty\" + \"lc\" + \"cl\" + \"yt\" = \"tylcclyt\", of length 8.\nNote that \"lcyttycl\" is another longest palindrome that can be created.\n
\n\n

Example 3:

\n\n
Input: words = [\"cc\",\"ll\",\"xx\"]\nOutput: 2\nExplanation: One longest palindrome is \"cc\", of length 2.\nNote that \"ll\" is another longest palindrome that can be created, and so is \"xx\".\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words.length <= 105
    • \n\t
  • words[i].length == 2
    • \n\t
  • words[i] consists of lowercase English letters.
    • \n
\n
" }, { "path": "2136-earliest-possible-day-of-full-bloom/2136-earliest-possible-day-of-full-bloom.java", "content": "class Solution {\n class Pair{\n int plantTime;\n int growTime;\n Pair(int a,int b){\n plantTime=a;\n growTime=b;\n }\n }\n public int earliestFullBloom(int[] plantTime, int[] growTime) {\n PriorityQueue pq=new PriorityQueue<>((a,b)->b.growTime-a.growTime);\n for(int i=0;i> combinationSum3(int k, int n) {\n List> res = new ArrayList<>();\n List out = new ArrayList<>();\n back(res,out,k,n,1);\n return res;\n }\n void back(List> res,List out,int currSize,int n,int limit)\n {\n if(out.size()==currSize && n ==0)\n {\n res.add(new ArrayList<>(out));\n return ;\n }\n if(limit>9)\n {\n return ;\n }\n \n if(out.size()>currSize)\n {\n return ;\n }\n if(n<0)\n {\n return ;\n }\n out.add(limit);\n back(res,out,currSize,n-limit,limit+1);\n out.remove(out.size()-1);\n back(res,out,currSize,n,limit+1);\n }\n}" }, { "path": "216-combination-sum-iii/NOTES.md", "content": "​" }, { "path": "216-combination-sum-iii/README.md", "content": "

216. Combination Sum III

Medium

Find all valid combinations of k numbers that sum up to n such that the following conditions are true:

\n\n
    \n\t
  • Only numbers 1 through 9 are used.
    • \n\t
  • Each number is used at most once.
    • \n
\n\n

Return a list of all possible valid combinations. The list must not contain the same combination twice, and the combinations may be returned in any order.

\n\n

 

\n

Example 1:

\n\n
Input: k = 3, n = 7\nOutput: [[1,2,4]]\nExplanation:\n1 + 2 + 4 = 7\nThere are no other valid combinations.
\n\n

Example 2:

\n\n
Input: k = 3, n = 9\nOutput: [[1,2,6],[1,3,5],[2,3,4]]\nExplanation:\n1 + 2 + 6 = 9\n1 + 3 + 5 = 9\n2 + 3 + 4 = 9\nThere are no other valid combinations.\n
\n\n

Example 3:

\n\n
Input: k = 4, n = 1\nOutput: []\nExplanation: There are no valid combinations.\nUsing 4 different numbers in the range [1,9], the smallest sum we can get is 1+2+3+4 = 10 and since 10 > 1, there are no valid combination.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= k <= 9
    • \n\t
  • 1 <= n <= 60
    • \n
\n
" }, { "path": "218-the-skyline-problem/218-the-skyline-problem.java", "content": "class Solution {\n class KeyPoint {\n public int key;\n public int height;\n public KeyPoint next = null;\n\n public KeyPoint(int key, int height) {\n this.key = key;\n this.height = height;\n }\n }\n\n public List> getSkyline(int[][] buildings) {\n List> res = new ArrayList<>();\n KeyPoint dummy = new KeyPoint(-1, 0); // dummy head\n KeyPoint pre = dummy;\n\n for (int[] bd : buildings) {\n int L = bd[0];\n int R = bd[1];\n int H = bd[2];\n\n while (pre.next != null && pre.next.key <= L)\n pre = pre.next;\n\n int preH = pre.height;\n\n if (pre.key == L)\n pre.height = Math.max(pre.height, H);\n else if (pre.height < H) {\n KeyPoint next = pre.next;\n pre.next = new KeyPoint(L, H);\n pre = pre.next;\n pre.next = next;\n }\n\n KeyPoint preIter = pre;\n KeyPoint curIter = pre.next;\n while (curIter != null && curIter.key < R) {\n preH = curIter.height;\n curIter.height = Math.max(curIter.height, H);\n\n if (curIter.height == preIter.height)\n preIter.next = curIter.next;\n else\n preIter = curIter;\n\n curIter = curIter.next;\n }\n\n if (preIter.height != preH && preIter.key != R && (curIter == null || curIter.key != R)) {\n KeyPoint next = preIter.next;\n preIter.next = new KeyPoint(R, preH);\n preIter.next.next = next;\n }\n }\n\n KeyPoint first = dummy;\n KeyPoint second = dummy.next;\n while (second != null) {\n if (second.height != first.height)\n res.add(Arrays.asList(second.key, second.height));\n first = first.next;\n second = second.next;\n }\n return res;\n }\n}" }, { "path": "218-the-skyline-problem/NOTES.md", "content": "​" }, { "path": "218-the-skyline-problem/README.md", "content": "

218. The Skyline Problem

Hard

A city's skyline is the outer contour of the silhouette formed by all the buildings in that city when viewed from a distance. Given the locations and heights of all the buildings, return the skyline formed by these buildings collectively.

\n\n

The geometric information of each building is given in the array buildings where buildings[i] = [lefti, righti, heighti]:

\n\n
    \n\t
  • lefti is the x coordinate of the left edge of the ith building.
    • \n\t
  • righti is the x coordinate of the right edge of the ith building.
    • \n\t
  • heighti is the height of the ith building.
    • \n
\n\n

You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.

\n\n

The skyline should be represented as a list of \"key points\" sorted by their x-coordinate in the form [[x1,y1],[x2,y2],...]. Each key point is the left endpoint of some horizontal segment in the skyline except the last point in the list, which always has a y-coordinate 0 and is used to mark the skyline's termination where the rightmost building ends. Any ground between the leftmost and rightmost buildings should be part of the skyline's contour.

\n\n

Note: There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...,[2 3],[4 5],[7 5],[11 5],[12 7],...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...,[2 3],[4 5],[12 7],...]

\n\n

 

\n

Example 1:

\n\"\"\n
Input: buildings = [[2,9,10],[3,7,15],[5,12,12],[15,20,10],[19,24,8]]\nOutput: [[2,10],[3,15],[7,12],[12,0],[15,10],[20,8],[24,0]]\nExplanation:\nFigure A shows the buildings of the input.\nFigure B shows the skyline formed by those buildings. The red points in figure B represent the key points in the output list.\n
\n\n

Example 2:

\n\n
Input: buildings = [[0,2,3],[2,5,3]]\nOutput: [[0,3],[5,0]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= buildings.length <= 104
    • \n\t
  • 0 <= lefti < righti <= 231 - 1
    • \n\t
  • 1 <= heighti <= 231 - 1
    • \n\t
  • buildings is sorted by lefti in non-decreasing order.
    • \n
\n
" }, { "path": "2225-find-players-with-zero-or-one-losses/2225-find-players-with-zero-or-one-losses.java", "content": "class Solution {\n public List> findWinners(int[][] matches) {\n Map p=new HashMap<>();\n int n=matches.length;\n int maxEle=0;\n for(int[] match:matches){\n p.putIfAbsent(match[0],0);\n p.putIfAbsent(match[1],0);\n p.put(match[1],p.get(match[1])+1);\n maxEle=Math.max(maxEle,Math.max(match[0],match[1]));\n }\n List zeroes=new ArrayList<>();\n List ones=new ArrayList<>();\n for(int i=1;i<=maxEle;i++){\n if(!p.containsKey(i))continue;\n if(p.get(i)==0){\n zeroes.add(i);\n }else if(p.get(i)==1){\n ones.add(i);\n }\n }\n List> ans=new ArrayList<>();\n ans.add(zeroes);\n ans.add(ones);\n return ans;\n }\n}" }, { "path": "2225-find-players-with-zero-or-one-losses/NOTES.md", "content": "​" }, { "path": "2225-find-players-with-zero-or-one-losses/README.md", "content": "

2225. Find Players With Zero or One Losses

Medium

You are given an integer array matches where matches[i] = [winneri, loseri] indicates that the player winneri defeated player loseri in a match.

\n\n

Return a list answer of size 2 where:

\n\n
    \n\t
  • answer[0] is a list of all players that have not lost any matches.
    • \n\t
  • answer[1] is a list of all players that have lost exactly one match.
    • \n
\n\n

The values in the two lists should be returned in increasing order.

\n\n

Note:

\n\n
    \n\t
  • You should only consider the players that have played at least one match.
    • \n\t
  • The testcases will be generated such that no two matches will have the same outcome.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input: matches = [[1,3],[2,3],[3,6],[5,6],[5,7],[4,5],[4,8],[4,9],[10,4],[10,9]]\nOutput: [[1,2,10],[4,5,7,8]]\nExplanation:\nPlayers 1, 2, and 10 have not lost any matches.\nPlayers 4, 5, 7, and 8 each have lost one match.\nPlayers 3, 6, and 9 each have lost two matches.\nThus, answer[0] = [1,2,10] and answer[1] = [4,5,7,8].\n
\n\n

Example 2:

\n\n
Input: matches = [[2,3],[1,3],[5,4],[6,4]]\nOutput: [[1,2,5,6],[]]\nExplanation:\nPlayers 1, 2, 5, and 6 have not lost any matches.\nPlayers 3 and 4 each have lost two matches.\nThus, answer[0] = [1,2,5,6] and answer[1] = [].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= matches.length <= 105
    • \n\t
  • matches[i].length == 2
    • \n\t
  • 1 <= winneri, loseri <= 105
    • \n\t
  • winneri != loseri
    • \n\t
  • All matches[i] are unique.
    • \n
\n
" }, { "path": "2244-minimum-rounds-to-complete-all-tasks/2244-minimum-rounds-to-complete-all-tasks.java", "content": "class Solution {\n public int minimumRounds(int[] tasks) {\n Map freq = new HashMap();\n // Store the frequencies in the map.\n for (int task : tasks) {\n freq.put(task, freq.getOrDefault(task, 0) + 1);\n }\n\n int minimumRounds = 0;\n // Iterate over the task's frequencies.\n for (int count : freq.values()) {\n // If the frequency is 1, it's not possible to complete tasks.\n if (count == 1) {\n return - 1;\n }\n\n if (count % 3 == 0) {\n // Group all the task in triplets.\n minimumRounds += count / 3;\n } else {\n // If count % 3 = 1; (count / 3 - 1) groups of triplets and 2 pairs.\n // If count % 3 = 2; (count / 3) groups of triplets and 1 pair.\n minimumRounds += count / 3 + 1;\n }\n }\n\n return minimumRounds;\n }\n}" }, { "path": "2244-minimum-rounds-to-complete-all-tasks/NOTES.md", "content": "​" }, { "path": "2244-minimum-rounds-to-complete-all-tasks/README.md", "content": "

2244. Minimum Rounds to Complete All Tasks

Medium

You are given a 0-indexed integer array tasks, where tasks[i] represents the difficulty level of a task. In each round, you can complete either 2 or 3 tasks of the same difficulty level.

\n\n

Return the minimum rounds required to complete all the tasks, or -1 if it is not possible to complete all the tasks.

\n\n

 

\n

Example 1:

\n\n
Input: tasks = [2,2,3,3,2,4,4,4,4,4]\nOutput: 4\nExplanation: To complete all the tasks, a possible plan is:\n- In the first round, you complete 3 tasks of difficulty level 2. \n- In the second round, you complete 2 tasks of difficulty level 3. \n- In the third round, you complete 3 tasks of difficulty level 4. \n- In the fourth round, you complete 2 tasks of difficulty level 4.  \nIt can be shown that all the tasks cannot be completed in fewer than 4 rounds, so the answer is 4.\n
\n\n

Example 2:

\n\n
Input: tasks = [2,3,3]\nOutput: -1\nExplanation: There is only 1 task of difficulty level 2, but in each round, you can only complete either 2 or 3 tasks of the same difficulty level. Hence, you cannot complete all the tasks, and the answer is -1.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= tasks.length <= 105
    • \n\t
  • 1 <= tasks[i] <= 109
    • \n
\n
" }, { "path": "2246-longest-path-with-different-adjacent-characters/2246-longest-path-with-different-adjacent-characters.java", "content": "class Solution {\n private int longestPath = 1;\n\n public int dfs(int currentNode, Map> children, String s) {\n // If the node is the only child, return 1 for the currentNode itself.\n if (!children.containsKey(currentNode)) {\n return 1;\n }\n\n // Longest and second longest path starting from currentNode (does not count the\n // currentNode itself).\n int longestChain = 0, secondLongestChain = 0;\n for (int child : children.get(currentNode)) {\n // Get the number of nodes in the longest chain starting from the child,\n // including the child.\n int longestChainStartingFromChild = dfs(child, children, s);\n // We won't move to the child if it has the same character as the currentNode.\n if (s.charAt(currentNode) == s.charAt(child)) {\n continue;\n }\n // Modify the longestChain and secondLongestChain if longestChainStartingFromChild\n // is bigger.\n if (longestChainStartingFromChild > longestChain) {\n secondLongestChain = longestChain;\n longestChain = longestChainStartingFromChild;\n } else if (longestChainStartingFromChild > secondLongestChain) {\n secondLongestChain = longestChainStartingFromChild;\n }\n }\n\n // Add \"1\" for the node itself.\n longestPath = Math.max(longestPath, longestChain + secondLongestChain + 1);\n return longestChain + 1;\n }\n\n public int longestPath(int[] parent, String s) {\n int n = parent.length;\n Map> children = new HashMap<>();\n // Start from node 1, since root node 0 does not have a parent.\n for (int i = 1; i < n; i++) {\n children.computeIfAbsent(parent[i], value -> new ArrayList()).add(i);\n }\n\n dfs(0, children, s);\n\n return longestPath;\n }\n}" }, { "path": "2246-longest-path-with-different-adjacent-characters/NOTES.md", "content": "​" }, { "path": "2246-longest-path-with-different-adjacent-characters/README.md", "content": "

2246. Longest Path With Different Adjacent Characters

Hard

You are given a tree (i.e. a connected, undirected graph that has no cycles) rooted at node 0 consisting of n nodes numbered from 0 to n - 1. The tree is represented by a 0-indexed array parent of size n, where parent[i] is the parent of node i. Since node 0 is the root, parent[0] == -1.

\n\n

You are also given a string s of length n, where s[i] is the character assigned to node i.

\n\n

Return the length of the longest path in the tree such that no pair of adjacent nodes on the path have the same character assigned to them.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: parent = [-1,0,0,1,1,2], s = \"abacbe\"\nOutput: 3\nExplanation: The longest path where each two adjacent nodes have different characters in the tree is the path: 0 -> 1 -> 3. The length of this path is 3, so 3 is returned.\nIt can be proven that there is no longer path that satisfies the conditions. \n
\n\n

Example 2:

\n\"\"\n
Input: parent = [-1,0,0,0], s = \"aabc\"\nOutput: 3\nExplanation: The longest path where each two adjacent nodes have different characters is the path: 2 -> 0 -> 3. The length of this path is 3, so 3 is returned.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == parent.length == s.length
    • \n\t
  • 1 <= n <= 105
    • \n\t
  • 0 <= parent[i] <= n - 1 for all i >= 1
    • \n\t
  • parent[0] == -1
    • \n\t
  • parent represents a valid tree.
    • \n\t
  • s consists of only lowercase English letters.
    • \n
\n
" }, { "path": "225-implement-stack-using-queues/225-implement-stack-using-queues.java", "content": "class MyStack {\n Queue q1,q2;\n boolean fis;\n public MyStack() {\n q1=new LinkedList<>();\n q2=new LinkedList<>();\n fis=true;\n }\n \n public void push(int x) {\n if(fis){\n q1.add(x);\n }else{\n q2.add(x);\n }\n }\n \n public int pop() {\n if(fis){\n fis=false;\n while(q1.size()>1){\n q2.add(q1.remove());\n }\n int ele=q1.remove();\n return ele;\n }else{\n fis=true;\n while(q2.size()>1){\n q1.add(q2.remove());\n }\n int ele=q2.remove();\n return ele;\n }\n }\n \n public int top() {\n if(fis){\n fis=false;\n while(q1.size()>1){\n q2.add(q1.remove());\n }\n int ele=q1.peek();\n q2.add(q1.remove());\n return ele;\n }else{\n fis=true;\n while(q2.size()>1){\n q1.add(q2.remove());\n }\n int ele=q2.peek();\n q1.add(q2.remove());\n return ele;\n }\n }\n \n public boolean empty() {\n return q1.isEmpty() && q2.isEmpty();\n }\n}\n\n/**\n * Your MyStack object will be instantiated and called as such:\n * MyStack obj = new MyStack();\n * obj.push(x);\n * int param_2 = obj.pop();\n * int param_3 = obj.top();\n * boolean param_4 = obj.empty();\n */" }, { "path": "225-implement-stack-using-queues/NOTES.md", "content": "​" }, { "path": "2256-minimum-average-difference/2256-minimum-average-difference.java", "content": "class Solution {\n public int minimumAverageDifference(int[] nums) {\n int n=nums.length;\n long left=0;\n long right=0;\n long minDiff=Integer.MAX_VALUE;\n int idx=-1;\n for(int i:nums)right+=i;\n for(int i=0;i2256. Minimum Average Difference

Medium

You are given a 0-indexed integer array nums of length n.

\n\n

The average difference of the index i is the absolute difference between the average of the first i + 1 elements of nums and the average of the last n - i - 1 elements. Both averages should be rounded down to the nearest integer.

\n\n

Return the index with the minimum average difference. If there are multiple such indices, return the smallest one.

\n\n

Note:

\n\n
    \n\t
  • The absolute difference of two numbers is the absolute value of their difference.
    • \n\t
  • The average of n elements is the sum of the n elements divided (integer division) by n.
    • \n\t
  • The average of 0 elements is considered to be 0.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input: nums = [2,5,3,9,5,3]\nOutput: 3\nExplanation:\n- The average difference of index 0 is: |2 / 1 - (5 + 3 + 9 + 5 + 3) / 5| = |2 / 1 - 25 / 5| = |2 - 5| = 3.\n- The average difference of index 1 is: |(2 + 5) / 2 - (3 + 9 + 5 + 3) / 4| = |7 / 2 - 20 / 4| = |3 - 5| = 2.\n- The average difference of index 2 is: |(2 + 5 + 3) / 3 - (9 + 5 + 3) / 3| = |10 / 3 - 17 / 3| = |3 - 5| = 2.\n- The average difference of index 3 is: |(2 + 5 + 3 + 9) / 4 - (5 + 3) / 2| = |19 / 4 - 8 / 2| = |4 - 4| = 0.\n- The average difference of index 4 is: |(2 + 5 + 3 + 9 + 5) / 5 - 3 / 1| = |24 / 5 - 3 / 1| = |4 - 3| = 1.\n- The average difference of index 5 is: |(2 + 5 + 3 + 9 + 5 + 3) / 6 - 0| = |27 / 6 - 0| = |4 - 0| = 4.\nThe average difference of index 3 is the minimum average difference so return 3.\n
\n\n

Example 2:

\n\n
Input: nums = [0]\nOutput: 0\nExplanation:\nThe only index is 0 so return 0.\nThe average difference of index 0 is: |0 / 1 - 0| = |0 - 0| = 0.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • 0 <= nums[i] <= 105
    • \n
\n
" }, { "path": "2279-maximum-bags-with-full-capacity-of-rocks/2279-maximum-bags-with-full-capacity-of-rocks.java", "content": "class Solution {\n public int maximumBags(int[] capacity, int[] rocks, int x) {\n int n=rocks.length;\n int[]diff=new int[n];\n for(int i=0;i0){\n if(i=diff[i]){\n x-=diff[i];\n i++; \n }else{\n break;\n }\n }\n return i;\n }\n}" }, { "path": "2279-maximum-bags-with-full-capacity-of-rocks/NOTES.md", "content": "​" }, { "path": "2279-maximum-bags-with-full-capacity-of-rocks/README.md", "content": "

2279. Maximum Bags With Full Capacity of Rocks

Medium

You have n bags numbered from 0 to n - 1. You are given two 0-indexed integer arrays capacity and rocks. The ith bag can hold a maximum of capacity[i] rocks and currently contains rocks[i] rocks. You are also given an integer additionalRocks, the number of additional rocks you can place in any of the bags.

\n\n

Return the maximum number of bags that could have full capacity after placing the additional rocks in some bags.

\n\n

 

\n

Example 1:

\n\n
Input: capacity = [2,3,4,5], rocks = [1,2,4,4], additionalRocks = 2\nOutput: 3\nExplanation:\nPlace 1 rock in bag 0 and 1 rock in bag 1.\nThe number of rocks in each bag are now [2,3,4,4].\nBags 0, 1, and 2 have full capacity.\nThere are 3 bags at full capacity, so we return 3.\nIt can be shown that it is not possible to have more than 3 bags at full capacity.\nNote that there may be other ways of placing the rocks that result in an answer of 3.\n
\n\n

Example 2:

\n\n
Input: capacity = [10,2,2], rocks = [2,2,0], additionalRocks = 100\nOutput: 3\nExplanation:\nPlace 8 rocks in bag 0 and 2 rocks in bag 2.\nThe number of rocks in each bag are now [10,2,2].\nBags 0, 1, and 2 have full capacity.\nThere are 3 bags at full capacity, so we return 3.\nIt can be shown that it is not possible to have more than 3 bags at full capacity.\nNote that we did not use all of the additional rocks.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == capacity.length == rocks.length
    • \n\t
  • 1 <= n <= 5 * 104
    • \n\t
  • 1 <= capacity[i] <= 109
    • \n\t
  • 0 <= rocks[i] <= capacity[i]
    • \n\t
  • 1 <= additionalRocks <= 109
    • \n
\n
" }, { "path": "23-Merge-k-Sorted-Lists/23-Merge-k-Sorted-Lists.cpp", "content": "class Solution {\r\npublic:\r\n ListNode* mergeKLists(vector& lists) {\r\n //pushing all list values into min heap\r\n priority_queue, greater > mh;\r\n for(auto head : lists){\r\n while(head){\r\n mh.push(head -> val);\r\n head = head -> next;\r\n }\r\n }\r\n \r\n //if there is no element in lists\r\n if(mh.size() == 0) return NULL;\r\n \r\n //creating head node of resultant list\r\n ListNode * head = new ListNode(mh.top());\r\n mh.pop();\r\n //we will traverse the head so storing it for returning\r\n ListNode * ans_head = head;\r\n \r\n //creating final list and poping the min heap\r\n int n = mh.size();\r\n while(n--){\r\n head -> next = new ListNode(mh.top());\r\n mh.pop();\r\n head = head -> next;\r\n }\r\n \r\n return ans_head;\r\n }\r\n};" }, { "path": "23-Merge-k-Sorted-Lists/NOTES.md", "content": "" }, { "path": "23-Merge-k-Sorted-Lists/README.md", "content": "

\r\n 23. Merge k Sorted Lists \r\n

\r\n

Hard

\r\n
\r\nYou are given an array of `k` linked-lists `lists`, each linked-list is sorted in ascending order.\r\n\r\n*Merge all the linked-lists into one sorted linked-list and return it.*\r\n\r\n**Example 1:**\r\n\r\n**Input:** lists = [[1,4,5],[1,3,4],[2,6]]\r\n
\r\n**Output:** [1,1,2,3,4,4,5,6]\r\n
\r\n**Explanation:** The linked-lists are:\r\n[\r\n 1->4->5,\r\n 1->3->4,\r\n 2->6\r\n]\r\nmerging them into one sorted list:\r\n1->1->2->3->4->4->5->6\r\n\r\n**Example 2:**\r\n\r\n**Input:** lists = []\r\n**Output:** []\r\n\r\n**Example 3:**\r\n\r\n**Input:** lists = [[]]\r\n**Output:** []\r\n\r\n**Constraints:**\r\n\r\n- `k == lists.length`\r\n- `0 <= k <= 10^4^`\r\n- `0 <= lists[i].length <= 500`\r\n- `-10^4^ <= lists[i][j] <= 10^4^`\r\n- `lists[i]` is sorted in **ascending order**.\r\n- The sum of `lists[i].length` will not exceed `10^4^`.\r\n" }, { "path": "230-kth-smallest-element-in-a-bst/230-kth-smallest-element-in-a-bst.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n int count=0;\n int ans=-1;\n public int kthSmallest(TreeNode root, int k) {\n dfs(root,k);\n return ans;\n }\n public void dfs(TreeNode root,int k){\n if(root==null)return;\n dfs(root.left,k);\n count++;\n if(count==k){\n ans=root.val;\n return;\n }\n dfs(root.right,k);\n return;\n }\n}" }, { "path": "230-kth-smallest-element-in-a-bst/NOTES.md", "content": "​" }, { "path": "234-palindrome-linked-list/234-palindrome-linked-list.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public boolean isPalindrome(ListNode head) {\n ListNode node=head;\n int sz=0;\n while(node!=null){\n node=node.next;\n sz++;\n }\n if(sz==1)return true;\n ListNode curr=head;\n ListNode prev=null;\n for(int i=0;i bool:\n if head is None:\n return True\n slow = head\n fast = head\n while fast.next is not None and fast.next.next is not None:\n slow = slow.next\n fast = fast.next.next\n mid = slow.next\n slow.next = None\n prev = None\n while mid is not None:\n temp = mid.next\n mid.next = prev\n prev = mid\n mid = temp\n while prev is not None and head is not None:\n if prev.val != head.val:\n return False\n prev = prev.next\n head = head.next\n return True" }, { "path": "234-palindrome-linked-list/NOTES.md", "content": "​" }, { "path": "234-palindrome-linked-list/README.md", "content": "

234. Palindrome Linked List

Easy

Given the head of a singly linked list, return true if it is a palindrome.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,2,1]\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: head = [1,2]\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is in the range [1, 105].
    • \n\t
  • 0 <= Node.val <= 9
    • \n
\n\n

 

\nFollow up: Could you do it in O(n) time and O(1) space?
" }, { "path": "234-palindrome-linked-list/palindrome-linked-list.cpp", "content": "class Solution {\npublic:\n bool isPalindrome(ListNode* head) {\n ListNode* slow = head, *fast = head;\n while(fast and fast->next){\n slow=slow->next;\n fast=fast->next->next;\n }\n \n // reverse half of linkedlist\n ListNode* nextNode, *prev = NULL;\n while(slow){\n nextNode = slow->next;\n slow->next = prev;\n prev = slow;\n slow = nextNode;\n }\n \n while(prev){\n if(prev->val != head->val) return false;\n prev = prev->next;\n head = head->next;\n }\n return true;\n }\n};\n" }, { "path": "234. Palindrome Linked List/SolutionCode.cpp", "content": "/*\n Approach : \n 1. Find mid point of linked list.Divide the LL into two respective LL's.\n 2. Now reverse either one of the LL.\n 3. Traverse both LL's simulatenously and if at any instant their data doesn't match -> return false;\n*/\n\nclass Solution {\npublic:\nListNode* reverseNode(ListNode* head){\n if(!head) return head;\n \n ListNode* nx = head->next, *prev = NULL, *curr = head;\n \n while(curr){\n nx = curr->next;\n curr->next = prev;\n prev = curr;\n curr = nx;\n }\n return prev;\n}\n bool isPalindrome(ListNode* head) {\n if(!head) return true;\n \n \n ListNode *slow = head, *fast = head->next;\n \n while(fast && fast->next){\n slow = slow->next;\n fast = fast->next;\n if(fast){\n fast = fast->next;\n }\n }\n \n ListNode* tmp = slow->next;\n slow->next = NULL;\n \n ListNode* rev = reverseNode(tmp);\n \n while(rev && head){\n if(rev->val != head->val) return false;\n \n rev = rev->next;\n head = head->next;\n }\n \n return true;\n }\n};\n\n\n" }, { "path": "235-lowest-common-ancestor-of-a-binary-search-tree/235-lowest-common-ancestor-of-a-binary-search-tree.java", "content": "class Solution {\n public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {\n if(p.valroot.val && q.val>root.val)\n return lowestCommonAncestor(root.right,p,q);\n else\n return root;\n }\n}" }, { "path": "235-lowest-common-ancestor-of-a-binary-search-tree/235-lowest-common-ancestor-of-a-binary-search-tree.py", "content": "# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, x):\n# self.val = x\n# self.left = None\n# self.right = None\n\nclass Solution:\n def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':\n \n \n # Using Recursion\n if (root == p or root == q or not root): return root\n \n left = self.lowestCommonAncestor(root.left, p, q)\n right = self.lowestCommonAncestor(root.right, p , q)\n \n if left and right : return root #Found common ancestor\n \n elif left: return left\n elif right: return right\n" }, { "path": "235-lowest-common-ancestor-of-a-binary-search-tree/NOTES.md", "content": "​" }, { "path": "235-lowest-common-ancestor-of-a-binary-search-tree/README.md", "content": "

235. Lowest Common Ancestor of a Binary Search Tree

Easy

Given a binary search tree (BST), find the lowest common ancestor (LCA) node of two given nodes in the BST.

\n\n

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8\nOutput: 6\nExplanation: The LCA of nodes 2 and 8 is 6.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4\nOutput: 2\nExplanation: The LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.\n
\n\n

Example 3:

\n\n
Input: root = [2,1], p = 2, q = 1\nOutput: 2\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [2, 105].
    • \n\t
  • -109 <= Node.val <= 109
    • \n\t
  • All Node.val are unique.
    • \n\t
  • p != q
    • \n\t
  • p and q will exist in the BST.
    • \n
\n
" }, { "path": "2359-find-closest-node-to-given-two-nodes/NOTES.md", "content": "​" }, { "path": "2359-find-closest-node-to-given-two-nodes/README.md", "content": "

2359. Find Closest Node to Given Two Nodes

Medium

You are given a directed graph of n nodes numbered from 0 to n - 1, where each node has at most one outgoing edge.

\n\n

The graph is represented with a given 0-indexed array edges of size n, indicating that there is a directed edge from node i to node edges[i]. If there is no outgoing edge from i, then edges[i] == -1.

\n\n

You are also given two integers node1 and node2.

\n\n

Return the index of the node that can be reached from both node1 and node2, such that the maximum between the distance from node1 to that node, and from node2 to that node is minimized. If there are multiple answers, return the node with the smallest index, and if no possible answer exists, return -1.

\n\n

Note that edges may contain cycles.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: edges = [2,2,3,-1], node1 = 0, node2 = 1\nOutput: 2\nExplanation: The distance from node 0 to node 2 is 1, and the distance from node 1 to node 2 is 1.\nThe maximum of those two distances is 1. It can be proven that we cannot get a node with a smaller maximum distance than 1, so we return node 2.\n
\n\n

Example 2:

\n\"\"\n
Input: edges = [1,2,-1], node1 = 0, node2 = 2\nOutput: 2\nExplanation: The distance from node 0 to node 2 is 2, and the distance from node 2 to itself is 0.\nThe maximum of those two distances is 2. It can be proven that we cannot get a node with a smaller maximum distance than 2, so we return node 2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == edges.length
    • \n\t
  • 2 <= n <= 105
    • \n\t
  • -1 <= edges[i] < n
    • \n\t
  • edges[i] != i
    • \n\t
  • 0 <= node1, node2 < n
    • \n
\n
" }, { "path": "236-lowest-common-ancestor-of-a-binary-tree/236-lowest-common-ancestor-of-a-binary-tree.java", "content": "class Solution {\n public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {\n if (root == null || root == p || root == q) return root;\n TreeNode left = lowestCommonAncestor(root.left, p, q);\n TreeNode right = lowestCommonAncestor(root.right, p, q);\n if (left != null && right != null) return root;\n return left != null ? left : right;\n }\n}" }, { "path": "236-lowest-common-ancestor-of-a-binary-tree/NOTES.md", "content": "​" }, { "path": "237-delete-node-in-a-linked-list/237-delete-node-in-a-linked-list.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode(int x) { val = x; }\n * }\n */\nclass Solution {\n public void deleteNode(ListNode node) {\n node.val = node.next.val;\n node.next = node.next.next;\n return;\n }\n}" }, { "path": "237-delete-node-in-a-linked-list/NOTES.md", "content": "" }, { "path": "2389-longest-subsequence-with-limited-sum/2389-longest-subsequence-with-limited-sum.java", "content": "class Solution {\n public int[] answerQueries(int[] nums, int[] queries) {\n Arrays.sort(nums);\n int n=queries.length;\n int[]ans=new int[n];\n for(int i=0;iqueries[i])break;\n sum+=nums[j];\n }\n ans[i]=j;\n }\n return ans;\n }\n}" }, { "path": "2389-longest-subsequence-with-limited-sum/NOTES.md", "content": "​" }, { "path": "2389-longest-subsequence-with-limited-sum/README.md", "content": "

2389. Longest Subsequence With Limited Sum

Easy

You are given an integer array nums of length n, and an integer array queries of length m.

\n\n

Return an array answer of length m where answer[i] is the maximum size of a subsequence that you can take from nums such that the sum of its elements is less than or equal to queries[i].

\n\n

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [4,5,2,1], queries = [3,10,21]\nOutput: [2,3,4]\nExplanation: We answer the queries as follows:\n- The subsequence [2,1] has a sum less than or equal to 3. It can be proven that 2 is the maximum size of such a subsequence, so answer[0] = 2.\n- The subsequence [4,5,1] has a sum less than or equal to 10. It can be proven that 3 is the maximum size of such a subsequence, so answer[1] = 3.\n- The subsequence [4,5,2,1] has a sum less than or equal to 21. It can be proven that 4 is the maximum size of such a subsequence, so answer[2] = 4.\n
\n\n

Example 2:

\n\n
Input: nums = [2,3,4,5], queries = [1]\nOutput: [0]\nExplanation: The empty subsequence is the only subsequence that has a sum less than or equal to 1, so answer[0] = 0.
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == nums.length
    • \n\t
  • m == queries.length
    • \n\t
  • 1 <= n, m <= 1000
    • \n\t
  • 1 <= nums[i], queries[i] <= 106
    • \n
\n
" }, { "path": "2389_longest_subsequence_with_limited_sum.cpp", "content": "class Solution {\npublic:\n vector answerQueries(vector& n, vector& q) {\n vector v;\n sort(n.begin(),n.end());\n for(int i =0;i& nums) {\n set s;\n for(int i =0;i= 0 && i < matrix.length && j >= 0 && j < matrix[0].length){\n if(matrix[i][j] == target) return true;\n else if(matrix[i][j] > target) j--;\n else if(matrix[i][j] < target) i++;\n }\n return false;\n }\n}" }, { "path": "240-search-a-2d-matrix-ii/NOTES.md", "content": "​" }, { "path": "240-search-a-2d-matrix-ii/README.md", "content": "

240. Search a 2D Matrix II

Medium

Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:

\n\n
    \n\t
  • Integers in each row are sorted in ascending from left to right.
    • \n\t
  • Integers in each column are sorted in ascending from top to bottom.
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == matrix.length
    • \n\t
  • n == matrix[i].length
    • \n\t
  • 1 <= n, m <= 300
    • \n\t
  • -109 <= matrix[i][j] <= 109
    • \n\t
  • All the integers in each row are sorted in ascending order.
    • \n\t
  • All the integers in each column are sorted in ascending order.
    • \n\t
  • -109 <= target <= 109
    • \n
\n
" }, { "path": "242-valid-anagram/242-valid-anagram.java", "content": "class Solution {\n public boolean isAnagram(String s, String t) {\n var freqs = new int[26];\n var freqt = new int[26];\n \n for (var c : s.toCharArray()) {\n freqs[c - 'a']++;\n }\n \n for (var c : t.toCharArray()) {\n freqt[c - 'a']++;\n }\n \n for (int i = 0; i != 26; ++i) {\n if (freqs[i] != freqt[i]) {\n return false;\n }\n }\n return true;\n }\n}" }, { "path": "242-valid-anagram/NOTES.md", "content": "​" }, { "path": "242-valid-anagram/README.md", "content": "

242. Valid Anagram

Easy

Given two strings s and t, return true if t is an anagram of s, and false otherwise.

\n\n

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.

\n\n

 

\n

Example 1:

\n
Input: s = \"anagram\", t = \"nagaram\"\nOutput: true\n

Example 2:

\n
Input: s = \"rat\", t = \"car\"\nOutput: false\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length, t.length <= 5 * 104
    • \n\t
  • s and t consist of lowercase English letters.
    • \n
\n\n

 

\n

Follow up: What if the inputs contain Unicode characters? How would you adapt your solution to such a case?

\n
" }, { "path": "2421-number-of-good-paths/2421-number-of-good-paths.java", "content": "class UnionFind {\n int[] parent;\n int[] rank;\n\n public UnionFind(int size) {\n parent = new int[size];\n for (int i = 0; i < size; i++)\n parent[i] = i;\n rank = new int[size];\n }\n\n public int find(int x) {\n if (parent[x] != x)\n parent[x] = find(parent[x]);\n return parent[x];\n }\n\n public void union_set(int x, int y) {\n int xset = find(x), yset = find(y);\n if (xset == yset) {\n return;\n } else if (rank[xset] < rank[yset]) {\n parent[xset] = yset;\n } else if (rank[xset] > rank[yset]) {\n parent[yset] = xset;\n } else {\n parent[yset] = xset;\n rank[xset]++;\n }\n }\n}\n\nclass Solution {\n public int numberOfGoodPaths(int[] vals, int[][] edges) {\n Map> adj = new HashMap<>();\n for (int[] edge : edges) {\n int a = edge[0], b = edge[1];\n adj.computeIfAbsent(a, value -> new ArrayList()).add(b);\n adj.computeIfAbsent(b, value -> new ArrayList()).add(a);\n }\n\n int n = vals.length;\n // Mapping from value to all the nodes having the same value in sorted order of\n // values.\n TreeMap> valuesToNodes = new TreeMap<>();\n for (int i = 0; i < n; i++) {\n valuesToNodes.computeIfAbsent(vals[i], value -> new ArrayList()).add(i);\n }\n\n UnionFind dsu = new UnionFind(n);\n int goodPaths = 0;\n\n // Iterate over all the nodes with the same value in sorted order, starting from\n // the lowest value.\n for (int value : valuesToNodes.keySet()) {\n // For every node in nodes, combine the sets of the node and its neighbors into\n // one set.\n for (int node : valuesToNodes.get(value)) {\n if (!adj.containsKey(node))\n continue;\n for (int neighbor : adj.get(node)) {\n // Only choose neighbors with a smaller value, as there is no point in\n // traversing to other neighbors.\n if (vals[node] >= vals[neighbor]) {\n dsu.union_set(node, neighbor);\n }\n }\n }\n // Map to compute the number of nodes under observation (with the same values)\n // in each of the sets.\n Map group = new HashMap<>();\n // Iterate over all the nodes. Get the set of each node and increase the count\n // of the set by 1.\n for (int u : valuesToNodes.get(value)) {\n group.put(dsu.find(u), group.getOrDefault(dsu.find(u), 0) + 1);\n }\n // For each set of \"size\", add size * (size + 1) / 2 to the number of goodPaths.\n for (int key : group.keySet()) {\n int size = group.get(key);\n goodPaths += size * (size + 1) / 2;\n }\n }\n return goodPaths;\n }\n}" }, { "path": "2421-number-of-good-paths/NOTES.md", "content": "​" }, { "path": "2429-minimize-xor/2429-minimize-xor.cpp", "content": "class Solution\n{\npublic:\n int minimizeXor(int num1, int num2)\n {\n int c1 = __builtin_popcount(num1);\n int c2 = __builtin_popcount(num2);\n\n int ans = 0;\n\n for (int i = 31; i >= 0; i--)\n {\n if ((1 << i) & num1)\n {\n ans |= (1 << i);\n c2--;\n\n if (c2 == 0) break;\n }\n }\n\n if (c2 > 0)\n {\n for (int i = 0; i < 32; i++)\n {\n if (((1 << i) & num1) == 0)\n {\n ans |= 1 << i;\n c2--;\n }\n\n if (c2 == 0) break;\n }\n }\n\n return ans;\n }\n};" }, { "path": "2429-minimize-xor/Notes.md", "content": "" }, { "path": "2429-minimize-xor/Readme.md", "content": "## 2429. Minimize XOR\n\n**Difficulty - Medium**\n\nGiven two positive integers num1 and num2, find the integer x such that:\n\n- x has the same number of set bits as num2, and\n- The value x XOR num1 is minimal. \n Note that XOR is the bitwise XOR operation.\n\nReturn the integer x. The test cases are generated such that x is uniquely determined.\n\nThe number of set bits of an integer is the number of 1's in its binary representation.\n\n## Example 1\n\n**Input:** num1 = 3, num2 = 5 \n**Output:** 3 \n**Explanation:** \nThe binary representations of num1 and num2 are 0011 and 0101, respectively.\nThe integer 3 has the same number of set bits as num2, and the value 3 XOR 3 = 0 is minimal.\n\n## Example 2\n\n**Input:** num1 = 1, num2 = 12 \n**Output:** 3 \n**Explanation:** \nThe binary representations of num1 and num2 are 0001 and 1100, respectively.\nThe integer 3 has the same number of set bits as num2, and the value 3 XOR 1 = 2 is minimal.\n\n## Contraints\n\n- 1 <= num1, num2 <= 109\n" }, { "path": "2453-destroy-sequential-targets/2453-destroy-sequential-targets.java", "content": "class Solution {\n public int destroyTargets(int[] nums, int space) {\n HashMap remCount = new HashMap<>();\n HashMap remNum = new HashMap<>();\n for(int e : nums){\n int rem = e%space;\n\n remNum.put(rem, Math.min(e,remNum.getOrDefault(rem, Integer.MAX_VALUE) ));\n remCount.put(rem, remCount.getOrDefault(rem,0)+1);\n }\n\n int max = -1; int remMax=-1; int re = -1;\n for(int rem : remCount.keySet()){\n if(remCount.get(rem)>max){\n remMax = rem; max = remCount.get(rem);\n re = remNum.get(remMax);\n }\n }\n\n int result = Integer.MAX_VALUE;\n for(int key : remNum.keySet()){\n if(remCount.get(key)==max){\n result = Math.min(remNum.get(key), result);\n }\n }\n\n return result;\n }\n}" }, { "path": "2453-destroy-sequential-targets/NOTES.md", "content": "​" }, { "path": "268-missing-number/268-missing-number.java", "content": "class Solution {\n public int missingNumber(int[] nums) {\n int num=nums.length;\n for(int i=0;i268. Missing Number

Easy

Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [3,0,1]\nOutput: 2\nExplanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.\n
\n\n

Example 2:

\n\n
Input: nums = [0,1]\nOutput: 2\nExplanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.\n
\n\n

Example 3:

\n\n
Input: nums = [9,6,4,2,3,5,7,0,1]\nOutput: 8\nExplanation: n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == nums.length
    • \n\t
  • 1 <= n <= 104
    • \n\t
  • 0 <= nums[i] <= n
    • \n\t
  • All the numbers of nums are unique.
    • \n
\n\n

 

\n

Follow up: Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?

\n
" }, { "path": "284-peeking-iterator/284-peeking-iterator.java", "content": "// Java Iterator interface reference:\n// https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html\n\nclass PeekingIterator implements Iterator {\n int i;\n ArrayList arr;\n\tpublic PeekingIterator(Iterator iterator) {\n\t // initialize any member here.\n\t arr=new ArrayList<>();\n while(iterator.hasNext()){\n arr.add(iterator.next());\n }\n i=0;\n\t}\n\t\n // Returns the next element in the iteration without advancing the iterator.\n\tpublic Integer peek() {\n return arr.get(i);\n\t}\n\t\n\t// hasNext() and next() should behave the same as in the Iterator interface.\n\t// Override them if needed.\n\t@Override\n\tpublic Integer next() {\n\t int val=arr.get(i);\n i++;\n return val;\n\t}\n\t\n\t@Override\n\tpublic boolean hasNext() {\n\t return i284. Peeking Iterator

Medium

Design an iterator that supports the peek operation on an existing iterator in addition to the hasNext and the next operations.

\n\n

Implement the PeekingIterator class:

\n\n
    \n\t
  • PeekingIterator(Iterator<int> nums) Initializes the object with the given integer iterator iterator.
    • \n\t
  • int next() Returns the next element in the array and moves the pointer to the next element.
    • \n\t
  • boolean hasNext() Returns true if there are still elements in the array.
    • \n\t
  • int peek() Returns the next element in the array without moving the pointer.
    • \n
\n\n

Note: Each language may have a different implementation of the constructor and Iterator, but they all support the int next() and boolean hasNext() functions.

\n\n

 

\n

Example 1:

\n\n
Input\n[\"PeekingIterator\", \"next\", \"peek\", \"next\", \"next\", \"hasNext\"]\n[[[1, 2, 3]], [], [], [], [], []]\nOutput\n[null, 1, 2, 2, 3, false]\n\nExplanation\nPeekingIterator peekingIterator = new PeekingIterator([1, 2, 3]); // [1,2,3]\npeekingIterator.next();    // return 1, the pointer moves to the next element [1,2,3].\npeekingIterator.peek();    // return 2, the pointer does not move [1,2,3].\npeekingIterator.next();    // return 2, the pointer moves to the next element [1,2,3]\npeekingIterator.next();    // return 3, the pointer moves to the next element [1,2,3]\npeekingIterator.hasNext(); // return False\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 1000
    • \n\t
  • 1 <= nums[i] <= 1000
    • \n\t
  • All the calls to next and peek are valid.
    • \n\t
  • At most 1000 calls will be made to next, hasNext, and peek.
    • \n
\n\n

 

\nFollow up: How would you extend your design to be generic and work with all types, not just integer?
" }, { "path": "287-find-the-duplicate-number/287-find-the-duplicate-number.java", "content": "class Solution {\n public int findDuplicate(int[] nums) {\n int fast=0,slow=0;\n while(true){\n slow=nums[slow];\n fast=nums[nums[fast]];\n if(slow==fast)break;\n }\n int slow2=0;\n while(true){\n slow=nums[slow];\n slow2=nums[slow2];\n if(slow==slow2)break;\n }\n return slow;\n }\n}" }, { "path": "287-find-the-duplicate-number/NOTES.md", "content": "​" }, { "path": "287-find-the-duplicate-number/README.md", "content": "

287. Find the Duplicate Number

Medium

Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive.

\n\n

There is only one repeated number in nums, return this repeated number.

\n\n

You must solve the problem without modifying the array nums and uses only constant extra space.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,3,4,2,2]\nOutput: 2\n
\n\n

Example 2:

\n\n
Input: nums = [3,1,3,4,2]\nOutput: 3\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 105
    • \n\t
  • nums.length == n + 1
    • \n\t
  • 1 <= nums[i] <= n
    • \n\t
  • All the integers in nums appear only once except for precisely one integer which appears two or more times.
    • \n
\n\n

 

\n

Follow up:

\n\n
    \n\t
  • How can we prove that at least one duplicate number must exist in nums?
    • \n\t
  • Can you solve the problem in linear runtime complexity?
    • \n
\n
" }, { "path": "289-game-of-life/289-game-of-life.java", "content": "class Solution {\n public void gameOfLife(int[][] board) {\n int n=board.length;\n int m=board[0].length;\n int[][] ans=new int[n][m];\n for(int i=0;i3){\n ans[i][j]=0;\n }else if(board[i][j]==0 && ones==3){\n ans[i][j]=1;\n }\n }\n }\n for(int i=0;i0){\n ans+=mat[i-1][j];\n }\n if(j>0){\n ans+=mat[i][j-1];\n }\n if(i>0 && j>0){\n ans+=mat[i-1][j-1];\n }\n if(j0 && j0 && i289. Game of Life

Medium

According to Wikipedia's article: \"The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970.\"

\n\n

The board is made up of an m x n grid of cells, where each cell has an initial state: live (represented by a 1) or dead (represented by a 0). Each cell interacts with its eight neighbors (horizontal, vertical, diagonal) using the following four rules (taken from the above Wikipedia article):

\n\n
    \n\t
  1. Any live cell with fewer than two live neighbors dies as if caused by under-population.
    2. \n\t
  2. Any live cell with two or three live neighbors lives on to the next generation.
    3. \n\t
  3. Any live cell with more than three live neighbors dies, as if by over-population.
    4. \n\t
  4. Any dead cell with exactly three live neighbors becomes a live cell, as if by reproduction.
    5. \n
\n\n

The next state is created by applying the above rules simultaneously to every cell in the current state, where births and deaths occur simultaneously. Given the current state of the m x n grid board, return the next state.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]\nOutput: [[0,0,0],[1,0,1],[0,1,1],[0,1,0]]\n
\n\n

Example 2:

\n\"\"\n
Input: board = [[1,1],[1,0]]\nOutput: [[1,1],[1,1]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == board.length
    • \n\t
  • n == board[i].length
    • \n\t
  • 1 <= m, n <= 25
    • \n\t
  • board[i][j] is 0 or 1.
    • \n
\n\n

 

\n

Follow up:

\n\n
    \n\t
  • Could you solve it in-place? Remember that the board needs to be updated simultaneously: You cannot update some cells first and then use their updated values to update other cells.
    • \n\t
  • In this question, we represent the board using a 2D array. In principle, the board is infinite, which would cause problems when the active area encroaches upon the border of the array (i.e., live cells reach the border). How would you address these problems?
    • \n
\n
" }, { "path": "29-divide-two-integers/29-divide-two-integers.java", "content": "class Solution {\n public int divide(int dividend, int divisor) {\n //the special situation\n if (dividend == 0) {\n return 0;\n }\n if (dividend == Integer.MIN_VALUE && divisor == -1) {\n return Integer.MAX_VALUE;\n }\n //mark the different situation\n boolean sign = true;\n if ((dividend > 0 && divisor < 0) || (dividend < 0 && divisor > 0)) {\n sign = false;\n }\n //change them both into negative number\n dividend = dividend > 0 ? -dividend : dividend;\n divisor = divisor > 0 ? -divisor : divisor;\n //if there are different,so it must be a negative number,just 0 minus the result\n return sign == false ? 0 - count(dividend, divisor) : count(dividend, divisor);\n }\n\n /**\n * This recursion main code is while,it just likes optimization of subtraction\n */\n private int count(int a, int b) {\n //if 3*n==7 just plus 1,or 3*n>7 just plus 0\n if (a >= b) {\n return a > b ? 0 : 1;\n }\n //the default number is 1,and 2,4,8...doubling\n int n = 1;\n int result = 0;\n int temp = b;\n while (a <= temp && temp < 0) {\n a -= temp;\n result += n;\n temp += temp;\n n += n;\n }\n return result + count(a, b);\n }\n}" }, { "path": "29-divide-two-integers/NOTES.md", "content": "​" }, { "path": "3-longest-substring-without-repeating-characters/3-longest-substring-without-repeating-characters.java", "content": "class Solution {\n public int lengthOfLongestSubstring(String s) {\n if(s.length() < 2) return s.length();\n int max = 0;\n char[] split = s.toCharArray();\n int[] map = new int[256];\n for(int i = 0, j = 0; i < split.length; i++) {\n char c = split[i]; \n j = Math.max(j, map[c]);\n map[c] = i + 1;\n max = Math.max(max, i - j + 1);\n }\n return max;\n }\n}" }, { "path": "3-longest-substring-without-repeating-characters/NOTES.md", "content": "​" }, { "path": "3-longest-substring-without-repeating-characters/README.md", "content": "

3. Longest Substring Without Repeating Characters

Medium

Given a string s, find the length of the longest substring without repeating characters.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"abcabcbb\"\nOutput: 3\nExplanation: The answer is \"abc\", with the length of 3.\n
\n\n

Example 2:

\n\n
Input: s = \"bbbbb\"\nOutput: 1\nExplanation: The answer is \"b\", with the length of 1.\n
\n\n

Example 3:

\n\n
Input: s = \"pwwkew\"\nOutput: 3\nExplanation: The answer is \"wke\", with the length of 3.\nNotice that the answer must be a substring, \"pwke\" is a subsequence and not a substring.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= s.length <= 5 * 104
    • \n\t
  • s consists of English letters, digits, symbols and spaces.
    • \n
\n
" }, { "path": "30-substring-with-concatenation-of-all-words/30-substring-with-concatenation-of-all-words.java", "content": "class Solution {\n public List findSubstring(String str, String[] words) {\n if(str == null || str.length() == 0 || words == null || words.length == 0) {\n return new ArrayList<>();\n }\n\n Map frequencyMap = new HashMap<>();\n\n for(String word: words) {\n frequencyMap.put(word, frequencyMap.getOrDefault(word, 0) + 1);\n }\n\n int eachWordLength = words[0].length();\n int totalWords = words.length;\n List result = new ArrayList<>();\n\n for (int i = 0; i <= str.length() - (totalWords * eachWordLength); i++) {\n\n Map seenWords = new HashMap<>();\n\n for (int j = 0; j < totalWords; j++) {\n int wordIndex = i + j * eachWordLength;\n\n String word = str.substring(wordIndex, wordIndex + eachWordLength);\n\n if(!frequencyMap.containsKey(word)) {\n break;\n }\n\n seenWords.put(word, seenWords.getOrDefault(word, 0) + 1);\n\n if(seenWords.get(word) > frequencyMap.get(word)) {\n break;\n }\n\n if(j + 1 == totalWords) {\n result.add(i);\n }\n }\n }\n\n return result;\n }\n}" }, { "path": "30-substring-with-concatenation-of-all-words/30-substring-with-concatenation-of-all-words.py", "content": "class Solution:\n def findSubstring(self, s: str, words: List[str]) -> List[int]:\n\n words_counter = Counter(words)\n WORDLEN = len(words[0])\n MATCHLEN = (len(words) - 1) * WORDLEN\n\n res = []\n stack = deque()\n \n for offset in range(WORDLEN):\n counter = words_counter.copy()\n for i in range(offset, len(s), WORDLEN):\n word = s[i: i + WORDLEN]\n while len(stack) and word not in counter:\n prev = stack.popleft()\n if prev == word:\n stack.append(word)\n break\n counter[prev] += 1\n \n if word in counter:\n counter[word] -= 1\n stack.append(word)\n if counter[word] == 0:\n del counter[word]\n \n if len(counter) == 0:\n res.append(i - MATCHLEN)\n \n stack.clear() # Clears stack in the cases there are left overs from previous offset\n \n return res\n" }, { "path": "30-substring-with-concatenation-of-all-words/NOTES.md", "content": "​" }, { "path": "30-substring-with-concatenation-of-all-words/README.md", "content": "

30. Substring with Concatenation of All Words

Hard

You are given a string s and an array of strings words of the same length. Return all starting indices of substring(s) in s that is a concatenation of each word in words exactly once, in any order, and without any intervening characters.

\n\n

You can return the answer in any order.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"barfoothefoobarman\", words = [\"foo\",\"bar\"]\nOutput: [0,9]\nExplanation: Substrings starting at index 0 and 9 are \"barfoo\" and \"foobar\" respectively.\nThe output order does not matter, returning [9,0] is fine too.\n
\n\n

Example 2:

\n\n
Input: s = \"wordgoodgoodgoodbestword\", words = [\"word\",\"good\",\"best\",\"word\"]\nOutput: []\n
\n\n

Example 3:

\n\n
Input: s = \"barfoofoobarthefoobarman\", words = [\"bar\",\"foo\",\"the\"]\nOutput: [6,9,12]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 104
    • \n\t
  • 1 <= words.length <= 5000
    • \n\t
  • 1 <= words[i].length <= 30
    • \n\t
  • s and words[i] consist of lowercase English letters.
    • \n
\n
" }, { "path": "300-longest-increasing-subsequence/300-longest-increasing-subsequence.java", "content": "class Solution {\n public int lengthOfLIS(int[] nums) {\n int[]dp=new int[nums.length];\n Arrays.fill(dp,1);\n for(int i=nums.length-2;i>=0;i--){\n for(int j=i+1;j300. Longest Increasing Subsequence

Medium

Given an integer array nums, return the length of the longest strictly increasing subsequence.

\n\n

A subsequence is a sequence that can be derived from an array by deleting some or no elements without changing the order of the remaining elements. For example, [3,6,2,7] is a subsequence of the array [0,3,1,6,2,2,7].

\n\n

 

\n

Example 1:

\n\n
Input: nums = [10,9,2,5,3,7,101,18]\nOutput: 4\nExplanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.\n
\n\n

Example 2:

\n\n
Input: nums = [0,1,0,3,2,3]\nOutput: 4\n
\n\n

Example 3:

\n\n
Input: nums = [7,7,7,7,7,7,7]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 2500
    • \n\t
  • -104 <= nums[i] <= 104
    • \n
\n\n

 

\n

Follow up: Can you come up with an algorithm that runs in O(n log(n)) time complexity?

\n
" }, { "path": "304-range-sum-query-2d-immutable/304-range-sum-query-2d-immutable.java", "content": "class NumMatrix {\n int[][]mat;\n int[][]sum;\n public NumMatrix(int[][] matrix) {\n mat=matrix;\n int n=matrix.length;\n int m=matrix[0].length;\n sum=new int[n][m];\n for(int i=0;i304. Range Sum Query 2D - Immutable

Medium

Given a 2D matrix matrix, handle multiple queries of the following type:

\n\n
    \n\t
  • Calculate the sum of the elements of matrix inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).
    • \n
\n\n

Implement the NumMatrix class:

\n\n
    \n\t
  • NumMatrix(int[][] matrix) Initializes the object with the integer matrix matrix.
    • \n\t
  • int sumRegion(int row1, int col1, int row2, int col2) Returns the sum of the elements of matrix inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input\n[\"NumMatrix\", \"sumRegion\", \"sumRegion\", \"sumRegion\"]\n[[[[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]]], [2, 1, 4, 3], [1, 1, 2, 2], [1, 2, 2, 4]]\nOutput\n[null, 8, 11, 12]\n\nExplanation\nNumMatrix numMatrix = new NumMatrix([[3, 0, 1, 4, 2], [5, 6, 3, 2, 1], [1, 2, 0, 1, 5], [4, 1, 0, 1, 7], [1, 0, 3, 0, 5]]);\nnumMatrix.sumRegion(2, 1, 4, 3); // return 8 (i.e sum of the red rectangle)\nnumMatrix.sumRegion(1, 1, 2, 2); // return 11 (i.e sum of the green rectangle)\nnumMatrix.sumRegion(1, 2, 2, 4); // return 12 (i.e sum of the blue rectangle)\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == matrix.length
    • \n\t
  • n == matrix[i].length
    • \n\t
  • 1 <= m, n <= 200
    • \n\t
  • -105 <= matrix[i][j] <= 105
    • \n\t
  • 0 <= row1 <= row2 < m
    • \n\t
  • 0 <= col1 <= col2 < n
    • \n\t
  • At most 104 calls will be made to sumRegion.
    • \n
\n
" }, { "path": "307-range-sum-query-mutable/307-range-sum-query-mutable.java", "content": "class NumArray {\n class SegmentTreeNode {\n int start, end;\n SegmentTreeNode left, right;\n int sum;\n\n public SegmentTreeNode(int start, int end) {\n this.start = start;\n this.end = end;\n this.left = null;\n this.right = null;\n this.sum = 0;\n }\n }\n \n SegmentTreeNode root = null;\n \n public NumArray(int[] nums) {\n root = buildTree(nums, 0, nums.length-1);\n }\n\n private SegmentTreeNode buildTree(int[] nums, int start, int end) {\n if (start > end) {\n return null;\n } else {\n SegmentTreeNode ret = new SegmentTreeNode(start, end);\n if (start == end) {\n ret.sum = nums[start];\n } else {\n int mid = start + (end - start) / 2; \n ret.left = buildTree(nums, start, mid);\n ret.right = buildTree(nums, mid + 1, end);\n ret.sum = ret.left.sum + ret.right.sum;\n } \n return ret;\n }\n }\n \n void update(int i, int val) {\n update(root, i, val);\n }\n \n void update(SegmentTreeNode root, int pos, int val) {\n if (root.start == root.end) {\n root.sum = val;\n } else {\n int mid = root.start + (root.end - root.start) / 2;\n if (pos <= mid) {\n update(root.left, pos, val);\n } else {\n update(root.right, pos, val);\n }\n root.sum = root.left.sum + root.right.sum;\n }\n }\n\n public int sumRange(int i, int j) {\n return sumRange(root, i, j);\n }\n \n public int sumRange(SegmentTreeNode root, int start, int end) {\n if (root.end == end && root.start == start) {\n return root.sum;\n } else {\n int mid = root.start + (root.end - root.start) / 2;\n if (end <= mid) {\n return sumRange(root.left, start, end);\n } else if (start >= mid+1) {\n return sumRange(root.right, start, end);\n } else { \n return sumRange(root.right, mid+1, end) + sumRange(root.left, start, mid);\n }\n }\n }\n}\n\n/**\n * Your NumArray object will be instantiated and called as such:\n * NumArray obj = new NumArray(nums);\n * obj.update(index,val);\n * int param_2 = obj.sumRange(left,right);\n */" }, { "path": "307-range-sum-query-mutable/NOTES.md", "content": "​" }, { "path": "307-range-sum-query-mutable/README.md", "content": "

307. Range Sum Query - Mutable

Medium

Given an integer array nums, handle multiple queries of the following types:

\n\n
    \n\t
  1. Update the value of an element in nums.
    2. \n\t
  2. Calculate the sum of the elements of nums between indices left and right inclusive where left <= right.
    3. \n
\n\n

Implement the NumArray class:

\n\n
    \n\t
  • NumArray(int[] nums) Initializes the object with the integer array nums.
    • \n\t
  • void update(int index, int val) Updates the value of nums[index] to be val.
    • \n\t
  • int sumRange(int left, int right) Returns the sum of the elements of nums between indices left and right inclusive (i.e. nums[left] + nums[left + 1] + ... + nums[right]).
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"NumArray\", \"sumRange\", \"update\", \"sumRange\"]\n[[[1, 3, 5]], [0, 2], [1, 2], [0, 2]]\nOutput\n[null, 9, null, 8]\n\nExplanation\nNumArray numArray = new NumArray([1, 3, 5]);\nnumArray.sumRange(0, 2); // return 1 + 3 + 5 = 9\nnumArray.update(1, 2);   // nums = [1, 2, 5]\nnumArray.sumRange(0, 2); // return 1 + 2 + 5 = 8\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 3 * 104
    • \n\t
  • -100 <= nums[i] <= 100
    • \n\t
  • 0 <= index < nums.length
    • \n\t
  • -100 <= val <= 100
    • \n\t
  • 0 <= left <= right < nums.length
    • \n\t
  • At most 3 * 104 calls will be made to update and sumRange.
    • \n
\n
" }, { "path": "31-next-permutation/31-next-permutation.java", "content": "class Solution {\n public void nextPermutation(int[] a) {\n int N=a.length;\n int k=-1;\n for(int i=0;ia[k]){\n l=i;\n }\n }\n int temp=a[k];\n a[k]=a[l];\n a[l]=temp;\n reverse(a,k+1,N-1);\n }\n public void reverse(int[]a,int i,int j){\n while(i<=j-1){\n int temp=a[i];\n a[i]=a[j];\n a[j]=temp;\n i++;\n j--;\n }\n }\n}" }, { "path": "31-next-permutation/NOTES.md", "content": "​" }, { "path": "31-next-permutation/README.md", "content": "

31. Next Permutation

Medium

A permutation of an array of integers is an arrangement of its members into a sequence or linear order.

\n\n
    \n\t
  • For example, for arr = [1,2,3], the following are considered permutations of arr: [1,2,3], [1,3,2], [3,1,2], [2,3,1].
    • \n
\n\n

The next permutation of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the next permutation of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order).

\n\n
    \n\t
  • For example, the next permutation of arr = [1,2,3] is [1,3,2].
    • \n\t
  • Similarly, the next permutation of arr = [2,3,1] is [3,1,2].
    • \n\t
  • While the next permutation of arr = [3,2,1] is [1,2,3] because [3,2,1] does not have a lexicographical larger rearrangement.
    • \n
\n\n

Given an array of integers nums, find the next permutation of nums.

\n\n

The replacement must be in place and use only constant extra memory.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3]\nOutput: [1,3,2]\n
\n\n

Example 2:

\n\n
Input: nums = [3,2,1]\nOutput: [1,2,3]\n
\n\n

Example 3:

\n\n
Input: nums = [1,1,5]\nOutput: [1,5,1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 100
    • \n\t
  • 0 <= nums[i] <= 100
    • \n
\n
" }, { "path": "31-next-permutation/nextPurmutation.cpp", "content": "/*\nApproach: \nThere may be three possibilities for the given sequence, it could be in ascending, descending or mixed Order.\nBased upon that three subcases will be applied\n1. Descending Order : For this we simply need to return a series in acending order i.e. a Sorted Array\n2. Ascending Order : By just swapping last two unequal numbers of array, we could get a Required next Permutation.\n3. Mixed Order : For this we need to find the right most local maxima, after that is find further two cases may arise: \n i) If a number exists in right of this local maxima which is less than this maxima and greater than element before maxima(let say that as midVal)\n In that cases swapping midVal with element just before local maxima will give, next premutaion, as that would be more close.\n ii) In case if no such Element Exists, in that case directly swapping local maxima with element before than will be right.\n \n After doing any of i or ii, we need to sort remainning right array in ascending order. \n\n*/\n\n// Code : \n\nclass Solution {\npublic:\nint findIfMidExists(vector& nums, int t){\n int ans = -1;\n for(int i=t+1;inums[t-1]){\n ans = i;\n }\n }\n return ans;\n} \n void nextPermutation(vector& nums) {\n if(nums.size()==1) return ;\n if(nums.size()==2){\n swap(nums[0], nums[1]);\n return;\n }\n int n = nums.size(), mx = n-1, i=n-1;\n for(;i>=0;i--){\n if(i==n-1 && nums[i]>nums[i-1]){ \n mx = n-1;\n break;}\n else if(i>0 && nums[i]>nums[i-1] && nums[i]>=nums[i+1]){ \n mx = i;\n break;\n }\n }\n // If Given series is in descending Order\n if(i<0){\n sort(nums.begin(), nums.end());\n return;\n }\n \n int midVal = findIfMidExists(nums,mx);\n if(midVal != -1){\n swap(nums[mx-1], nums[midVal]);\n sort(nums.begin()+mx, nums.end());\n return;\n }\n swap(nums[mx-1], nums[mx]);\n sort(nums.begin() + mx, nums.end());\n }\n};\n" }, { "path": "315-count-of-smaller-numbers-after-self/315-count-of-smaller-numbers-after-self.java", "content": "class Solution {\n public List countSmaller(int[] nums) {\n int n=nums.length;\n Integer[] ans=new Integer[n];\n ans[n-1]=0;\n int ii=n-2;\n List arr=new ArrayList<>();\n arr.add(nums[n-1]);\n for(int i=n-2;i>=0;i--){\n int idx=dfs(arr,nums[i]);\n arr.add(idx,nums[i]);\n ans[ii]=idx;\n ii--;\n }\n return Arrays.asList(ans);\n }\n int dfs(List arr,int ele){\n int l=0;\n int h=arr.size()-1;\n while(l<=h){\n int mid=l+(h-l)/2;\n if(ele<=arr.get(mid)){\n h=mid-1;\n }else{\n l=mid+1;\n }\n }\n return l;\n }\n}" }, { "path": "315-count-of-smaller-numbers-after-self/NOTES.md", "content": "​" }, { "path": "315-count-of-smaller-numbers-after-self/README.md", "content": "

315. Count of Smaller Numbers After Self

Hard

You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].

\n\n

 

\n

Example 1:

\n\n
Input: nums = [5,2,6,1]\nOutput: [2,1,1,0]\nExplanation:\nTo the right of 5 there are 2 smaller elements (2 and 1).\nTo the right of 2 there is only 1 smaller element (1).\nTo the right of 6 there is 1 smaller element (1).\nTo the right of 1 there is 0 smaller element.\n
\n\n

Example 2:

\n\n
Input: nums = [-1]\nOutput: [0]\n
\n\n

Example 3:

\n\n
Input: nums = [-1,-1]\nOutput: [0,0]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • -104 <= nums[i] <= 104
    • \n
\n
" }, { "path": "316-remove-duplicate-letters/316-remove-duplicate-letters.java", "content": "class Solution {\n public String removeDuplicateLetters(String s) {\n int[]freq=new int[26];\n int[]done=new int[26];\n for(char c:s.toCharArray()){\n freq[c-97]++;\n }\n Deque stack=new ArrayDeque<>();\n for(int i=0;i0 && stack.peek()>ch){\n if(freq[stack.peek()-97]>0){\n char out=stack.pop();\n done[out-97]=0;\n }else{\n break;\n }\n }\n done[ch-97]=1;\n stack.push(ch);\n }\n freq[ch-97]--;\n }\n StringBuilder sb=new StringBuilder();\n while(stack.size()>0){\n sb.append(stack.pop());\n }\n return sb.reverse().toString();\n }\n}" }, { "path": "316-remove-duplicate-letters/NOTES.md", "content": "​" }, { "path": "316-remove-duplicate-letters/README.md", "content": "

316. Remove Duplicate Letters

Medium

Given a string s, remove duplicate letters so that every letter appears once and only once. You must make sure your result is the smallest in lexicographical order among all possible results.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"bcabc\"\nOutput: \"abc\"\n
\n\n

Example 2:

\n\n
Input: s = \"cbacdcbc\"\nOutput: \"acdb\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 104
    • \n\t
  • s consists of lowercase English letters.
    • \n
\n\n

 

\n

Note: This question is the same as 1081: https://leetcode.com/problems/smallest-subsequence-of-distinct-characters/

\n
" }, { "path": "318-maximum-product-of-word-lengths/318-maximum-product-of-word-lengths.java", "content": "class Solution {\n public int maxProduct(String[] words) {\n int n=words.length;\n int[] mask=new int[n];\n for(int i=0; i318. Maximum Product of Word Lengths

Medium

Given a string array words, return the maximum value of length(word[i]) * length(word[j]) where the two words do not share common letters. If no such two words exist, return 0.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"abcw\",\"baz\",\"foo\",\"bar\",\"xtfn\",\"abcdef\"]\nOutput: 16\nExplanation: The two words can be \"abcw\", \"xtfn\".\n
\n\n

Example 2:

\n\n
Input: words = [\"a\",\"ab\",\"abc\",\"d\",\"cd\",\"bcd\",\"abcd\"]\nOutput: 4\nExplanation: The two words can be \"ab\", \"cd\".\n
\n\n

Example 3:

\n\n
Input: words = [\"a\",\"aa\",\"aaa\",\"aaaa\"]\nOutput: 0\nExplanation: No such pair of words.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= words.length <= 1000
    • \n\t
  • 1 <= words[i].length <= 1000
    • \n\t
  • words[i] consists only of lowercase English letters.
    • \n
\n
" }, { "path": "32-longest-valid-parentheses/32-longest-valid-parentheses.java", "content": "public class Solution {\n public int longestValidParentheses(String s) {\n int left = 0, right = 0, maxlength = 0;\n for (int i = 0; i < s.length(); i++) {\n if (s.charAt(i) == '(') {\n left++;\n } else {\n right++;\n }\n if (left == right) {\n maxlength = Math.max(maxlength, 2 * right);\n } else if (right >= left) {\n left = right = 0;\n }\n }\n left = right = 0;\n for (int i = s.length() - 1; i >= 0; i--) {\n if (s.charAt(i) == '(') {\n left++;\n } else {\n right++;\n }\n if (left == right) {\n maxlength = Math.max(maxlength, 2 * left);\n } else if (left >= right) {\n left = right = 0;\n }\n }\n return maxlength;\n }\n}" }, { "path": "32-longest-valid-parentheses/NOTES.md", "content": "​" }, { "path": "32-longest-valid-parentheses/README.md", "content": "

32. Longest Valid Parentheses

Hard

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"(()\"\nOutput: 2\nExplanation: The longest valid parentheses substring is \"()\".\n
\n\n

Example 2:

\n\n
Input: s = \")()())\"\nOutput: 4\nExplanation: The longest valid parentheses substring is \"()()\".\n
\n\n

Example 3:

\n\n
Input: s = \"\"\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= s.length <= 3 * 104
    • \n\t
  • s[i] is '(', or ')'.
    • \n
\n
" }, { "path": "322-coin-change/322-coin-change.java", "content": "class Solution {\n public int coinChange(int[] coins, int amount) {\n int dp[]=new int[amount+1];\n Arrays.fill(dp,amount+1);\n dp[0]=0;\n for(int coin:coins){\n for(int i=coin;i<=amount;i++){//322. Coin Change

Medium

You are given an integer array coins representing coins of different denominations and an integer amount representing a total amount of money.

\n\n

Return the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

\n\n

You may assume that you have an infinite number of each kind of coin.

\n\n

 

\n

Example 1:

\n\n
Input: coins = [1,2,5], amount = 11\nOutput: 3\nExplanation: 11 = 5 + 5 + 1\n
\n\n

Example 2:

\n\n
Input: coins = [2], amount = 3\nOutput: -1\n
\n\n

Example 3:

\n\n
Input: coins = [1], amount = 0\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= coins.length <= 12
    • \n\t
  • 1 <= coins[i] <= 231 - 1
    • \n\t
  • 0 <= amount <= 104
    • \n
\n
" }, { "path": "326-power-of-three/326-power-of-three.java", "content": "public class Solution {\n public boolean isPowerOfThree(int n) {\n return n > 0 && 1162261467 % n == 0;\n }\n}" }, { "path": "326-power-of-three/326_Power_of_three.cpp", "content": "class Solution {\npublic:\n bool isPowerOfThree(int n) {\n while(n>=3)\n {\n if(n%3 != 0)\n return false;\n n/=3;\n }\n return n==1;\n }\n};\n" }, { "path": "326-power-of-three/NOTES.md", "content": "​" }, { "path": "326-power-of-three/README.md", "content": "

326. Power of Three

Easy

Given an integer n, return true if it is a power of three. Otherwise, return false.

\n\n

An integer n is a power of three, if there exists an integer x such that n == 3x.

\n\n

 

\n

Example 1:

\n\n
Input: n = 27\nOutput: true\n
\n\n

Example 2:

\n\n
Input: n = 0\nOutput: false\n
\n\n

Example 3:

\n\n
Input: n = 9\nOutput: true\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • -231 <= n <= 231 - 1
    • \n
\n\n

 

\nFollow up: Could you solve it without loops/recursion?
" }, { "path": "329-longest-increasing-path-in-a-matrix/329-longest-increasing-path-in-a-matrix.java", "content": "class Solution {\n int[][] matrix, helper;\n int[][] dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};\n public int longestIncreasingPath(int[][] matrix) {\n helper = new int[matrix.length][matrix[0].length];\n this.matrix= matrix;\n int path = 0;\n for(int i=0;i= 0 && i < matrix.length && j >= 0 && j < matrix[0].length && matrix[x][y] < matrix[i][j]) {\n helper[x][y] = Math.max(helper[x][y], dfs(i, j));\n }\n }\n return ++helper[x][y];\n }\n}" }, { "path": "329-longest-increasing-path-in-a-matrix/README.md", "content": "

329. Longest Increasing Path in a Matrix

Hard

Given an m x n integers matrix, return the length of the longest increasing path in matrix.

\n\n

From each cell, you can either move in four directions: left, right, up, or down. You may not move diagonally or move outside the boundary (i.e., wrap-around is not allowed).

\n\n

 

\n

Example 1:

\n\"\"\n
Input: matrix = [[9,9,4],[6,6,8],[2,1,1]]\nOutput: 4\nExplanation: The longest increasing path is [1, 2, 6, 9].\n
\n\n

Example 2:

\n\"\"\n
Input: matrix = [[3,4,5],[3,2,6],[2,2,1]]\nOutput: 4\nExplanation: The longest increasing path is [3, 4, 5, 6]. Moving diagonally is not allowed.\n
\n\n

Example 3:

\n\n
Input: matrix = [[1]]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == matrix.length
    • \n\t
  • n == matrix[i].length
    • \n\t
  • 1 <= m, n <= 200
    • \n\t
  • 0 <= matrix[i][j] <= 231 - 1
    • \n
\n
" }, { "path": "33-search-in-rotated-sorted-array/33-search-in-rotated-sorted-array.java", "content": "class Solution {\n public int search(int[] nums, int target) {\n int l=0,h=nums.length-1;\n while(l<=h){\n int mid=(l+h)/2;\n if(nums[mid]==target){\n return mid;\n }\n else if(nums[mid]>=nums[l]){\n if(target>=nums[l] && targetnums[mid] && target<=nums[h]){\n l=mid+1;\n }else{\n h=mid-1;\n }\n }\n }\n return -1;\n }\n}" }, { "path": "33-search-in-rotated-sorted-array/README.md", "content": "

33. Search in Rotated Sorted Array

Medium

There is an integer array nums sorted in ascending order (with distinct values).

\n\n

Prior to being passed to your function, nums is possibly rotated at an unknown pivot index k (1 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and become [4,5,6,7,0,1,2].

\n\n

Given the array nums after the possible rotation and an integer target, return the index of target if it is in nums, or -1 if it is not in nums.

\n\n

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

\n\n

 

\n

Example 1:

\n
Input: nums = [4,5,6,7,0,1,2], target = 0\nOutput: 4\n

Example 2:

\n
Input: nums = [4,5,6,7,0,1,2], target = 3\nOutput: -1\n

Example 3:

\n
Input: nums = [1], target = 0\nOutput: -1\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 5000
    • \n\t
  • -104 <= nums[i] <= 104
    • \n\t
  • All values of nums are unique.
    • \n\t
  • nums is an ascending array that is possibly rotated.
    • \n\t
  • -104 <= target <= 104
    • \n
\n
" }, { "path": "336-palindrome-pairs/336-palindrome-pairs.java", "content": "class Solution {\n public List> palindromePairs(String[] words) {\n List> ans=new ArrayList<>();\n Map map= new HashMap<>();\n int idx=0;\n for(String word:words){\n StringBuilder sb=new StringBuilder(word);\n map.put(sb.reverse().toString(),idx++);\n }\n for(int i=0;i curr=new ArrayList<>();\n curr.add(i);\n curr.add(map.get(s1));\n ans.add(curr);\n }\n if(!s1.isEmpty() && map.containsKey(s2) && map.get(s2)!=i && isPal(s1)){\n List curr=new ArrayList<>();\n curr.add(map.get(s2));\n curr.add(i);\n ans.add(curr);\n }\n \n }\n }\n return ans;\n }\n boolean isPal(String s){\n int i=0;\n int j=s.length()-1;\n while(i336. Palindrome Pairs

Hard

Given a list of unique words, return all the pairs of the distinct indices (i, j) in the given list, so that the concatenation of the two words words[i] + words[j] is a palindrome.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"abcd\",\"dcba\",\"lls\",\"s\",\"sssll\"]\nOutput: [[0,1],[1,0],[3,2],[2,4]]\nExplanation: The palindromes are [\"dcbaabcd\",\"abcddcba\",\"slls\",\"llssssll\"]\n
\n\n

Example 2:

\n\n
Input: words = [\"bat\",\"tab\",\"cat\"]\nOutput: [[0,1],[1,0]]\nExplanation: The palindromes are [\"battab\",\"tabbat\"]\n
\n\n

Example 3:

\n\n
Input: words = [\"a\",\"\"]\nOutput: [[0,1],[1,0]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words.length <= 5000
    • \n\t
  • 0 <= words[i].length <= 300
    • \n\t
  • words[i] consists of lower-case English letters.
    • \n
\n
" }, { "path": "34-find-first-and-last-position-of-element-in-sorted-array/34-find-first-and-last-position-of-element-in-sorted-array.java", "content": "class Solution {\n public int[] searchRange(int[] nums, int target) {\n int[] ans=new int[2];\n ans[0]=Integer.MAX_VALUE;\n ans[1]=Integer.MIN_VALUE;\n dfs(nums,target,ans,0,nums.length-1);\n if(ans[0]==Integer.MAX_VALUE){\n ans[0]=-1;\n ans[1]=-1;\n }\n return ans;\n }\n void dfs(int[]nums,int target,int[]ans,int l,int h){\n if(l<=h){\n int mid=l+(h-l)/2;\n if(nums[mid]==target){\n ans[0]=Math.min(ans[0],mid);\n ans[1]=Math.max(ans[1],mid);\n dfs(nums,target,ans,l,mid-1);\n dfs(nums,target,ans,mid+1,h);\n }else if(nums[mid]>target){\n dfs(nums,target,ans,l,mid-1);\n }else{\n dfs(nums,target,ans,mid+1,h);\n }\n }\n }\n}" }, { "path": "34-find-first-and-last-position-of-element-in-sorted-array/README.md", "content": "

34. Find First and Last Position of Element in Sorted Array

Medium

Given an array of integers nums sorted in non-decreasing order, find the starting and ending position of a given target value.

\n\n

If target is not found in the array, return [-1, -1].

\n\n

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

\n\n

 

\n

Example 1:

\n
Input: nums = [5,7,7,8,8,10], target = 8\nOutput: [3,4]\n

Example 2:

\n
Input: nums = [5,7,7,8,8,10], target = 6\nOutput: [-1,-1]\n

Example 3:

\n
Input: nums = [], target = 0\nOutput: [-1,-1]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= nums.length <= 105
    • \n\t
  • -109 <= nums[i] <= 109
    • \n\t
  • nums is a non-decreasing array.
    • \n\t
  • -109 <= target <= 109
    • \n
\n
" }, { "path": "341-flatten-nested-list-iterator/341-flatten-nested-list-iterator.java", "content": "public class NestedIterator implements Iterator {\n \n List list;\n int index = 0;\n \n public NestedIterator(List nestedList) {\n list = new ArrayList();\n worker(nestedList);\n }\n\n void worker(List node) {\n if(node==null) {\n return;\n }\n for(NestedInteger next:node) {\n if(next.isInteger()) {\n list.add(next.getInteger());\n } else {\n worker(next.getList());\n }\n }\n }\n \n @Override\n public Integer next() {\n int val = list.get(index);\n index++;\n return val;\n }\n\n @Override\n public boolean hasNext() {\n return index341. Flatten Nested List Iterator

Medium

You are given a nested list of integers nestedList. Each element is either an integer or a list whose elements may also be integers or other lists. Implement an iterator to flatten it.

\n\n

Implement the NestedIterator class:

\n\n
    \n\t
  • NestedIterator(List<NestedInteger> nestedList) Initializes the iterator with the nested list nestedList.
    • \n\t
  • int next() Returns the next integer in the nested list.
    • \n\t
  • boolean hasNext() Returns true if there are still some integers in the nested list and false otherwise.
    • \n
\n\n

Your code will be tested with the following pseudocode:

\n\n
initialize iterator with nestedList\nres = []\nwhile iterator.hasNext()\n    append iterator.next() to the end of res\nreturn res\n
\n\n

If res matches the expected flattened list, then your code will be judged as correct.

\n\n

 

\n

Example 1:

\n\n
Input: nestedList = [[1,1],2,[1,1]]\nOutput: [1,1,2,1,1]\nExplanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].\n
\n\n

Example 2:

\n\n
Input: nestedList = [1,[4,[6]]]\nOutput: [1,4,6]\nExplanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nestedList.length <= 500
    • \n\t
  • The values of the integers in the nested list is in the range [-106, 106].
    • \n
\n
" }, { "path": "342-power-of-four/342-power-of-four.java", "content": "class Solution {\n public boolean isPowerOfFour(int n) {\n if(n==0)return false;\n int x=(int)(Math.log(n)/Math.log(4));\n if(Math.pow(4,x)==n)return true;\n return false;\n }\n}" }, { "path": "342-power-of-four/NOTES.md", "content": "​" }, { "path": "342-power-of-four/README.md", "content": "

342. Power of Four

Easy

Given an integer n, return true if it is a power of four. Otherwise, return false.

\n\n

An integer n is a power of four, if there exists an integer x such that n == 4x.

\n\n

 

\n

Example 1:

\n
Input: n = 16\nOutput: true\n

Example 2:

\n
Input: n = 5\nOutput: false\n

Example 3:

\n
Input: n = 1\nOutput: true\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • -231 <= n <= 231 - 1
    • \n
\n\n

 

\nFollow up: Could you solve it without loops/recursion?
" }, { "path": "342-power-of-four/power of four.cpp", "content": "bool isPowerOfFour(int n) {\n long int ans=0;\n int i=0;\n \n while(ans<=n)\n {\n ans=pow(4,i);\n i++;\n if(ans==n)\n return true;\n }\n return false;\n }\n" }, { "path": "344-reverse-string/344-reverse-string.java", "content": "class Solution {\n public void reverseString(char[] s) {\n int n=s.length;\n for(int i=0;i344. Reverse String

Easy

Write a function that reverses a string. The input string is given as an array of characters s.

\n\n

You must do this by modifying the input array in-place with O(1) extra memory.

\n\n

 

\n

Example 1:

\n
Input: s = [\"h\",\"e\",\"l\",\"l\",\"o\"]\nOutput: [\"o\",\"l\",\"l\",\"e\",\"h\"]\n

Example 2:

\n
Input: s = [\"H\",\"a\",\"n\",\"n\",\"a\",\"h\"]\nOutput: [\"h\",\"a\",\"n\",\"n\",\"a\",\"H\"]\n
\n

 

\n

Constraints:

\n\n\n
" }, { "path": "347-top-k-frequent-elements/347-top-k-frequent-elements.cpp", "content": "class Solution {\npublic:\n vector topKFrequent(vector& nums, int k) {\n \n // 1.\n // unordered_map mp;\n // for(int i=0;i ans;\n // while(ans.size() < k){\n // int f = INT_MIN;\n // int t;\n // for(auto it : mp){ \n // if(f < it.second){\n // f = it.second;\n // t = it.first;\n // }\n // }\n // if(ans.size() < k)\n // ans.push_back(t);\n // mp.erase(t);\n // }\n // return ans;\n \n \n // by default the priority queue will sort the first value of pairs in descending order\n // 2. \n unordered_map mp;\n for(int i=0;i ans(k, 0);\n priority_queue> pq;\n for(auto it : mp){\n pair p;\n p.first = it.second;\n p.second = it.first;\n pq.push(p);\n }\n int i=0;\n while(imap=new HashMap<>();\n for(int i:nums){\n map.put(i,map.getOrDefault(i,0)+1);\n }\n PriorityQueue pq=new PriorityQueue<>((a,b)->b[1]-a[1]);\n for(Map.Entry entry:map.entrySet()){\n int[]a=new int[]{entry.getKey(),entry.getValue()};\n pq.add(a);\n }\n int i=0;\n while(i347. Top K Frequent Elements

Medium

Given an integer array nums and an integer k, return the k most frequent elements. You may return the answer in any order.

\n\n

 

\n

Example 1:

\n
Input: nums = [1,1,1,2,2,3], k = 2\nOutput: [1,2]\n

Example 2:

\n
Input: nums = [1], k = 1\nOutput: [1]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • k is in the range [1, the number of unique elements in the array].
    • \n\t
  • It is guaranteed that the answer is unique.
    • \n
\n\n

 

\n

Follow up: Your algorithm's time complexity must be better than O(n log n), where n is the array's size.

\n
" }, { "path": "354-russian-doll-envelopes/354-russian-doll-envelopes.java", "content": "public class Solution {\n public int maxEnvelopes(int[][] envelopes) {\n if(envelopes.length < 2) return envelopes.length;\n \n Arrays.sort(envelopes, new EnvelopeComparator());\n int[] dp = new int[envelopes.length];\n int size = 0;\n \n for(int[] envelope: envelopes) {\n // binary search\n int left = 0, right = size, middle = 0; // right = size\n while(left < right) {\n middle = left + (right - left) / 2;\n if(dp[middle] < envelope[1]) left = middle + 1;\n else right = middle;\n }\n \n // left is the right position to 'replace' in dp array\n dp[left] = envelope[1];\n if(left == size) size++;\n }\n return size;\n }\n \n class EnvelopeComparator implements Comparator {\n public int compare(int[] e1, int[] e2) {\n return e1[0] == e2[0] ? e2[1] - e1[1] : e1[0] - e2[0];\n }\n }\n}" }, { "path": "354-russian-doll-envelopes/NOTES.md", "content": "​" }, { "path": "354-russian-doll-envelopes/README.md", "content": "

354. Russian Doll Envelopes

Hard

You are given a 2D array of integers envelopes where envelopes[i] = [wi, hi] represents the width and the height of an envelope.

\n\n

One envelope can fit into another if and only if both the width and height of one envelope are greater than the other envelope's width and height.

\n\n

Return the maximum number of envelopes you can Russian doll (i.e., put one inside the other).

\n\n

Note: You cannot rotate an envelope.

\n\n

 

\n

Example 1:

\n\n
Input: envelopes = [[5,4],[6,4],[6,7],[2,3]]\nOutput: 3\nExplanation: The maximum number of envelopes you can Russian doll is 3 ([2,3] => [5,4] => [6,7]).\n
\n\n

Example 2:

\n\n
Input: envelopes = [[1,1],[1,1],[1,1]]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= envelopes.length <= 105
    • \n\t
  • envelopes[i].length == 2
    • \n\t
  • 1 <= wi, hi <= 105
    • \n
\n
" }, { "path": "363-max-sum-of-rectangle-no-larger-than-k/363-max-sum-of-rectangle-no-larger-than-k.cpp", "content": "// problem is a combination of 2 problems first is max sum of rectangle and second is sum of subarray not greater than k\nclass Solution {\npublic:\n int maxSumSubmatrix(vector>& mat, int k) {\n int row = mat.size();\n int col = mat[0].size();\n int maxLen=INT_MIN;\n for(int left = 0; left < col; left++){\n vector v(row, 0); \n for(int right = left; right < col; right++){\n for(int i = 0; i < row; i++){\n v[i] += mat[i][right]; \n }\n set s = {0};\n int run_sum=0;\n for(int sum : v){\n run_sum += sum;\n auto it = s.lower_bound(run_sum - k);\n if(it != s.end())\n maxLen = max(maxLen, run_sum - *it); \n s.insert(run_sum);\n }\n }\n }\n return maxLen;\n }\n};\n" }, { "path": "363-max-sum-of-rectangle-no-larger-than-k/363-max-sum-of-rectangle-no-larger-than-k.java", "content": "class Solution {\n public int maxSumSubmatrix(int[][] mat, int k) {\n int n=mat.length;\n int m=mat[0].length;\n \n //create prefix sum array\n int[][]pre=new int[n][m];\n pre[0][0]=mat[0][0];\n for(int i=1;i363. Max Sum of Rectangle No Larger Than K

Hard

Given an m x n matrix matrix and an integer k, return the max sum of a rectangle in the matrix such that its sum is no larger than k.

\n\n

It is guaranteed that there will be a rectangle with a sum no larger than k.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: matrix = [[1,0,1],[0,-2,3]], k = 2\nOutput: 2\nExplanation: Because the sum of the blue rectangle [[0, 1], [-2, 3]] is 2, and 2 is the max number no larger than k (k = 2).\n
\n\n

Example 2:

\n\n
Input: matrix = [[2,2,-1]], k = 3\nOutput: 3\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == matrix.length
    • \n\t
  • n == matrix[i].length
    • \n\t
  • 1 <= m, n <= 100
    • \n\t
  • -100 <= matrix[i][j] <= 100
    • \n\t
  • -105 <= k <= 105
    • \n
\n\n

 

\n

Follow up: What if the number of rows is much larger than the number of columns?

\n
" }, { "path": "37-Sudoku-solver/37-Sudoku-solver.js", "content": "var solveSudoku = function(board) {\n\n function isValid(grid, row, col, k) {\n for (let i = 0; i < 9; i++) {\n const m = 3 * Math.floor(row / 3) + Math.floor(i / 3);\n const n = 3 * Math.floor(col / 3) + i % 3;\n if (grid[row][i] == k || grid[i][col] == k || grid[m][n] == k) {\n return false;\n }\n }\n return true;\n }\n\n\n function solve(grid) {\n\n for (let i = 0; i < 9; i++) {\n for (let j = 0; j < 9; j++) {\n\n if (grid[i][j] == '.') {\n\n for (let k = 1; k <= 9; k++) {\n\n if (isValid(grid, i, j, k)) {\n grid[i][j] = `${k}`;\n if (solve(grid)) {\n return true;\n } else {\n grid[i][j] = '.';\n }\n }\n }\n\n return false;\n }\n }\n }\n\n return true;\n }\n solve(board)\n return board ;\n };" }, { "path": "37-Sudoku-solver/README.md", "content": "\n

37. Sudoku Solver

Hard

\n

Write a program to solve a Sudoku puzzle by filling the empty cells.\nA sudoku solution must satisfy\nall of the following rules:

\n\n
    \n\t
  1. Each of the digits 1-9 must occur exactly once in each row.
    2. \n\t
  2. Each of the digits 1-9 must occur exactly once in each column.
    3. \n\t
  3. Each of the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid.
    4. \n
\n\n

The '.' character indicates empty cells.

\n
\n

Example 1:

\n\n
Input: board = [[\"5\",\"3\",\".\",\".\",\"7\",\".\",\".\",\".\",\".\"],[\"6\",\".\",\".\",\"1\",\"9\",\"5\",\".\",\".\",\".\"],[\".\",\"9\",\"8\",\".\",\".\",\".\",\".\",\"6\",\".\"],[\"8\",\".\",\".\",\".\",\"6\",\".\",\".\",\".\",\"3\"],[\"4\",\".\",\".\",\"8\",\".\",\"3\",\".\",\".\",\"1\"],[\"7\",\".\",\".\",\".\",\"2\",\".\",\".\",\".\",\"6\"],[\".\",\"6\",\".\",\".\",\".\",\".\",\"2\",\"8\",\".\"],[\".\",\".\",\".\",\"4\",\"1\",\"9\",\".\",\".\",\"5\"],[\".\",\".\",\".\",\".\",\"8\",\".\",\".\",\"7\",\"9\"]]\nOutput: [[\"5\",\"3\",\"4\",\"6\",\"7\",\"8\",\"9\",\"1\",\"2\"],[\"6\",\"7\",\"2\",\"1\",\"9\",\"5\",\"3\",\"4\",\"8\"],[\"1\",\"9\",\"8\",\"3\",\"4\",\"2\",\"5\",\"6\",\"7\"],[\"8\",\"5\",\"9\",\"7\",\"6\",\"1\",\"4\",\"2\",\"3\"],[\"4\",\"2\",\"6\",\"8\",\"5\",\"3\",\"7\",\"9\",\"1\"],[\"7\",\"1\",\"3\",\"9\",\"2\",\"4\",\"8\",\"5\",\"6\"],[\"9\",\"6\",\"1\",\"5\",\"3\",\"7\",\"2\",\"8\",\"4\"],[\"2\",\"8\",\"7\",\"4\",\"1\",\"9\",\"6\",\"3\",\"5\"],[\"3\",\"4\",\"5\",\"2\",\"8\",\"6\",\"1\",\"7\",\"9\"]]\nExplanation: The input board is shown above and the only valid solution is shown below:\n\n\n
\n\n\n

Constraints:

\n
\n
    \n\t
  • board.length == 9
    • \n\t
  • board[i].length == 9
    • \n\t
  • board[i][j] is a digit or '.'.
    • \n\t
  • It is guaranteed that the input board has only one solution.
    • \n
\n\n

Alice wants the rope to be colorful. She does not want two consecutive balloons to be of the same color, so she asks Bob for help. Bob can remove some balloons from the rope to make it colorful. You are given a 0-indexed integer array neededTime where neededTime[i] is the time (in seconds) that Bob needs to remove the ith balloon from the rope.

\n\n

Return the minimum time Bob needs to make the rope colorful.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: colors = \"abaac\", neededTime = [1,2,3,4,5]\nOutput: 3\nExplanation: In the above image, 'a' is blue, 'b' is red, and 'c' is green.\nBob can remove the blue balloon at index 2. This takes 3 seconds.\nThere are no longer two consecutive balloons of the same color. Total time = 3.
\n\n

Example 2:

\n\"\"\n
Input: colors = \"abc\", neededTime = [1,2,3]\nOutput: 0\nExplanation: The rope is already colorful. Bob does not need to remove any balloons from the rope.\n
\n\n

Example 3:

\n\"\"\n
Input: colors = \"aabaa\", neededTime = [1,2,3,4,1]\nOutput: 2\nExplanation: Bob will remove the ballons at indices 0 and 4. Each ballon takes 1 second to remove.\nThere are no longer two consecutive balloons of the same color. Total time = 1 + 1 = 2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == colors.length == neededTime.length
    • \n\t
  • 1 <= n <= 105
    • \n\t
  • 1 <= neededTime[i] <= 104
    • \n\t
  • colors contains only lowercase English letters.
    • \n
\n
" }, { "path": "371-sum-of-two-integers/371-sum-of-two-integers.java", "content": "class Solution {\n public int getSum(int a, int b) {\n while(b!=0){\n int ans=(a^b);\n int carry=(a&b)<<1;\n a=ans;\n b=carry;\n }\n return a;\n }\n}" }, { "path": "371-sum-of-two-integers/NOTES.md", "content": "​" }, { "path": "371-sum-of-two-integers/README.md", "content": "

371. Sum of Two Integers

Medium

Given two integers a and b, return the sum of the two integers without using the operators + and -.

\n\n

 

\n

Example 1:

\n
Input: a = 1, b = 2\nOutput: 3\n

Example 2:

\n
Input: a = 2, b = 3\nOutput: 5\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • -1000 <= a, b <= 1000
    • \n
\n
" }, { "path": "376-wiggle-subsequence/376-wiggle-subsequence.java", "content": "public class Solution {\n public int wiggleMaxLength(int[] nums) {\n if (nums.length < 2)return nums.length;\n int prevdiff = nums[1] - nums[0];\n int count = prevdiff != 0 ? 2 : 1;\n for (int i = 2; i < nums.length; i++) {\n int diff = nums[i] - nums[i - 1];\n if ((diff > 0 && prevdiff <= 0) || (diff < 0 && prevdiff >= 0)) {\n count++;\n prevdiff = diff;\n }\n }\n return count;\n }\n}" }, { "path": "376-wiggle-subsequence/NOTES.md", "content": "​" }, { "path": "376-wiggle-subsequence/README.md", "content": "

376. Wiggle Subsequence

Medium

A wiggle sequence is a sequence where the differences between successive numbers strictly alternate between positive and negative. The first difference (if one exists) may be either positive or negative. A sequence with one element and a sequence with two non-equal elements are trivially wiggle sequences.

\n\n
    \n\t
  • For example, [1, 7, 4, 9, 2, 5] is a wiggle sequence because the differences (6, -3, 5, -7, 3) alternate between positive and negative.
    • \n\t
  • In contrast, [1, 4, 7, 2, 5] and [1, 7, 4, 5, 5] are not wiggle sequences. The first is not because its first two differences are positive, and the second is not because its last difference is zero.
    • \n
\n\n

A subsequence is obtained by deleting some elements (possibly zero) from the original sequence, leaving the remaining elements in their original order.

\n\n

Given an integer array nums, return the length of the longest wiggle subsequence of nums.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,7,4,9,2,5]\nOutput: 6\nExplanation: The entire sequence is a wiggle sequence with differences (6, -3, 5, -7, 3).\n
\n\n

Example 2:

\n\n
Input: nums = [1,17,5,10,13,15,10,5,16,8]\nOutput: 7\nExplanation: There are several subsequences that achieve this length.\nOne is [1, 17, 10, 13, 10, 16, 8] with differences (16, -7, 3, -3, 6, -8).\n
\n\n

Example 3:

\n\n
Input: nums = [1,2,3,4,5,6,7,8,9]\nOutput: 2\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 1000
    • \n\t
  • 0 <= nums[i] <= 1000
    • \n
\n\n

 

\n

Follow up: Could you solve this in O(n) time?

\n
" }, { "path": "377-combination-sum-iv/377-combination-sum-iv.java", "content": "class Solution {\n private int[] dp;\n\n public int combinationSum4(int[] nums, int target) {\n dp = new int[target + 1];\n Arrays.fill(dp, -1);\n dp[0] = 1;\n return helper(nums, target);\n }\n\n private int helper(int[] nums, int target) {\n if (dp[target] != -1) \n return dp[target];\n\n int res = 0;\n for (int num: nums) {\n if (target >= num) {\n res += helper(nums, target - num);\n }\n }\n return dp[target] = res;\n // res;\n }\n}" }, { "path": "377-combination-sum-iv/NOTES.md", "content": "​" }, { "path": "377-combination-sum-iv/README.md", "content": "

377. Combination Sum IV

Medium

Given an array of distinct integers nums and a target integer target, return the number of possible combinations that add up to target.

\n\n

The test cases are generated so that the answer can fit in a 32-bit integer.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3], target = 4\nOutput: 7\nExplanation:\nThe possible combination ways are:\n(1, 1, 1, 1)\n(1, 1, 2)\n(1, 2, 1)\n(1, 3)\n(2, 1, 1)\n(2, 2)\n(3, 1)\nNote that different sequences are counted as different combinations.\n
\n\n

Example 2:

\n\n
Input: nums = [9], target = 3\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 200
    • \n\t
  • 1 <= nums[i] <= 1000
    • \n\t
  • All the elements of nums are unique.
    • \n\t
  • 1 <= target <= 1000
    • \n
\n\n

 

\n

Follow up: What if negative numbers are allowed in the given array? How does it change the problem? What limitation we need to add to the question to allow negative numbers?

\n
" }, { "path": "378-kth-smallest-element-in-a-sorted-matrix/378-kth-smallest-element-in-a-sorted-matrix.java", "content": "class Solution {\n public int kthSmallest(int[][] mat, int k) {\n int[]arr=new int[mat.length*mat[0].length];\n int idx=0;\n for(int i=0;i383. Ransom Note

Easy

Given two strings ransomNote and magazine, return true if ransomNote can be constructed by using the letters from magazine and false otherwise.

\n\n

Each letter in magazine can only be used once in ransomNote.

\n\n

 

\n

Example 1:

\n
Input: ransomNote = \"a\", magazine = \"b\"\nOutput: false\n

Example 2:

\n
Input: ransomNote = \"aa\", magazine = \"ab\"\nOutput: false\n

Example 3:

\n
Input: ransomNote = \"aa\", magazine = \"aab\"\nOutput: true\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= ransomNote.length, magazine.length <= 105
    • \n\t
  • ransomNote and magazine consist of lowercase English letters.
    • \n
\n
" }, { "path": "383-ransom-note/ransom-note.cpp", "content": "class Solution {\npublic:\n bool canConstruct(string ransomNote, string magazine) {\n ios_base::sync_with_stdio(false);\n cin.tie(NULL);\n \n vector magazineHash(26,0); // 26 char, start from 0 , \n// traverse magazing and keep count of each letter in magazineHash\n for(int i =0; magazine[i]!='\\0'; ++i){\n magazineHash[magazine[i]-'a'] +=1;\n \n }\n// now traverse ransomNote and keep decrementing count in magazineHash\n for(int i =0; ransomNote[i]!='\\0'; ++i){\n if(magazineHash[ransomNote[i]-'a'] == 0) return false;\n magazineHash[ransomNote[i]-'a'] -=1; // using up char to lead decrement it by value 1 \n \n }\n return true;\n// TC:O(N+M) -> where n is the length of the magazing and M is length of randomString\n \n }\n};" }, { "path": "383-ransom-note/ransome-note-two-approaches.cpp", "content": "class Solution {\npublic:\n bool canConstruct(string rn, string mag) {\n if(mag.size() < rn.size()) return false;\n \n // 1.\n// unordered_map m1, m2;\n// for(int i=0;i m2[rn[i]]){\n// return false;\n// }\n// }\n \n \n // 2.\n vector arr(26, 0);\n for(int i=0;i387. First Unique Character in a String

Easy

Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1.

\n\n

 

\n

Example 1:

\n
Input: s = \"leetcode\"\nOutput: 0\n

Example 2:

\n
Input: s = \"loveleetcode\"\nOutput: 2\n

Example 3:

\n
Input: s = \"aabb\"\nOutput: -1\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 105
    • \n\t
  • s consists of only lowercase English letters.
    • \n
\n
" }, { "path": "387-first-unique-character-in-a-string/first-unique-character-in-a-string.CPP", "content": " int firstUniqChar(string s) {\n unordered_mapmp;\n \n for(int i=0;i255) return false; // 1 after 8th digit, 100000000\n\t\tint numberOfBytes = 0;\n\t\tif((data[i] & 128) == 0) { // 0xxxxxxx, 1 byte, 128(10000000)\n\t\t\tnumberOfBytes = 1;\n\t\t} else if((data[i] & 224) == 192) { // 110xxxxx, 2 bytes, 224(11100000), 192(11000000)\n\t\t\tnumberOfBytes = 2;\n\t\t} else if((data[i] & 240) == 224) { // 1110xxxx, 3 bytes, 240(11110000), 224(11100000)\n\t\t\tnumberOfBytes = 3;\n\t\t} else if((data[i] & 248) == 240) { // 11110xxx, 4 bytes, 248(11111000), 240(11110000)\n\t\t\tnumberOfBytes = 4;\n\t\t} else {\n\t\t\treturn false;\n\t\t}\n\t\tfor(int j=1;j=data.length) return false;\n\t\t\tif((data[i+j] & 192) != 128) return false; // 192(11000000), 128(10000000)\n\t\t}\n\t\ti=i+numberOfBytes-1;\n\t}\n\treturn isValid;\n }\n}\n\n\n//Approach 2\n\n\nclass Solution {\n public boolean validUtf8(int[] data) {\n int f[]=new int[256];\n for(int i=0;i<256;i++) { // storing All sequences in in array having data[i] as index. As 0<=data[i]<=255, stored in f array\n int count=0;\n for(int j=7;j>=0;j--) {\n if((i&(1<0) {\n count+=1;\n }\n else {\n break;\n }\n }\n \n if(count<=4) f[i]=count; // if starting 1's count <=4 storing in f array\n else f[i]=-1; //if starting 1's count>=5, it is not part of any utf-8 sequence making as -1\n }\n \n int bytes=-1;\n int sequence=-1;\n for(int i=0;i00000000 then sequence becomes -1\n bytes=f[data[i]];\n if(bytes==1 && (data[i]&(1<<7))>0) {\n return false;\n }\n sequence=bytes-1;\n continue;\n } \n \n if(setBits==1) { // After having starting , remaining sequence should contain only 1's\n sequence-=1;\n }\n else { // otherwise returning false\n return false;\n }\n }\n \n if(sequence==0 || sequence == -1) { //At end sequence should be either 0 or -1 which means sequence completed for 0/1/2/3. for 0->sequence becomes -1, for 1,2,3->sequence becomes 0\n return true;\n }\n return false;\n }\n}\n" }, { "path": "393-utf-8-validation/NOTES.md", "content": "​" }, { "path": "393-utf-8-validation/README.md", "content": "

393. UTF-8 Validation

Medium

Given an integer array data representing the data, return whether it is a valid UTF-8 encoding (i.e. it translates to a sequence of valid UTF-8 encoded characters).

\n\n

A character in UTF8 can be from 1 to 4 bytes long, subjected to the following rules:

\n\n
    \n\t
  1. For a 1-byte character, the first bit is a 0, followed by its Unicode code.
    2. \n\t
  2. For an n-bytes character, the first n bits are all one's, the n + 1 bit is 0, followed by n - 1 bytes with the most significant 2 bits being 10.
    3. \n
\n\n

This is how the UTF-8 encoding would work:

\n\n
     Number of Bytes   |        UTF-8 Octet Sequence\n                       |              (binary)\n   --------------------+-----------------------------------------\n            1          |   0xxxxxxx\n            2          |   110xxxxx 10xxxxxx\n            3          |   1110xxxx 10xxxxxx 10xxxxxx\n            4          |   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx\n
\n\n

x denotes a bit in the binary form of a byte that may be either 0 or 1.

\n\n

Note: The input is an array of integers. Only the least significant 8 bits of each integer is used to store the data. This means each integer represents only 1 byte of data.

\n\n

 

\n

Example 1:

\n\n
Input: data = [197,130,1]\nOutput: true\nExplanation: data represents the octet sequence: 11000101 10000010 00000001.\nIt is a valid utf-8 encoding for a 2-bytes character followed by a 1-byte character.\n
\n\n

Example 2:

\n\n
Input: data = [235,140,4]\nOutput: false\nExplanation: data represented the octet sequence: 11101011 10001100 00000100.\nThe first 3 bits are all one's and the 4th bit is 0 means it is a 3-bytes character.\nThe next byte is a continuation byte which starts with 10 and that's correct.\nBut the second continuation byte does not start with 10, so it is invalid.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= data.length <= 2 * 104
    • \n\t
  • 0 <= data[i] <= 255
    • \n
\n
" }, { "path": "399-evaluate-division/399-evaluate-division.java", "content": "class Solution {\n class Node{\n String key;\n double val;\n Node(String k,double v){\n key=k;\n val=v;\n }\n }\n public double[] calcEquation(List> equations, double[] values, List> queries) {\n Map>g=buildGraph(equations,values);\n double[]res=new double[queries.size()];\n for(int i=0;i(),g);\n }\n return res;\n }\n private double dfs(String s,String d,Set vis,Map> g){\n if(!(g.containsKey(s) && g.containsKey(d)))return -1.0;\n if(s.equals(d))return 1.0;\n vis.add(s);\n for(Node n:g.get(s)){\n if(!vis.contains(n.key)){\n double ans=dfs(n.key,d,vis,g);\n if(ans!=-1.0)return ans*n.val;\n }\n }\n return -1.0;\n }\n private Map> buildGraph(List> eq,double[] vals){\n Map> g=new HashMap<>();\n for(int i=0;i());\n g.putIfAbsent(des,new ArrayList<>());\n g.get(src).add(new Node(des,vals[i]));\n g.get(des).add(new Node(src,1/vals[i]));\n }\n return g;\n }\n}" }, { "path": "399-evaluate-division/NOTES.md", "content": "​" }, { "path": "399-evaluate-division/README.md", "content": "

399. Evaluate Division

Medium

You are given an array of variable pairs equations and an array of real numbers values, where equations[i] = [Ai, Bi] and values[i] represent the equation Ai / Bi = values[i]. Each Ai or Bi is a string that represents a single variable.

\n\n

You are also given some queries, where queries[j] = [Cj, Dj] represents the jth query where you must find the answer for Cj / Dj = ?.

\n\n

Return the answers to all queries. If a single answer cannot be determined, return -1.0.

\n\n

Note: The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.

\n\n

 

\n

Example 1:

\n\n
Input: equations = [[\"a\",\"b\"],[\"b\",\"c\"]], values = [2.0,3.0], queries = [[\"a\",\"c\"],[\"b\",\"a\"],[\"a\",\"e\"],[\"a\",\"a\"],[\"x\",\"x\"]]\nOutput: [6.00000,0.50000,-1.00000,1.00000,-1.00000]\nExplanation: \nGiven: a / b = 2.0, b / c = 3.0\nqueries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?\nreturn: [6.0, 0.5, -1.0, 1.0, -1.0 ]\n
\n\n

Example 2:

\n\n
Input: equations = [[\"a\",\"b\"],[\"b\",\"c\"],[\"bc\",\"cd\"]], values = [1.5,2.5,5.0], queries = [[\"a\",\"c\"],[\"c\",\"b\"],[\"bc\",\"cd\"],[\"cd\",\"bc\"]]\nOutput: [3.75000,0.40000,5.00000,0.20000]\n
\n\n

Example 3:

\n\n
Input: equations = [[\"a\",\"b\"]], values = [0.5], queries = [[\"a\",\"b\"],[\"b\",\"a\"],[\"a\",\"c\"],[\"x\",\"y\"]]\nOutput: [0.50000,2.00000,-1.00000,-1.00000]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= equations.length <= 20
    • \n\t
  • equations[i].length == 2
    • \n\t
  • 1 <= Ai.length, Bi.length <= 5
    • \n\t
  • values.length == equations.length
    • \n\t
  • 0.0 < values[i] <= 20.0
    • \n\t
  • 1 <= queries.length <= 20
    • \n\t
  • queries[i].length == 2
    • \n\t
  • 1 <= Cj.length, Dj.length <= 5
    • \n\t
  • Ai, Bi, Cj, Dj consist of lower case English letters and digits.
    • \n
\n
" }, { "path": "4-median-of-two-sorted-arrays/4-median-of-two-sorted-arrays.java", "content": "class Solution {\n public double findMedianSortedArrays(int[] nums1, int[] nums2) {\n int[] nums = new int[nums1.length + nums2.length];\n System.arraycopy(nums1, 0, nums, 0, nums1.length);\n System.arraycopy(nums2, 0, nums, nums1.length, nums2.length); \n Arrays.sort(nums);\n return (nums[nums.length >> 1] + nums[(nums.length - 1) >> 1]) / 2.0;\n }\n}" }, { "path": "4-median-of-two-sorted-arrays/NOTES.md", "content": "​" }, { "path": "406-queue-reconstruction-by-height/406-queue-reconstruction-by-height.java", "content": "class Solution {\n public int[][] reconstructQueue(int[][] people) {\n Arrays.sort(people, (o1, o2) -> o1[0] != o2[0] ? o2[0] - o1[0] : o1[1] - o2[1]);\n List tempRes = new LinkedList<>();\n for (int[] person : people) {\n tempRes.add(person[1], person);\n }\n return tempRes.toArray(new int[people.length][]);\n }\n}" }, { "path": "406-queue-reconstruction-by-height/NOTES.md", "content": "​" }, { "path": "406-queue-reconstruction-by-height/README.md", "content": "

406. Queue Reconstruction by Height

Medium

You are given an array of people, people, which are the attributes of some people in a queue (not necessarily in order). Each people[i] = [hi, ki] represents the ith person of height hi with exactly ki other people in front who have a height greater than or equal to hi.

\n\n

Reconstruct and return the queue that is represented by the input array people. The returned queue should be formatted as an array queue, where queue[j] = [hj, kj] is the attributes of the jth person in the queue (queue[0] is the person at the front of the queue).

\n\n

 

\n

Example 1:

\n\n
Input: people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]\nOutput: [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]\nExplanation:\nPerson 0 has height 5 with no other people taller or the same height in front.\nPerson 1 has height 7 with no other people taller or the same height in front.\nPerson 2 has height 5 with two persons taller or the same height in front, which is person 0 and 1.\nPerson 3 has height 6 with one person taller or the same height in front, which is person 1.\nPerson 4 has height 4 with four people taller or the same height in front, which are people 0, 1, 2, and 3.\nPerson 5 has height 7 with one person taller or the same height in front, which is person 1.\nHence [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] is the reconstructed queue.\n
\n\n

Example 2:

\n\n
Input: people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]\nOutput: [[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= people.length <= 2000
    • \n\t
  • 0 <= hi <= 106
    • \n\t
  • 0 <= ki < people.length
    • \n\t
  • It is guaranteed that the queue can be reconstructed.
    • \n
\n
" }, { "path": "410-split-array-largest-sum/410-split-array-largest-sum.java", "content": "class Solution {\n public int splitArray(int[] nums, int m) {\n int max = Integer.MIN_VALUE;\n int sum = 0;\n // search range [max, sum];\n for (int i = 0; i < nums.length; i++) {\n max = Math.max(max, nums[i]);\n sum += nums[i];\n }\n int left = max;\n int right = sum;\n while (left < right) {\n int mid = left + (right - left) / 2;\n if (canSplit(nums, m, mid)) {\n right = mid;\n } else {\n left = mid + 1;\n }\n }\n // if (canSplit(nums, m, right)) return right;\n return left;\n }\n private boolean canSplit(int[] nums, int m, int largest) {\n int count = 1;\n int sum = 0;\n for (int i = 0; i < nums.length; i++) {\n sum += nums[i];\n if (sum > largest) {\n count++;\n sum = nums[i];\n }\n }\n return count <= m;\n }\n}" }, { "path": "410-split-array-largest-sum/NOTES.md", "content": "​" }, { "path": "410-split-array-largest-sum/README.md", "content": "

410. Split Array Largest Sum

Hard

Given an array nums which consists of non-negative integers and an integer m, you can split the array into m non-empty continuous subarrays.

\n\n

Write an algorithm to minimize the largest sum among these m subarrays.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [7,2,5,10,8], m = 2\nOutput: 18\nExplanation:\nThere are four ways to split nums into two subarrays.\nThe best way is to split it into [7,2,5] and [10,8],\nwhere the largest sum among the two subarrays is only 18.\n
\n\n

Example 2:

\n\n
Input: nums = [1,2,3,4,5], m = 2\nOutput: 9\n
\n\n

Example 3:

\n\n
Input: nums = [1,4,4], m = 3\nOutput: 4\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 1000
    • \n\t
  • 0 <= nums[i] <= 106
    • \n\t
  • 1 <= m <= min(50, nums.length)
    • \n
\n
" }, { "path": "417-pacific-atlantic-water-flow/417-pacific-atlantic-water-flow.java", "content": "class Solution {\n public List> pacificAtlantic(int[][] heights) {\n int rows = heights.length, cols = heights[0].length;\n boolean[][] pac = new boolean[rows][cols];\n boolean[][] atl = new boolean[rows][cols];\n \n for (int col = 0; col< cols; col++){\n dfs(0, col, rows, cols, pac, heights[0][col], heights);\n dfs(rows-1, col,rows, cols, atl, heights[rows-1][col], heights);\n }\n for (int row = 0; row> result = new ArrayList>();\n for (int i = 0; i < rows; i++)\n for (int j = 0; j < cols; j++){\n if (pac[i][j] && atl[i][j])\n result.add(Arrays.asList(i,j));\n }\n return result;\n }\n private void dfs(int row, int col, int rows, int cols, boolean[][] visited, int prevHeight, int[][] heights){\n if (row < 0 || row >= rows || col < 0 || col >= cols || visited[row][col] || prevHeight > heights[row][col])\n return;\n visited[row][col]= true;\n dfs(row+1, col, rows, cols, visited, heights[row][col], heights);\n dfs(row-1, col, rows, cols, visited, heights[row][col], heights);\n dfs(row, col+1, rows, cols, visited, heights[row][col], heights);\n dfs(row, col-1, rows, cols, visited, heights[row][col], heights);\n \n }\n}" }, { "path": "417-pacific-atlantic-water-flow/NOTES.md", "content": "​" }, { "path": "417-pacific-atlantic-water-flow/README.md", "content": "

417. Pacific Atlantic Water Flow

Medium

There is an m x n rectangular island that borders both the Pacific Ocean and Atlantic Ocean. The Pacific Ocean touches the island's left and top edges, and the Atlantic Ocean touches the island's right and bottom edges.

\n\n

The island is partitioned into a grid of square cells. You are given an m x n integer matrix heights where heights[r][c] represents the height above sea level of the cell at coordinate (r, c).

\n\n

The island receives a lot of rain, and the rain water can flow to neighboring cells directly north, south, east, and west if the neighboring cell's height is less than or equal to the current cell's height. Water can flow from any cell adjacent to an ocean into the ocean.

\n\n

Return a 2D list of grid coordinates result where result[i] = [ri, ci] denotes that rain water can flow from cell (ri, ci) to both the Pacific and Atlantic oceans.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: heights = [[1,2,2,3,5],[3,2,3,4,4],[2,4,5,3,1],[6,7,1,4,5],[5,1,1,2,4]]\nOutput: [[0,4],[1,3],[1,4],[2,2],[3,0],[3,1],[4,0]]\nExplanation: The following cells can flow to the Pacific and Atlantic oceans, as shown below:\n[0,4]: [0,4] -> Pacific Ocean \n       [0,4] -> Atlantic Ocean\n[1,3]: [1,3] -> [0,3] -> Pacific Ocean \n       [1,3] -> [1,4] -> Atlantic Ocean\n[1,4]: [1,4] -> [1,3] -> [0,3] -> Pacific Ocean \n       [1,4] -> Atlantic Ocean\n[2,2]: [2,2] -> [1,2] -> [0,2] -> Pacific Ocean \n       [2,2] -> [2,3] -> [2,4] -> Atlantic Ocean\n[3,0]: [3,0] -> Pacific Ocean \n       [3,0] -> [4,0] -> Atlantic Ocean\n[3,1]: [3,1] -> [3,0] -> Pacific Ocean \n       [3,1] -> [4,1] -> Atlantic Ocean\n[4,0]: [4,0] -> Pacific Ocean \n       [4,0] -> Atlantic Ocean\nNote that there are other possible paths for these cells to flow to the Pacific and Atlantic oceans.\n
\n\n

Example 2:

\n\n
Input: heights = [[1]]\nOutput: [[0,0]]\nExplanation: The water can flow from the only cell to the Pacific and Atlantic oceans.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == heights.length
    • \n\t
  • n == heights[r].length
    • \n\t
  • 1 <= m, n <= 200
    • \n\t
  • 0 <= heights[r][c] <= 105
    • \n
\n
" }, { "path": "417_Pacific Atlantic Water Flow.cpp", "content": "#include\nusing namespace std;\nclass Solution{\n public:\n\n // using dfs \n int m, n;\n // this denotes cells reachable starting from atlantic and pacific edged cells resp\n vector > atlantic, pacific;\n\tvector > res; \n vector > pacificAtlantic(vector>& heights) {\n if(!size(heights)) return res; // check for null condition\n m = size(heights), n = size(heights[0]); // initializing row and col\n\n // taking bolean matrices(vector), to see whether a cell that can reach the atalantic of pacific\n atlantic = pacific = vector >(m, vector(n, false));\n\t\t// perform dfs from all edge cells (ocean-connected cells)\n for(int i = 0; i < m; i++) dfs(heights, pacific, i, 0), dfs(heights, atlantic, i, n - 1);\n for(int i = 0; i < n; i++) dfs(heights, pacific, 0, i), dfs(heights, atlantic, m - 1, i); \n return res;\n }\n // define dfs\n void dfs(vector >& mat, vector >& visited, int i, int j){ \n if(visited[i][j]) return;\n visited[i][j] = true;\n\t\t// if cell reachable from both the oceans, insert into final result vector\n if(atlantic[i][j] && pacific[i][j]) res.push_back(vector{i, j}); \n\t\t// dfs from current cell only if height of next cell is greater\n/*down dir*/ if(i + 1 < m && mat[i + 1][j] >= mat[i][j]) dfs(mat, visited, i + 1, j); \n/*Up dir*/ if(i - 1 >= 0 && mat[i - 1][j] >= mat[i][j]) dfs(mat, visited, i - 1, j);\n/*right dir*/ if(j + 1 < n && mat[i][j + 1] >= mat[i][j]) dfs(mat, visited, i, j + 1); \n/*left dir*/ if(j - 1 >= 0 && mat[i][j - 1] >= mat[i][j]) dfs(mat, visited, i, j - 1);\n }\n};\nint main(){\n\n}" }, { "path": "42 Trapping Rain Water hd s18.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n int trap(vector& height) {\n// using 2 pointers tech\n int i =0, j = height.size()-1, res =0, maxi =0, mini =0;\n \n// pointer i from left and j from right\n while(i <=j){\n// take mini ht\n mini = min(height[i], height[j]);\n// find max, min ht\n maxi = max(maxi, mini);\n \n// unit of water being tapped is diff betn max_ht & min_ht\n res += maxi - mini;\n// move pointer i if ht[i] is smaller\n if(height[i] < height[j]) i++;\n// else move ptr j\n else j--;\n }\n return res;\n// TC: O(N), SC:O(1)\n }\n};" }, { "path": "42-trapping-rain-water/42-trapping-rain-water.java", "content": "class Solution {\n public int trap(int[] h) {\n int n=h.length;\n int[] left=new int[n];\n int[]right=new int[n];\n \n left[0]=h[0];\n for(int i=1;i=0;i--){\n right[i]=Math.max(right[i+1],h[i]);\n }\n \n int ans=0;\n for(int i=0;i42. Trapping Rain Water

Hard

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.

\n\n

 

\n

Example 1:

\n\n
Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]\nOutput: 6\nExplanation: The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.\n
\n\n

Example 2:

\n\n
Input: height = [4,2,0,3,2,5]\nOutput: 9\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == height.length
    • \n\t
  • 1 <= n <= 2 * 104
    • \n\t
  • 0 <= height[i] <= 105
    • \n
\n
" }, { "path": "429-n-ary-tree-level-order-traversal/429-n-ary-tree-level-order-traversal.cpp", "content": "class Solution {\npublic:\n vector> levelOrder(Node* root) {\n if(!root) return {};\n vector> ans;\n queue q;\n q.push(root);\n while(!q.empty()){\n int n = q.size();\n vector v;\n for(int i=0;ival);\n for(Node* child : node->children) q.push(child);\n }\n ans.push_back(v);\n }\n return ans;\n }\n};\n" }, { "path": "429-n-ary-tree-level-order-traversal/429-n-ary-tree-level-order-traversal.java", "content": "/*\n// Definition for a Node.\nclass Node {\n public int val;\n public List children;\n\n public Node() {}\n\n public Node(int _val) {\n val = _val;\n }\n\n public Node(int _val, List _children) {\n val = _val;\n children = _children;\n }\n};\n*/\n\nclass Solution {\n public List> levelOrder(Node root) {\n List> list=new ArrayList<>();\n if(root==null)return list;\n Queue q=new LinkedList<>();\n q.add(root);\n while(!q.isEmpty()){\n int size=q.size();\n List l=new ArrayList<>();\n for(int i=0;i> levelOrder(Node root) {\n\n List> outter=new ArrayList<>();\n\n if(root==null)\n return outter;\n\n Deque q=new LinkedList<>();\n\n q.add(root);\n List inner=new ArrayList<>();\n inner.add(root.val);\n outter.add(inner);\n\n while(q.size()>0){\n //R P A\n int len=q.size();\n inner=new ArrayList<>();\n\n for(int i=0;i child=curr.children;\n\n if(child.size()==0)\n continue;\n\n int run=child.size();\n\n for(int j=0;j0)\n outter.add(inner);\n }\n\n return outter;\n }\n}\n" }, { "path": "429-n-ary-tree-level-order-traversal/NOTES.md", "content": "​" }, { "path": "429-n-ary-tree-level-order-traversal/README.md", "content": "

429. N-ary Tree Level Order Traversal

Medium

Given an n-ary tree, return the level order traversal of its nodes' values.

\n\n

Nary-Tree input serialization is represented in their level order traversal, each group of children is separated by the null value (See examples).

\n\n

 

\n

Example 1:

\n\n

\n\n
Input: root = [1,null,3,2,4,null,5,6]\nOutput: [[1],[3,2,4],[5,6]]\n
\n\n

Example 2:

\n\n

\"\"

\n\n
Input: root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]\nOutput: [[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The height of the n-ary tree is less than or equal to 1000
    • \n\t
  • The total number of nodes is between [0, 104]
    • \n
\n
" }, { "path": "456-132-pattern/456-132-pattern.java", "content": "class Solution {\n public boolean find132pattern(int[] nums) {\n int len = nums.length;\n if (len < 3)return false;\n Deque stk = new ArrayDeque<>();\n int k = -1;\n for (int i = len - 1; i >= 0; i--) {\n if (k > -1 && nums[k] > nums[i]) {\n return true;\n }\n\n while (!stk.isEmpty() && nums[i] > nums[stk.peek()]) {\n k = stk.pop();\n }\n\n stk.push(i);\n }\n return false;\n }\n}" }, { "path": "456-132-pattern/NOTES.md", "content": "​" }, { "path": "456-132-pattern/README.md", "content": "

456. 132 Pattern

Medium

Given an array of n integers nums, a 132 pattern is a subsequence of three integers nums[i], nums[j] and nums[k] such that i < j < k and nums[i] < nums[k] < nums[j].

\n\n

Return true if there is a 132 pattern in nums, otherwise, return false.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3,4]\nOutput: false\nExplanation: There is no 132 pattern in the sequence.\n
\n\n

Example 2:

\n\n
Input: nums = [3,1,4,2]\nOutput: true\nExplanation: There is a 132 pattern in the sequence: [1, 4, 2].\n
\n\n

Example 3:

\n\n
Input: nums = [-1,3,2,0]\nOutput: true\nExplanation: There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == nums.length
    • \n\t
  • 1 <= n <= 2 * 105
    • \n\t
  • -109 <= nums[i] <= 109
    • \n
\n
" }, { "path": "458-poor-pigs/458-poor-pigs.java", "content": "class Solution {\n public int poorPigs(int buckets, int minutesToDie, int minutesToTest) {\n int rounds=(minutesToTest/minutesToDie)+1;\n return (int)Math.ceil(Math.log(buckets)/Math.log(rounds));\n }\n}" }, { "path": "458-poor-pigs/NOTES.md", "content": "​" }, { "path": "458-poor-pigs/README.md", "content": "

458. Poor Pigs

Hard

There are buckets buckets of liquid, where exactly one of the buckets is poisonous. To figure out which one is poisonous, you feed some number of (poor) pigs the liquid to see whether they will die or not. Unfortunately, you only have minutesToTest minutes to determine which bucket is poisonous.

\n\n

You can feed the pigs according to these steps:

\n\n
    \n\t
  1. Choose some live pigs to feed.
    2. \n\t
  2. For each pig, choose which buckets to feed it. The pig will consume all the chosen buckets simultaneously and will take no time.
    3. \n\t
  3. Wait for minutesToDie minutes. You may not feed any other pigs during this time.
    4. \n\t
  4. After minutesToDie minutes have passed, any pigs that have been fed the poisonous bucket will die, and all others will survive.
    5. \n\t
  5. Repeat this process until you run out of time.
    6. \n
\n\n

Given buckets, minutesToDie, and minutesToTest, return the minimum number of pigs needed to figure out which bucket is poisonous within the allotted time.

\n\n

 

\n

Example 1:

\n
Input: buckets = 1000, minutesToDie = 15, minutesToTest = 60\nOutput: 5\n

Example 2:

\n
Input: buckets = 4, minutesToDie = 15, minutesToTest = 15\nOutput: 2\n

Example 3:

\n
Input: buckets = 4, minutesToDie = 15, minutesToTest = 30\nOutput: 2\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= buckets <= 1000
    • \n\t
  • 1 <= minutesToDie <= minutesToTest <= 100
    • \n
\n
" }, { "path": "462-minimum-moves-to-equal-array-elements-ii/462-minimum-moves-to-equal-array-elements-ii.java", "content": "class Solution {\n public int minMoves2(int[] nums) {\n Arrays.sort(nums);\n int i=0;\n int j=nums.length-1;\n int staps=0;\n while(i462. Minimum Moves to Equal Array Elements II

Medium

Given an integer array nums of size n, return the minimum number of moves required to make all array elements equal.

\n\n

In one move, you can increment or decrement an element of the array by 1.

\n\n

Test cases are designed so that the answer will fit in a 32-bit integer.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3]\nOutput: 2\nExplanation:\nOnly two moves are needed (remember each move increments or decrements one element):\n[1,2,3]  =>  [2,2,3]  =>  [2,2,2]\n
\n\n

Example 2:

\n\n
Input: nums = [1,10,2,9]\nOutput: 16\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == nums.length
    • \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • -109 <= nums[i] <= 109
    • \n
\n
" }, { "path": "47-permutations-ii/47-permutations-ii.java", "content": "class Solution {\n \n List> lists;\n boolean[] added;\n \n public List> permuteUnique(int[] nums) {\n lists = new ArrayList<>();\n Arrays.sort(nums);\n added = new boolean[nums.length];\n permuteUnique(nums, new ArrayList<>());\n return lists;\n }\n \n private void permuteUnique(int[] nums, List list) {\n if(list.size() == nums.length) {\n lists.add(new ArrayList(list));\n return;\n }\n for(int i = 0; i < nums.length; i++) {\n if(added[i])\n continue;\n // avoid permute duplicates\n if(i > 0 && nums[i] == nums[i - 1] && !added[i - 1])\n continue;\n list.add(nums[i]);\n added[i] = true;\n permuteUnique(nums, list);\n list.remove(list.size() - 1);\n added[i] = false;\n }\n }\n}" }, { "path": "47-permutations-ii/NOTES.md", "content": "​" }, { "path": "47-permutations-ii/README.md", "content": "

47. Permutations II

Medium

Given a collection of numbers, nums, that might contain duplicates, return all possible unique permutations in any order.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,1,2]\nOutput:\n[[1,1,2],\n [1,2,1],\n [2,1,1]]\n
\n\n

Example 2:

\n\n
Input: nums = [1,2,3]\nOutput: [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 8
    • \n\t
  • -10 <= nums[i] <= 10
    • \n
\n
" }, { "path": "473-matchsticks-to-square/473-matchsticks-to-square.java", "content": "import java.util.HashMap;\n\nclass Solution {\n\n // The memoization cache to be used during recursion.\n public HashMap, Boolean> memo;\n\n // Array containing our matchsticks.\n public int[] nums;\n\n // Possible side of our square depending on the total sum of all the matchsticks. \n public int possibleSquareSide;\n\n // Default constructor to initialise our memo cache.\n public Solution() {\n this.memo = new HashMap, Boolean>();\n }\n\n // Main DP function.\n public boolean recurse(Integer mask, Integer sidesDone) {\n int total = 0;\n int L = this.nums.length;\n\n // The memo key for this recursion\n Pair memoKey = new Pair(mask, sidesDone);\n\n // Find out the sum of matchsticks used till now.\n for(int i = L - 1; i >= 0; i--) {\n if ((mask&(1 << i)) == 0) {\n total += this.nums[L - 1 - i];\n }\n }\n\n // If the sum if divisible by our square's side, then we increment our number of complete sides formed variable.\n if (total > 0 && total % this.possibleSquareSide == 0) {\n sidesDone++;\n }\n\n // Base case.\n if (sidesDone == 3) {\n return true;\n }\n\n\n // Return precomputed results\n if (this.memo.containsKey(memoKey)) {\n return this.memo.get(memoKey);\n }\n\n boolean ans = false;\n int c = total / this.possibleSquareSide;\n\n // Remaining vlength in the current partially formed side.\n int rem = this.possibleSquareSide * (c + 1) - total;\n\n // Try out all remaining options (that are valid)\n for(int i = L - 1; i >= 0; i--) {\n if (this.nums[L - 1 - i] <= rem && (mask&(1 << i)) > 0) {\n if (this.recurse(mask ^ (1 << i), sidesDone)) {\n ans = true;\n break;\n }\n }\n }\n\n // Cache the computed results.\n this.memo.put(memoKey, ans);\n return ans;\n }\n\n public boolean makesquare(int[] nums) {\n\n // Empty matchsticks.\n if (nums == null || nums.length == 0) {\n return false;\n }\n\n // Find the perimeter of the square (if at all possible)\n int L = nums.length;\n int perimeter = 0;\n for(int i = 0; i < L; i++) {\n perimeter += nums[i];\n }\n\n int possibleSquareSide = perimeter / 4;\n if (possibleSquareSide * 4 != perimeter) {\n return false;\n }\n\n this.nums = nums;\n this.possibleSquareSide = possibleSquareSide;\n return this.recurse((1 << L) - 1, 0);\n }\n}" }, { "path": "473-matchsticks-to-square/NOTES.md", "content": "​" }, { "path": "473-matchsticks-to-square/README.md", "content": "

473. Matchsticks to Square

Medium

You are given an integer array matchsticks where matchsticks[i] is the length of the ith matchstick. You want to use all the matchsticks to make one square. You should not break any stick, but you can link them up, and each matchstick must be used exactly one time.

\n\n

Return true if you can make this square and false otherwise.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: matchsticks = [1,1,2,2,2]\nOutput: true\nExplanation: You can form a square with length 2, one side of the square came two sticks with length 1.\n
\n\n

Example 2:

\n\n
Input: matchsticks = [3,3,3,3,4]\nOutput: false\nExplanation: You cannot find a way to form a square with all the matchsticks.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= matchsticks.length <= 15
    • \n\t
  • 1 <= matchsticks[i] <= 108
    • \n
\n
" }, { "path": "474-ones-and-zeroes/474-ones-and-zeroes.java", "content": "class Solution {\n public static int findMaxForm(String[] strs, int m, int n) {\n int[][] dp = new int[m + 1][n + 1];\n for(String str : strs){\n int one = 0;\n int zero = 0;\n for(char c : str.toCharArray()){\n if(c == '1')\n one++;\n else\n zero++;\n }\n for(int i = m; i >= zero; i--){\n for(int j = n; j >= one; j--){\n if(one <= j && zero <= i)\n dp[i][j] = Math.max(dp[i][j],dp[i - zero][j - one] + 1);\n }\n }\n }\n return dp[m][n];\n }\n}" }, { "path": "474-ones-and-zeroes/NOTES.md", "content": "​" }, { "path": "474-ones-and-zeroes/README.md", "content": "

474. Ones and Zeroes

Medium

You are given an array of binary strings strs and two integers m and n.

\n\n

Return the size of the largest subset of strs such that there are at most m 0's and n 1's in the subset.

\n\n

A set x is a subset of a set y if all elements of x are also elements of y.

\n\n

 

\n

Example 1:

\n\n
Input: strs = [\"10\",\"0001\",\"111001\",\"1\",\"0\"], m = 5, n = 3\nOutput: 4\nExplanation: The largest subset with at most 5 0's and 3 1's is {\"10\", \"0001\", \"1\", \"0\"}, so the answer is 4.\nOther valid but smaller subsets include {\"0001\", \"1\"} and {\"10\", \"1\", \"0\"}.\n{\"111001\"} is an invalid subset because it contains 4 1's, greater than the maximum of 3.\n
\n\n

Example 2:

\n\n
Input: strs = [\"10\",\"0\",\"1\"], m = 1, n = 1\nOutput: 2\nExplanation: The largest subset is {\"0\", \"1\"}, so the answer is 2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= strs.length <= 600
    • \n\t
  • 1 <= strs[i].length <= 100
    • \n\t
  • strs[i] consists only of digits '0' and '1'.
    • \n\t
  • 1 <= m, n <= 100
    • \n
\n
" }, { "path": "48-rotate-image/48-Rotate-Image.cpp", "content": "class Solution {\npublic:\n void rotate(vector>& mat) {\n int n = mat.size();\n int m = mat[0].size();\n for(int i=0;i48. Rotate Image

Medium

You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).

\n\n

You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]\nOutput: [[7,4,1],[8,5,2],[9,6,3]]\n
\n\n

Example 2:

\n\"\"\n
Input: matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]\nOutput: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == matrix.length == matrix[i].length
    • \n\t
  • 1 <= n <= 20
    • \n\t
  • -1000 <= matrix[i][j] <= 1000
    • \n
\n
" }, { "path": "5-longest-palindromic-substring/5-longest-palindromic-substring.java", "content": "class Solution {\n public String longestPalindrome(String s) {\n int n = s.length();\n boolean dp[][] = new boolean[n][n];\n int start = 0,end = 0;\n \n for(int gap = 0;gap < n;gap++){\n for(int i = 0,j = gap;i< n && j < n;i++,j++){\n if(gap == 0){\n dp[i][j] = true;\n }else if(gap == 1){\n if(s.charAt(i) == s.charAt(j)){\n dp[i][j] = true;\n }else{\n dp[i][j] = false;\n }\n }else{\n if(s.charAt(i) == s.charAt(j) && dp[i+1][j-1] == true){\n dp[i][j] = true;\n }else{\n dp[i][j] = false;\n }\n }\n if(dp[i][j] == true){\n if(j-i > end - start){\n start = i;\n end = j;\n }\n }\n }\n }\n\t\t\n return s.substring(start,end + 1);\n }\n}" }, { "path": "5-longest-palindromic-substring/NOTES.md", "content": "​" }, { "path": "5-longest-palindromic-substring/README.md", "content": "

5. Longest Palindromic Substring

Medium

Given a string s, return the longest palindromic substring in s.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"babad\"\nOutput: \"bab\"\nExplanation: \"aba\" is also a valid answer.\n
\n\n

Example 2:

\n\n
Input: s = \"cbbd\"\nOutput: \"bb\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 1000
    • \n\t
  • s consist of only digits and English letters.
    • \n
\n
" }, { "path": "50-powx-n/50-powx-n.java", "content": "class Solution {\n public double myPow(double x, int n) {\n if(n == 0) return (double)1;\n if(n < 0){\n return 1 / x * myPow(1 / x , -(n + 1));\n }\n return (n % 2 == 0 ? myPow(x * x , n / 2) : x * myPow(x * x , n / 2));\n }\n}" }, { "path": "50-powx-n/NOTES.md", "content": "​" }, { "path": "50-powx-n/README.md", "content": "

50. Pow(x, n)

Medium

Implement pow(x, n), which calculates x raised to the power n (i.e., xn).

\n\n

 

\n

Example 1:

\n\n
Input: x = 2.00000, n = 10\nOutput: 1024.00000\n
\n\n

Example 2:

\n\n
Input: x = 2.10000, n = 3\nOutput: 9.26100\n
\n\n

Example 3:

\n\n
Input: x = 2.00000, n = -2\nOutput: 0.25000\nExplanation: 2-2 = 1/22 = 1/4 = 0.25\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • -100.0 < x < 100.0
    • \n\t
  • -231 <= n <= 231-1
    • \n\t
  • -104 <= xn <= 104
    • \n
\n
" }, { "path": "509-fibonacci-number/509-fibonacci-number.java", "content": "class Solution{\n static long mod = 1000000007;\n long[][] multiply(long [][]m1, long[][]m2){\n long ans[][] =new long[2][2];\n for(int i=0;i<2;i++)\n for(int j=0;j<2;j++)\n for(int k=0;k<2;k++)\n ans[i][j] += (m1[i][k]*m2[k][j])%mod;\n return ans;\n }\n \n long[][] matPow(long [][]mat,long n){\n if(n == 1)return mat;\n long[][] ans = matPow(mat,n/2);\n ans = multiply(ans,ans);\n if((n&1) == 1)ans = multiply(ans,mat);\n return ans;\n }\n \n public int fib(int N){\n long n = N;\n if(n==1 || n==0)return N;\n long mat[][] = {{1,1},{1,0}};\n mat = matPow(mat,n-1);\n return (int) (mat[0][0]%mod);\n }\n}" }, { "path": "509-fibonacci-number/NOTES.md", "content": "​" }, { "path": "509-fibonacci-number/README.md", "content": "

509. Fibonacci Number

Easy

The Fibonacci numbers, commonly denoted F(n) form a sequence, called the Fibonacci sequence, such that each number is the sum of the two preceding ones, starting from 0 and 1. That is,

\n\n
F(0) = 0, F(1) = 1\nF(n) = F(n - 1) + F(n - 2), for n > 1.\n
\n\n

Given n, calculate F(n).

\n\n

 

\n

Example 1:

\n\n
Input: n = 2\nOutput: 1\nExplanation: F(2) = F(1) + F(0) = 1 + 0 = 1.\n
\n\n

Example 2:

\n\n
Input: n = 3\nOutput: 2\nExplanation: F(3) = F(2) + F(1) = 1 + 1 = 2.\n
\n\n

Example 3:

\n\n
Input: n = 4\nOutput: 3\nExplanation: F(4) = F(3) + F(2) = 2 + 1 = 3.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= n <= 30
    • \n
\n
" }, { "path": "51-n-queens/51-n-queens.java", "content": "class Solution {\n public List> solveNQueens(int n) {\n char[][] board=new char[n][n];\n for(int i=0;i> res=new ArrayList<>();\n solve(res, 0,board, leftRow, upperDiagonal, lowerDiagonal);\n return res;\n }\n public static void solve(List> res, int col, char[][] board, int[] leftRow, int[] upperDiagonal, int[] lowerDiagonal)\n {\n int n=board.length;\n if(col==n){\n res.add(construct(board));\n return;\n }\n for(int row=0;row construct(char[][] board){\n List fans=new ArrayList<>();\n for(int i=0;i51. N-Queens

Hard

The n-queens puzzle is the problem of placing n queens on an n x n chessboard such that no two queens attack each other.

\n\n

Given an integer n, return all distinct solutions to the n-queens puzzle. You may return the answer in any order.

\n\n

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space, respectively.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 4\nOutput: [[\".Q..\",\"...Q\",\"Q...\",\"..Q.\"],[\"..Q.\",\"Q...\",\"...Q\",\".Q..\"]]\nExplanation: There exist two distinct solutions to the 4-queens puzzle as shown above\n
\n\n

Example 2:

\n\n
Input: n = 1\nOutput: [[\"Q\"]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 9
    • \n
\n
" }, { "path": "52-n-queens-ii/52-n-queens-ii.java", "content": "class Solution {\n int count;\n public int totalNQueens(int n) {\n boolean[][]board=new boolean[n][n];\n dfs(board,0);\n return count; \n }\n public void dfs(boolean[][]board,int row){\n if(row==board.length){\n count++;\n return;\n }\n for(int col=0;col52. N-Queens II

Hard

The n-queens puzzle is the problem of placing n queens on an n x n chessboard such that no two queens attack each other.

\n\n

Given an integer n, return the number of distinct solutions to the n-queens puzzle.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 4\nOutput: 2\nExplanation: There are two distinct solutions to the 4-queens puzzle as shown.\n
\n\n

Example 2:

\n\n
Input: n = 1\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 9
    • \n
\n
" }, { "path": "53-maximum-subarray/53-maximum-subarray.java", "content": "class Solution {\n public int maxSubArray(int[] nums) {\n int max=Integer.MIN_VALUE;\n int temp=0;\n for(int i=0;imax)max=temp;\n if(temp<0)temp=0;\n }\n return max;\n }\n}" }, { "path": "53-maximum-subarray/Maximum Subarray.py", "content": "class Solution:\n def maxSubArray(self, nums: List[int]) -> int:\n \n \n current = 0\n maxsum = nums[0]\n \n for i in range(len(nums)):\n current += nums[i]\n \n if current>maxsum:\n maxsum = current\n if current < 0:\n current = 0\n \n return maxsum\n \n" }, { "path": "53-maximum-subarray/NOTES.md", "content": "​" }, { "path": "53-maximum-subarray/README.md", "content": "

53. Maximum Subarray

Medium

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

\n\n

A subarray is a contiguous part of an array.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]\nOutput: 6\nExplanation: [4,-1,2,1] has the largest sum = 6.\n
\n\n

Example 2:

\n\n
Input: nums = [1]\nOutput: 1\n
\n\n

Example 3:

\n\n
Input: nums = [5,4,-1,7,8]\nOutput: 23\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 105
    • \n\t
  • -104 <= nums[i] <= 104
    • \n
\n\n

 

\n

Follow up: If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

\n
" }, { "path": "535-encode-and-decode-tinyurl/535-encode-and-decode-tinyurl.java", "content": "public class Codec {\n\n // Encodes a URL to a shortened URL.\n public String encode(String s) {\n return s;\n }\n\n // Decodes a shortened URL to its original URL.\n public String decode(String s) {\n return s;\n }\n}\n\n// Your Codec object will be instantiated and called as such:\n// Codec codec = new Codec();\n// codec.decode(codec.encode(url));" }, { "path": "535-encode-and-decode-tinyurl/NOTES.md", "content": "​" }, { "path": "535-encode-and-decode-tinyurl/README.md", "content": "

535. Encode and Decode TinyURL

Medium

Note: This is a companion problem to the System Design problem: Design TinyURL.
\n\n

TinyURL is a URL shortening service where you enter a URL such as https://leetcode.com/problems/design-tinyurl and it returns a short URL such as http://tinyurl.com/4e9iAk. Design a class to encode a URL and decode a tiny URL.

\n\n

There is no restriction on how your encode/decode algorithm should work. You just need to ensure that a URL can be encoded to a tiny URL and the tiny URL can be decoded to the original URL.

\n\n

Implement the Solution class:

\n\n
    \n\t
  • Solution() Initializes the object of the system.
    • \n\t
  • String encode(String longUrl) Returns a tiny URL for the given longUrl.
    • \n\t
  • String decode(String shortUrl) Returns the original long URL for the given shortUrl. It is guaranteed that the given shortUrl was encoded by the same object.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input: url = \"https://leetcode.com/problems/design-tinyurl\"\nOutput: \"https://leetcode.com/problems/design-tinyurl\"\n\nExplanation:\nSolution obj = new Solution();\nstring tiny = obj.encode(url); // returns the encoded tiny url.\nstring ans = obj.decode(tiny); // returns the original url after deconding it.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= url.length <= 104
    • \n\t
  • url is guranteed to be a valid URL.
    • \n
\n
" }, { "path": "538-convert-bst-to-greater-tree/538-convert-bst-to-greater-tree.java", "content": "class Solution {\n int sum=0;\n public TreeNode convertBST(TreeNode root) {\n if(root==null) return null;\n convertBST(root.right);\n sum+=root.val;\n root.val=sum;\n convertBST(root.left);\n return root;\n }\n}" }, { "path": "538-convert-bst-to-greater-tree/NOTES.md", "content": "​" }, { "path": "538-convert-bst-to-greater-tree/README.md", "content": "

538. Convert BST to Greater Tree

Medium

Given the root of a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus the sum of all keys greater than the original key in BST.

\n\n

As a reminder, a binary search tree is a tree that satisfies these constraints:

\n\n
    \n\t
  • The left subtree of a node contains only nodes with keys less than the node's key.
    • \n\t
  • The right subtree of a node contains only nodes with keys greater than the node's key.
    • \n\t
  • Both the left and right subtrees must also be binary search trees.
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]\nOutput: [30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]\n
\n\n

Example 2:

\n\n
Input: root = [0,null,1]\nOutput: [1,null,1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 104].
    • \n\t
  • -104 <= Node.val <= 104
    • \n\t
  • All the values in the tree are unique.
    • \n\t
  • root is guaranteed to be a valid binary search tree.
    • \n
\n\n

 

\n

Note: This question is the same as 1038: https://leetcode.com/problems/binary-search-tree-to-greater-sum-tree/

\n
" }, { "path": "541-reverse-string-ii/541-reverse-string-ii.java", "content": "class Solution {\n public String reverseStr(String s, int k) {\n StringBuilder sb=new StringBuilder();\n int i=0;\n if(k>s.length())\n return sb.append(s).reverse().toString();\n boolean flag=true;\n for(i=0;i541. Reverse String II

Easy

Given a string s and an integer k, reverse the first k characters for every 2k characters counting from the start of the string.

\n\n

If there are fewer than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and leave the other as original.

\n\n

 

\n

Example 1:

\n
Input: s = \"abcdefg\", k = 2\nOutput: \"bacdfeg\"\n

Example 2:

\n
Input: s = \"abcd\", k = 2\nOutput: \"bacd\"\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 104
    • \n\t
  • s consists of only lowercase English letters.
    • \n\t
  • 1 <= k <= 104
    • \n
\n
" }, { "path": "557 Reverse Words in a String III easy lc s22.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n// 2 -pointer tech TC: O(N) -outer loops iterate over N chars to find start & end idx of every word, reverse word also iterates N times to perform N/2 swaps. thus , TC is O(N+N) = O(N)\n// SC: O(1) using const extra space to track last space idx\n string reverseWords(string s) {\n int lastSpaceIndex = -1;\n int len = (int)s.size();\n for(int i = 0; i <= len; i++){\n if(i== len || s[i] == ' '){\n int start_i = lastSpaceIndex +1;\n int end_i = i-1;\n while(start_i < end_i){\n char temp = s[start_i];\n s[start_i] = s[end_i];\n s[end_i] = temp;\n start_i++;\n end_i--;\n }\n lastSpaceIndex = i;\n }\n }\n return s;\n \n }\n};" }, { "path": "557-reverse-words-in-a-string-iii/557-reverse-words-in-a-string-iii.java", "content": "class Solution {\n public String reverseWords(String sy) {\n String[] arr=sy.split(\" \");\n for(int i=0;i& nums, int k) { \n unordered_map mp;\n int sum=0, ans=0;\n mp[sum] = 1; // we always have one subarray with sum 0\n for(auto it : nums){\n sum += it; // prefix sum \n if(mp.find(sum - k) != mp.end()) ans += mp[sum - k];\n mp[sum]++;\n }\n return ans;\n }\n};\n" }, { "path": "576-out-of-boundary-paths/576-out-of-boundary-paths.java", "content": "class Solution {\n int[][][] cache;\n int MOD = 1000_000_007;\n public int findPaths(int m, int n, int maxMove, int startRow, int startColumn) {\n cache = new int[m][n][maxMove + 1];\n for(int[][] cc : cache) {\n for(int[] c : cc) {\n Arrays.fill(c, -1);\n }\n }\n return f(m, n, maxMove, startRow, startColumn);\n }\n int f(int m, int n, int max, int r, int c) {\n if(r < 0 || c < 0 || r == m || c == n) {\n return 1;\n }\n if(max == 0) {\n return 0;\n }\n if(cache[r][c][max] > -1) {\n return cache[r][c][max];\n }\n long l = f(m, n, max - 1, r - 1, c) % MOD;\n l += f(m, n, max - 1, r + 1, c) % MOD;\n l += f(m, n, max - 1, r, c + 1) % MOD;\n l += f(m, n, max - 1, r, c - 1) % MOD;\n cache[r][c][max] = (int)(l % MOD);\n return cache[r][c][max];\n }\n}" }, { "path": "576-out-of-boundary-paths/NOTES.md", "content": "​" }, { "path": "576-out-of-boundary-paths/README.md", "content": "

576. Out of Boundary Paths

Medium

There is an m x n grid with a ball. The ball is initially at the position [startRow, startColumn]. You are allowed to move the ball to one of the four adjacent cells in the grid (possibly out of the grid crossing the grid boundary). You can apply at most maxMove moves to the ball.

\n\n

Given the five integers m, n, maxMove, startRow, startColumn, return the number of paths to move the ball out of the grid boundary. Since the answer can be very large, return it modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: m = 2, n = 2, maxMove = 2, startRow = 0, startColumn = 0\nOutput: 6\n
\n\n

Example 2:

\n\"\"\n
Input: m = 1, n = 3, maxMove = 3, startRow = 0, startColumn = 1\nOutput: 12\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= m, n <= 50
    • \n\t
  • 0 <= maxMove <= 50
    • \n\t
  • 0 <= startRow < m
    • \n\t
  • 0 <= startColumn < n
    • \n
\n
" }, { "path": "581-shortest-unsorted-continuous-subarray/581-shortest-unsorted-continuous-subarray.java", "content": "public class Solution {\n public int findUnsortedSubarray(int[] nums) {\n int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;\n boolean flag = false;\n for (int i = 1; i < nums.length; i++) {\n if (nums[i] < nums[i - 1])\n flag = true;\n if (flag)\n min = Math.min(min, nums[i]);\n }\n flag = false;\n for (int i = nums.length - 2; i >= 0; i--) {\n if (nums[i] > nums[i + 1])\n flag = true;\n if (flag)\n max = Math.max(max, nums[i]);\n }\n int l, r;\n for (l = 0; l < nums.length; l++) {\n if (min < nums[l])\n break;\n }\n for (r = nums.length - 1; r >= 0; r--) {\n if (max > nums[r])\n break;\n }\n return r - l < 0 ? 0 : r - l + 1;\n }\n}" }, { "path": "581-shortest-unsorted-continuous-subarray/NOTES.md", "content": "​" }, { "path": "581-shortest-unsorted-continuous-subarray/README.md", "content": "

581. Shortest Unsorted Continuous Subarray

Medium

Given an integer array nums, you need to find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order.

\n\n

Return the shortest such subarray and output its length.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [2,6,4,8,10,9,15]\nOutput: 5\nExplanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.\n
\n\n

Example 2:

\n\n
Input: nums = [1,2,3,4]\nOutput: 0\n
\n\n

Example 3:

\n\n
Input: nums = [1]\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 104
    • \n\t
  • -105 <= nums[i] <= 105
    • \n
\n\n

 

\nFollow up: Can you solve it in O(n) time complexity?
" }, { "path": "583-delete-operation-for-two-strings/583-delete-operation-for-two-strings.java", "content": "class Solution {\n public int minDistance(String word1, String word2) {\n \n char[] s1= word1.toCharArray();\n char[] s2 = word2.toCharArray();\n \n int[][] DP = new int[s1.length+1][s2.length+1];\n \n for (int i=s1.length-1;i>=0;--i){\n for (int j=s2.length-1;j>=0;--j){\n if(s1[i] == s2[j]){\n DP[i][j]= 1+ DP[i+1][j+1];\n }else{\n DP[i][j]=Math.max(DP[i+1][j],DP[i][j+1]);\n }\n }\n }\n \n return word1.length()+word2.length()-(2*DP[0][0]);\n }\n \n \n}" }, { "path": "583-delete-operation-for-two-strings/NOTES.md", "content": "​" }, { "path": "583-delete-operation-for-two-strings/README.md", "content": "

583. Delete Operation for Two Strings

Medium

Given two strings word1 and word2, return the minimum number of steps required to make word1 and word2 the same.

\n\n

In one step, you can delete exactly one character in either string.

\n\n

 

\n

Example 1:

\n\n
Input: word1 = \"sea\", word2 = \"eat\"\nOutput: 2\nExplanation: You need one step to make \"sea\" to \"ea\" and another step to make \"eat\" to \"ea\".\n
\n\n

Example 2:

\n\n
Input: word1 = \"leetcode\", word2 = \"etco\"\nOutput: 4\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= word1.length, word2.length <= 500
    • \n\t
  • word1 and word2 consist of only lowercase English letters.
    • \n
\n
" }, { "path": "59-spiral-matrix-ii/59-spiral-matrix-ii.java", "content": "class Solution {\n public int[][] generateMatrix(int n) {\n \n int ans[][] = new int[n][n];\n fillMatrix(ans, 0 , 0, 1,'r');\n return ans;\n }\n \n public void fillMatrix(int [][]ans, int i, int j, int cur, char dir){\n if(i < 0 || j < 0 || i >=ans.length || j >= ans.length) return;\n \n if(ans[i][j] != 0) return;\n \n ans[i][j] = cur;\n \n if(dir == 'u'){\n fillMatrix(ans, i-1,j,cur+1, 'u'); \n }\n \n fillMatrix(ans, i,j+1,cur+1, 'r');\n fillMatrix(ans, i+1,j,cur+1, 'd');\n fillMatrix(ans, i,j-1,cur+1, 'l');\n fillMatrix(ans, i-1,j,cur+1, 'u');\n \n }\n}" }, { "path": "59-spiral-matrix-ii/NOTES.md", "content": "​" }, { "path": "59-spiral-matrix-ii/README.md", "content": "

59. Spiral Matrix II

Medium

Given a positive integer n, generate an n x n matrix filled with elements from 1 to n2 in spiral order.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: n = 3\nOutput: [[1,2,3],[8,9,4],[7,6,5]]\n
\n\n

Example 2:

\n\n
Input: n = 1\nOutput: [[1]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 20
    • \n
\n
" }, { "path": "6-zigzag-conversion/6-zigzag-conversion.java", "content": "class Solution {\n public String convert(String s, int numRows) {\n int strlen = s.length();\n int n = numRows;\n StringBuilder sub = new StringBuilder();\n if(n==1 || n > strlen) {\n return s;\n }\n for (int i = 0; i < n; i++) {\n int k = i;\n if(i==0 || i == n-1) {\n while(k6. Zigzag Conversion

Medium

The string \"PAYPALISHIRING\" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

\n\n
P   A   H   N\nA P L S I I G\nY   I   R\n
\n\n

And then read line by line: \"PAHNAPLSIIGYIR\"

\n\n

Write the code that will take a string and make this conversion given a number of rows:

\n\n
string convert(string s, int numRows);\n
\n\n

 

\n

Example 1:

\n\n
Input: s = \"PAYPALISHIRING\", numRows = 3\nOutput: \"PAHNAPLSIIGYIR\"\n
\n\n

Example 2:

\n\n
Input: s = \"PAYPALISHIRING\", numRows = 4\nOutput: \"PINALSIGYAHRPI\"\nExplanation:\nP     I    N\nA   L S  I G\nY A   H R\nP     I\n
\n\n

Example 3:

\n\n
Input: s = \"A\", numRows = 1\nOutput: \"A\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 1000
    • \n\t
  • s consists of English letters (lower-case and upper-case), ',' and '.'.
    • \n\t
  • 1 <= numRows <= 1000
    • \n
\n
" }, { "path": "606-construct-string-from-binary-tree/606-construct-string-from-binary-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n StringBuilder sb;\n public String tree2str(TreeNode root) {\n sb=new StringBuilder();\n dfs(root);\n return sb.toString();\n }\n public void dfs(TreeNode root){\n if(root==null)return;\n sb.append(root.val);\n if(root.left==null && root.right==null)return;\n sb.append(\"(\");\n dfs(root.left);\n sb.append(\")\"); \n if(root.right!=null){\n sb.append(\"(\");\n dfs(root.right);\n sb.append(\")\");\n }\n }\n}" }, { "path": "606-construct-string-from-binary-tree/NOTES.md", "content": "​" }, { "path": "606-construct-string-from-binary-tree/README.md", "content": "

606. Construct String from Binary Tree

Easy

Given the root of a binary tree, construct a string consisting of parenthesis and integers from a binary tree with the preorder traversal way, and return it.

\n\n

Omit all the empty parenthesis pairs that do not affect the one-to-one mapping relationship between the string and the original binary tree.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,2,3,4]\nOutput: \"1(2(4))(3)\"\nExplanation: Originally, it needs to be \"1(2(4)())(3()())\", but you need to omit all the unnecessary empty parenthesis pairs. And it will be \"1(2(4))(3)\"\n
\n\n

Example 2:

\n\"\"\n
Input: root = [1,2,3,null,4]\nOutput: \"1(2()(4))(3)\"\nExplanation: Almost the same as the first example, except we cannot omit the first parenthesis pair to break the one-to-one mapping relationship between the input and the output.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 104].
    • \n\t
  • -1000 <= Node.val <= 1000
    • \n
\n
" }, { "path": "609 Find Duplicate File in System lc med s19.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n vector split(string str, char delim) {\n string line;\n vector res;\n stringstream ss(str);\n while (getline(ss, line, delim)) res.push_back(line);\n return res;\n }\n\n vector> findDuplicate(vector& paths) {\n vector> ans;\n unordered_map> m;\n for (auto p : paths) {\n vector path = split(p, ' ');\n string directoryPath;\n for (int i = 0; i < path.size(); i++) {\n if (i == 0) {\n directoryPath = path[i];\n } else {\n string fileName = path[i].substr(0, path[i].find('('));\n string fileContent = path[i].substr(path[i].find('(') + 1, path[i].find(')') - path[i].find('(') - 1);\n m[fileContent].push_back(directoryPath + \"/\" + fileName);\n }\n }\n }\n for (auto x : m) {\n if (x.second.size() > 1) {\n ans.push_back(x.second); \n }\n }\n return ans;\n }\n};" }, { "path": "609-find-duplicate-file-in-system/609-find-duplicate-file-in-system.java", "content": "class Solution {\n public List> findDuplicate(String[] paths) {\n Map> map = new HashMap<>();\n List> res = new ArrayList<>();\n for(int i = 0; i < paths.length; i++){\n String s = paths[i];\n String[] str = s.split(\" \");\n String prefix = str[0] + \"/\";\n for(int j = 1; j < str.length; j++){\n String nc = str[j];\n int t = nc.length() - 1;\n while(t >= 0 && nc.charAt(t) != '(') t--;\n String name = nc.substring(0, t);\n String content = nc.substring(t + 1, nc.length() - 1);\n map.computeIfAbsent(content, a -> new ArrayList<>());\n map.get(content).add(prefix + name);\n }\n }\n \n for(String key: map.keySet()){\n if(map.get(key).size() > 1){\n res.add(map.get(key));\n }\n }\n \n return(res);\n \n }\n}" }, { "path": "609-find-duplicate-file-in-system/NOTES.md", "content": "​" }, { "path": "609-find-duplicate-file-in-system/README.md", "content": "

609. Find Duplicate File in System

Medium

Given a list paths of directory info, including the directory path, and all the files with contents in this directory, return all the duplicate files in the file system in terms of their paths. You may return the answer in any order.

\n\n

A group of duplicate files consists of at least two files that have the same content.

\n\n

A single directory info string in the input list has the following format:

\n\n
    \n\t
  • \"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)\"
    • \n
\n\n

It means there are n files (f1.txt, f2.txt ... fn.txt) with content (f1_content, f2_content ... fn_content) respectively in the directory \"root/d1/d2/.../dm\". Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.

\n\n

The output is a list of groups of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:

\n\n
    \n\t
  • \"directory_path/file_name.txt\"
    • \n
\n\n

 

\n

Example 1:

\n
Input: paths = [\"root/a 1.txt(abcd) 2.txt(efgh)\",\"root/c 3.txt(abcd)\",\"root/c/d 4.txt(efgh)\",\"root 4.txt(efgh)\"]\nOutput: [[\"root/a/2.txt\",\"root/c/d/4.txt\",\"root/4.txt\"],[\"root/a/1.txt\",\"root/c/3.txt\"]]\n

Example 2:

\n
Input: paths = [\"root/a 1.txt(abcd) 2.txt(efgh)\",\"root/c 3.txt(abcd)\",\"root/c/d 4.txt(efgh)\"]\nOutput: [[\"root/a/2.txt\",\"root/c/d/4.txt\"],[\"root/a/1.txt\",\"root/c/3.txt\"]]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= paths.length <= 2 * 104
    • \n\t
  • 1 <= paths[i].length <= 3000
    • \n\t
  • 1 <= sum(paths[i].length) <= 5 * 105
    • \n\t
  • paths[i] consist of English letters, digits, '/', '.', '(', ')', and ' '.
    • \n\t
  • You may assume no files or directories share the same name in the same directory.
    • \n\t
  • You may assume each given directory info represents a unique directory. A single blank space separates the directory path and file info.
    • \n
\n\n

 

\n

Follow up:

\n\n
    \n\t
  • Imagine you are given a real file system, how will you search files? DFS or BFS?
    • \n\t
  • If the file content is very large (GB level), how will you modify your solution?
    • \n\t
  • If you can only read the file by 1kb each time, how will you modify your solution?
    • \n\t
  • What is the time complexity of your modified solution? What is the most time-consuming part and memory-consuming part of it? How to optimize?
    • \n\t
  • How to make sure the duplicated files you find are not false positive?
    • \n
\n
" }, { "path": "62-unique-paths/62-unique-paths.java", "content": "class Solution {\n public int uniquePaths(int m, int n) {\n int[][] dp = new int[m+1][n+1];\n return helper(m, n, dp);\n }\n private int helper(int m, int n, int[][] dp) {\n if(m<1 || n<1) return 0;\n if(m == 1 || n == 1) return 1;\n if(dp[m][n] != 0) return dp[m][n];\n dp[m][n] = helper(m, n-1, dp) + helper(m-1, n, dp);\n return dp[m][n];\n }\n}" }, { "path": "62-unique-paths/NOTES.md", "content": "​" }, { "path": "62-unique-paths/README.md", "content": "

62. Unique Paths

Medium

There is a robot on an m x n grid. The robot is initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m - 1][n - 1]). The robot can only move either down or right at any point in time.

\n\n

Given the two integers m and n, return the number of possible unique paths that the robot can take to reach the bottom-right corner.

\n\n

The test cases are generated so that the answer will be less than or equal to 2 * 109.

\n\n

 

\n

Example 1:

\n\n
Input: m = 3, n = 7\nOutput: 28\n
\n\n

Example 2:

\n\n
Input: m = 3, n = 2\nOutput: 3\nExplanation: From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:\n1. Right -> Down -> Down\n2. Down -> Down -> Right\n3. Down -> Right -> Down\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= m, n <= 100
    • \n
\n
" }, { "path": "622-design-circular-queue/622-design-circular-queue.java", "content": "class MyCircularQueue {\n\n int[] queue;\n int size;\n int used;\n int front;\n int rear;\n \n public MyCircularQueue(int k) {\n queue = new int[k];\n size = k;\n }\n \n public boolean enQueue(int value) {\n if(isFull())\n return false;\n queue[rear] = value;\n rear = (rear+1)%size;\n used++;\n return true;\n }\n \n public boolean deQueue()\n {\n if(isEmpty())\n return false;\n front = (front+1)%size;\n used -- ;\n return true;\n \n }\n \n public int Front() {\n if(isEmpty())\n return -1;\n return queue[front];\n }\n \n public int Rear() {\n if(isEmpty())\n return -1;\n return queue[(rear-1+size)%size];\n }\n \n public boolean isEmpty() {\n return used ==0;\n }\n \n public boolean isFull() {\n return used == size;\n }\n}" }, { "path": "622-design-circular-queue/NOTES.md", "content": "​" }, { "path": "622-design-circular-queue/README.md", "content": "

622. Design Circular Queue

Medium

Design your implementation of the circular queue. The circular queue is a linear data structure in which the operations are performed based on FIFO (First In First Out) principle and the last position is connected back to the first position to make a circle. It is also called \"Ring Buffer\".

\n\n

One of the benefits of the circular queue is that we can make use of the spaces in front of the queue. In a normal queue, once the queue becomes full, we cannot insert the next element even if there is a space in front of the queue. But using the circular queue, we can use the space to store new values.

\n\n

Implementation the MyCircularQueue class:

\n\n
    \n\t
  • MyCircularQueue(k) Initializes the object with the size of the queue to be k.
    • \n\t
  • int Front() Gets the front item from the queue. If the queue is empty, return -1.
    • \n\t
  • int Rear() Gets the last item from the queue. If the queue is empty, return -1.
    • \n\t
  • boolean enQueue(int value) Inserts an element into the circular queue. Return true if the operation is successful.
    • \n\t
  • boolean deQueue() Deletes an element from the circular queue. Return true if the operation is successful.
    • \n\t
  • boolean isEmpty() Checks whether the circular queue is empty or not.
    • \n\t
  • boolean isFull() Checks whether the circular queue is full or not.
    • \n
\n\n

You must solve the problem without using the built-in queue data structure in your programming language. 

\n\n

 

\n

Example 1:

\n\n
Input\n[\"MyCircularQueue\", \"enQueue\", \"enQueue\", \"enQueue\", \"enQueue\", \"Rear\", \"isFull\", \"deQueue\", \"enQueue\", \"Rear\"]\n[[3], [1], [2], [3], [4], [], [], [], [4], []]\nOutput\n[null, true, true, true, false, 3, true, true, true, 4]\n\nExplanation\nMyCircularQueue myCircularQueue = new MyCircularQueue(3);\nmyCircularQueue.enQueue(1); // return True\nmyCircularQueue.enQueue(2); // return True\nmyCircularQueue.enQueue(3); // return True\nmyCircularQueue.enQueue(4); // return False\nmyCircularQueue.Rear();     // return 3\nmyCircularQueue.isFull();   // return True\nmyCircularQueue.deQueue();  // return True\nmyCircularQueue.enQueue(4); // return True\nmyCircularQueue.Rear();     // return 4\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= k <= 1000
    • \n\t
  • 0 <= value <= 1000
    • \n\t
  • At most 3000 calls will be made to enQueue, deQueue, Front, Rear, isEmpty, and isFull.
    • \n
\n
" }, { "path": "623-add-one-row-to-tree/623-add-one-row-to-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public TreeNode addOneRow(TreeNode root, int val, int depth) {\n if(depth==1){\n TreeNode head=new TreeNode(val);\n head.left=root;\n return head;\n }\n dfs(root,val,depth-1);\n return root;\n }\n public void dfs(TreeNode root,int val,int depth){\n if(depth==1){\n TreeNode lefty=root.left;\n TreeNode righty=root.right;\n TreeNode newLeft=new TreeNode(val);\n TreeNode newRight=new TreeNode(val);\n newLeft.left=lefty;\n root.left=newLeft;\n newRight.right=righty;\n root.right=newRight;\n return;\n }\n if(root.left!=null)dfs(root.left,val,depth-1);\n if(root.right!=null)dfs(root.right,val,depth-1);\n }\n}" }, { "path": "623-add-one-row-to-tree/NOTES.md", "content": "​" }, { "path": "623-add-one-row-to-tree/README.md", "content": "

623. Add One Row to Tree

Medium

Given the root of a binary tree and two integers val and depth, add a row of nodes with value val at the given depth depth.

\n\n

Note that the root node is at depth 1.

\n\n

The adding rule is:

\n\n
    \n\t
  • Given the integer depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtree root and right subtree root.
    • \n\t
  • cur's original left subtree should be the left subtree of the new left subtree root.
    • \n\t
  • cur's original right subtree should be the right subtree of the new right subtree root.
    • \n\t
  • If depth == 1 that means there is no depth depth - 1 at all, then create a tree node with value val as the new root of the whole original tree, and the original tree is the new root's left subtree.
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [4,2,6,3,1,5], val = 1, depth = 2\nOutput: [4,1,1,2,null,null,6,3,1,5]\n
\n\n

Example 2:

\n\"\"\n
Input: root = [4,2,null,3,1], val = 1, depth = 3\nOutput: [4,2,null,1,1,3,null,null,1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 104].
    • \n\t
  • The depth of the tree is in the range [1, 104].
    • \n\t
  • -100 <= Node.val <= 100
    • \n\t
  • -105 <= val <= 105
    • \n\t
  • 1 <= depth <= the depth of tree + 1
    • \n
\n
" }, { "path": "629-k-inverse-pairs-array/629-k-inverse-pairs-array.java", "content": "public class Solution {\n public int kInversePairs(int n, int k) {\n int[][] dp = new int[n + 1][k + 1];\n int M = 1000000007;\n for (int i = 1; i <= n; i++) {\n for (int j = 0; j <= k; j++) {\n if (j == 0)\n dp[i][j] = 1;\n else {\n int val = (dp[i - 1][j] + M - ((j - i) >= 0 ? dp[i - 1][j - i] : 0)) % M;\n dp[i][j] = (dp[i][j - 1] + val) % M;\n }\n }\n }\n return ((dp[n][k] + M - (k > 0 ? dp[n][k - 1] : 0)) % M);\n }\n}" }, { "path": "629-k-inverse-pairs-array/NOTES.md", "content": "​" }, { "path": "629-k-inverse-pairs-array/README.md", "content": "

629. K Inverse Pairs Array

Hard

For an integer array nums, an inverse pair is a pair of integers [i, j] where 0 <= i < j < nums.length and nums[i] > nums[j].

\n\n

Given two integers n and k, return the number of different arrays consist of numbers from 1 to n such that there are exactly k inverse pairs. Since the answer can be huge, return it modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: n = 3, k = 0\nOutput: 1\nExplanation: Only the array [1,2,3] which consists of numbers from 1 to 3 has exactly 0 inverse pairs.\n
\n\n

Example 2:

\n\n
Input: n = 3, k = 1\nOutput: 2\nExplanation: The array [1,3,2] and [2,1,3] have exactly 1 inverse pair.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 1000
    • \n\t
  • 0 <= k <= 1000
    • \n
\n
" }, { "path": "63-unique-paths-ii/63-unique-paths-ii.java", "content": "class Solution {\n public int uniquePathsWithObstacles(int[][] a) {\n int result = 0;\n int m = a.length;\n int n = a[0].length;\n int[] row = new int[n];\n int prevCol;\n row[0] = 1 - a[0][0];\n for (int i = 1; i < n; ++i) {\n if (a[0][i] == 1 || a[0][i-1] == 1) {\n row[i] = 0;\n continue;\n }\n row[i] = row[i-1];\n }\n \n for (int i = 1; i < m; ++i) {\n if (a[i-1][0] == 1 || a[i][0] == 1) {\n row[0] = 0;\n }\n for (int j = 1; j < n; ++j) {\n if (a[i][j] == 1) {\n row[j] = 0;\n continue;\n }\n int tmp = 0;\n if (a[i-1][j] != 1) {\n tmp += row[j];\n }\n if (a[i][j-1] != 1) {\n tmp += row[j-1];\n }\n row[j] = tmp;\n }\n }\n return row[n-1];\n }\n}" }, { "path": "63-unique-paths-ii/NOTES.md", "content": "​" }, { "path": "63-unique-paths-ii/README.md", "content": "

63. Unique Paths II

Medium

You are given an m x n integer array grid. There is a robot initially located at the top-left corner (i.e., grid[0][0]). The robot tries to move to the bottom-right corner (i.e., grid[m-1][n-1]). The robot can only move either down or right at any point in time.

\n\n

An obstacle and space are marked as 1 or 0 respectively in grid. A path that the robot takes cannot include any square that is an obstacle.

\n\n

Return the number of possible unique paths that the robot can take to reach the bottom-right corner.

\n\n

The testcases are generated so that the answer will be less than or equal to 2 * 109.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]\nOutput: 2\nExplanation: There is one obstacle in the middle of the 3x3 grid above.\nThere are two ways to reach the bottom-right corner:\n1. Right -> Right -> Down -> Down\n2. Down -> Down -> Right -> Right\n
\n\n

Example 2:

\n\"\"\n
Input: obstacleGrid = [[0,1],[0,0]]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == obstacleGrid.length
    • \n\t
  • n == obstacleGrid[i].length
    • \n\t
  • 1 <= m, n <= 100
    • \n\t
  • obstacleGrid[i][j] is 0 or 1.
    • \n
\n
" }, { "path": "630-course-schedule-iii/630-course-schedule-iii.java", "content": "public class Solution {\n public int scheduleCourse(int[][] courses) {\n Arrays.sort(courses, (a, b) -> a[1] - b[1]);\n PriorityQueue < Integer > queue = new PriorityQueue < > ((a, b) -> b - a);\n int time = 0;\n for (int[] c: courses) {\n if (time + c[0] <= c[1]) {\n queue.offer(c[0]);\n time += c[0];\n } else if (!queue.isEmpty() && queue.peek() > c[0]) {\n time += c[0] - queue.poll();\n queue.offer(c[0]);\n }\n }\n return queue.size();\n }\n}" }, { "path": "630-course-schedule-iii/README.md", "content": "

630. Course Schedule III

Hard

There are n different online courses numbered from 1 to n. You are given an array courses where courses[i] = [durationi, lastDayi] indicate that the ith course should be taken continuously for durationi days and must be finished before or on lastDayi.

\n\n

You will start on the 1st day and you cannot take two or more courses simultaneously.

\n\n

Return the maximum number of courses that you can take.

\n\n

 

\n

Example 1:

\n\n
Input: courses = [[100,200],[200,1300],[1000,1250],[2000,3200]]\nOutput: 3\nExplanation: \nThere are totally 4 courses, but you can take 3 courses at most:\nFirst, take the 1st course, it costs 100 days so you will finish it on the 100th day, and ready to take the next course on the 101st day.\nSecond, take the 3rd course, it costs 1000 days so you will finish it on the 1100th day, and ready to take the next course on the 1101st day. \nThird, take the 2nd course, it costs 200 days so you will finish it on the 1300th day. \nThe 4th course cannot be taken now, since you will finish it on the 3300th day, which exceeds the closed date.\n
\n\n

Example 2:

\n\n
Input: courses = [[1,2]]\nOutput: 1\n
\n\n

Example 3:

\n\n
Input: courses = [[3,2],[4,3]]\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= courses.length <= 104
    • \n\t
  • 1 <= durationi, lastDayi <= 104
    • \n
\n
" }, { "path": "637-average-of-levels-in-binary-tree/637-average-of-levels-in-binary-tree.cpp", "content": "class Solution {\npublic:\n vector averageOfLevels(TreeNode* root) {\n queue q;\n q.push(root);\n vector v;\n while(!q.empty()){\n int n = q.size();\n double d=0; \n for(int i=0;ileft) q.push(node->left);\n if(node->right) q.push(node->right);\n q.pop();\n d += node->val;\n }\n v.push_back(d/n);\n }\n return v;\n }\n};\n\n\n// Same approach:\n// class Solution {\n// public:\n// vector ans;\n// void getAverage(TreeNode *root){\n// queue q;\n// q.push(root);\n// while(!q.empty()){\n// double size = q.size();\n// double sum = 0;\n// for(int i = 0; i < size; i++){\n// auto node = q.front();\n// q.pop();\n// sum += node->val;\n// if(node->left)\n// q.push(node->left);\n// if(node->right)\n// q.push(node->right);\n// }\n// ans.push_back(sum / size);\n// }\n// }\n \n// vector averageOfLevels(TreeNode* root) {\n// getAverage(root);\n// return ans;\n// }\n// };\n" }, { "path": "637-average-of-levels-in-binary-tree/637-average-of-levels-in-binary-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public List averageOfLevels(TreeNode root) {\n List ans=new ArrayList<>();\n Queue q=new LinkedList<>();\n q.add(root);\n while(q.size()>0){\n int sz=q.size();\n int siz=sz;\n Double avg=0.00;\n while(siz-->0){\n TreeNode curr=q.remove();\n if(curr.left!=null)q.add(curr.left);\n if(curr.right!=null)q.add(curr.right);\n avg+=curr.val;\n }\n avg/=sz;\n ans.add(avg);\n }\n return ans;\n }\n}" }, { "path": "637-average-of-levels-in-binary-tree/README.md", "content": "

637. Average of Levels in Binary Tree

Easy

Given the root of a binary tree, return the average value of the nodes on each level in the form of an array. Answers within 10-5 of the actual answer will be accepted.\n

 

\n

Example 1:

\n\"\"\n
Input: root = [3,9,20,null,null,15,7]\nOutput: [3.00000,14.50000,11.00000]\nExplanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11.\nHence return [3, 14.5, 11].\n
\n\n

Example 2:

\n\"\"\n
Input: root = [3,9,20,15,7]\nOutput: [3.00000,14.50000,11.00000]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 104].
    • \n\t
  • -231 <= Node.val <= 231 - 1
    • \n
\n
" }, { "path": "637-average-of-levels-in-binary-tree.py", "content": "class Solution:\n def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:\n \n quene = [] \n res = []\n quene.append(root)\n \n while(quene): \n qlen = len(quene) \n tmp = 0\n for i in range(qlen): \n node = quene.pop(0)\n tmp += node.val\n if node.left: \n quene.append(node.left)\n if node.right:\n quene.append(node.right)\n res.append(tmp/qlen) \n \n return res\n" }, { "path": "647-palindromic-substrings/647-palindromic-substrings.java", "content": "class Solution {\n public int countSubstrings(String s) {\n char[] cs = s.toCharArray();\n int res = 0;\n for(int i = 0;i= 0 && b < s.length(); a --, b ++){\n if(cs[a] != cs[b])\n break;\n res++;\n }\n //even cases\n for(int a = i, b = i + 1; a >= 0 && b < s.length(); a --, b ++){\n if(cs[a] != cs[b])\n break;\n res ++;\n }\n }\n return res;\n }\n}" }, { "path": "647-palindromic-substrings/NOTES.md", "content": "​" }, { "path": "653-two-sum-iv-input-is-a-bst/653-two-sum-iv-input-is-a-bst.java", "content": "public class Solution {\n public boolean findTarget(TreeNode root, int k) {\n return dfs(root, root, k);\n }\n private boolean dfs(TreeNode root, TreeNode cur, int target) {\n if(cur == null) return false;\n return search(root, cur, target - cur.val) ||\n dfs(root, cur.left, target) ||\n dfs(root, cur.right, target);\n }\n private boolean search(TreeNode root, TreeNode cur, int target) {\n if(root == null) return false;\n return (root.val == target && cur != root)||\n (target > root.val && search(root.right, cur, target)) || \n (target < root.val && search(root.left, cur, target));\n }\n}" }, { "path": "653-two-sum-iv-input-is-a-bst/NOTES.md", "content": "​" }, { "path": "653-two-sum-iv-input-is-a-bst/README.md", "content": "

653. Two Sum IV - Input is a BST

Easy

Given the root of a Binary Search Tree and a target number k, return true if there exist two elements in the BST such that their sum is equal to the given target.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [5,3,6,2,4,null,7], k = 9\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: root = [5,3,6,2,4,null,7], k = 28\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 104].
    • \n\t
  • -104 <= Node.val <= 104
    • \n\t
  • root is guaranteed to be a valid binary search tree.
    • \n\t
  • -105 <= k <= 105
    • \n
\n
" }, { "path": "658-find-k-closest-elements/658-find-k-closest-elements.java", "content": "class Solution {\n public List findClosestElements(int[] arr, int k, int x) {\n List ans=new ArrayList<>();\n int idx=binSea(arr,x);\n int l=idx;\n int h=idx;\n while(k>0){\n if(l==h){\n ans.add(arr[l]);\n k--;\n l--;\n h++;\n }else{\n int lefty=l<0?Integer.MAX_VALUE:Math.abs(x-arr[l]);\n int righty=hrighty){\n ans.add(arr[h]);\n h++;\n k--;\n }else{\n ans.add(arr[l]);\n l--;\n k--;\n }\n }\n }\n Collections.sort(ans);\n return ans;\n }\n public int binSea(int[]arr,int x){\n int diff=Integer.MAX_VALUE;\n int idx=-1;\n for(int i=0;i658. Find K Closest Elements

Medium

Given a sorted integer array arr, two integers k and x, return the k closest integers to x in the array. The result should also be sorted in ascending order.

\n\n

An integer a is closer to x than an integer b if:

\n\n
    \n\t
  • |a - x| < |b - x|, or
    • \n\t
  • |a - x| == |b - x| and a < b
    • \n
\n\n

 

\n

Example 1:

\n
Input: arr = [1,2,3,4,5], k = 4, x = 3\nOutput: [1,2,3,4]\n

Example 2:

\n
Input: arr = [1,2,3,4,5], k = 4, x = -1\nOutput: [1,2,3,4]\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= k <= arr.length
    • \n\t
  • 1 <= arr.length <= 104
    • \n\t
  • arr is sorted in ascending order.
    • \n\t
  • -104 <= arr[i], x <= 104
    • \n
\n
" }, { "path": "659-split-array-into-consecutive-subsequences/659-split-array-into-consecutive-subsequences.cpp", "content": "class Solution {\npublic:\n bool isPossible(vector& nums) {\n\n unordered_map available, required;\n\n for(int it : nums)\n available[it]++;\n\n for(int it : nums)\n {\n if(available[it] <= 0)\n continue;\n\n else if(required[it] > 0)\n {\n available[it]--;\n required[it]--;\n required[it+1]++;\n }\n\n else if(available[it] > 0 and available[it+1] > 0 and available[it+2] > 0)\n {\n available[it]--;\n available[it+1]--;\n available[it+2]--;\n required[it+3]++;\n }\n\n else\n return false;\n }\n\n return true;\n }\n};\n" }, { "path": "659-split-array-into-consecutive-subsequences/659-split-array-into-consecutive-subsequences.java", "content": "class Solution {\n public boolean isPossible(int[] nums) {\n Mapcount=new HashMap<>();\n for(int i:nums){\n count.put(i,count.getOrDefault(i,0)+1);\n }\n Map end=new HashMap<>();\n for(int i:nums){\n if(count.get(i)>0){\n count.put(i,count.get(i)-1);\n if(end.containsKey(i-1) && end.get(i-1)>0){\n end.put(i,end.getOrDefault(i,0)+1);\n end.put(i-1,end.get(i-1)-1);\n }else if(count.containsKey(i+1) && count.containsKey(i+2) && count.get(i+1)>0 && count.get(i+2)>0){\n count.put(i+1,count.get(i+1)-1);\n count.put(i+2,count.get(i+2)-1);\n end.put(i+2,end.getOrDefault(i+2,0)+1);\n }else{\n return false;\n }\n }\n }\n return true;\n }\n}" }, { "path": "659-split-array-into-consecutive-subsequences/NOTES.md", "content": "​" }, { "path": "659-split-array-into-consecutive-subsequences/README.md", "content": "

659. Split Array into Consecutive Subsequences

Medium

You are given an integer array nums that is sorted in non-decreasing order.

\n\n

Determine if it is possible to split nums into one or more subsequences such that both of the following conditions are true:

\n\n
    \n\t
  • Each subsequence is a consecutive increasing sequence (i.e. each integer is exactly one more than the previous integer).
    • \n\t
  • All subsequences have a length of 3 or more.
    • \n
\n\n

Return true if you can split nums according to the above conditions, or false otherwise.

\n\n

A subsequence of an array is a new array that is formed from the original array by deleting some (can be none) of the elements without disturbing the relative positions of the remaining elements. (i.e., [1,3,5] is a subsequence of [1,2,3,4,5] while [1,3,2] is not).

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3,3,4,5]\nOutput: true\nExplanation: nums can be split into the following subsequences:\n[1,2,3,3,4,5] --> 1, 2, 3\n[1,2,3,3,4,5] --> 3, 4, 5\n
\n\n

Example 2:

\n\n
Input: nums = [1,2,3,3,4,4,5,5]\nOutput: true\nExplanation: nums can be split into the following subsequences:\n[1,2,3,3,4,4,5,5] --> 1, 2, 3, 4, 5\n[1,2,3,3,4,4,5,5] --> 3, 4, 5\n
\n\n

Example 3:

\n\n
Input: nums = [1,2,3,4,4,5]\nOutput: false\nExplanation: It is impossible to split nums into consecutive increasing subsequences of length 3 or more.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 104
    • \n\t
  • -1000 <= nums[i] <= 1000
    • \n\t
  • nums is sorted in non-decreasing order.
    • \n
\n
" }, { "path": "665-non-decreasing-array/665-non-decreasing-array.java", "content": "class Solution {\n\tpublic boolean checkPossibility(int[] arr) {\n\t\tint index = helper(arr);\n\t\tif (index == -1) {\n\t\t\treturn true;\n\t\t}\n\t\tint temp = arr[index];\n\t\tarr[index] = arr[index + 1];\n\t\tif (helper(arr) == -1) {\n\t\t\treturn true;\n\t\t}\n\n\t\tarr[index] = temp;\n\t\tarr[index + 1] = temp;\n\t\tif (helper(arr) == -1) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\n\tpublic int helper(int[] arr) {\n\t\tfor (int i = 0; i < arr.length - 1; i++) {\n\t\t\tif (arr[i] > arr[i + 1]) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t}\n}" }, { "path": "665-non-decreasing-array/NOTES.md", "content": "​" }, { "path": "665-non-decreasing-array/README.md", "content": "

665. Non-decreasing Array

Medium

Given an array nums with n integers, your task is to check if it could become non-decreasing by modifying at most one element.

\n\n

We define an array is non-decreasing if nums[i] <= nums[i + 1] holds for every i (0-based) such that (0 <= i <= n - 2).

\n\n

 

\n

Example 1:

\n\n
Input: nums = [4,2,3]\nOutput: true\nExplanation: You could modify the first 4 to 1 to get a non-decreasing array.\n
\n\n

Example 2:

\n\n
Input: nums = [4,2,1]\nOutput: false\nExplanation: You can't get a non-decreasing array by modify at most one element.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == nums.length
    • \n\t
  • 1 <= n <= 104
    • \n\t
  • -105 <= nums[i] <= 105
    • \n
\n
" }, { "path": "669-trim-a-binary-search-tree/669-trim-a-binary-search-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public TreeNode trimBST(TreeNode root, int low, int high) {\n if(root==null)return null;\n if(root.valhigh){\n return trimBST(root.left,low,high);\n }\n root.left=trimBST(root.left,low,high);\n root.right=trimBST(root.right,low,high);\n return root;\n }\n}" }, { "path": "669-trim-a-binary-search-tree/NOTES.md", "content": "​" }, { "path": "669-trim-a-binary-search-tree/README.md", "content": "

669. Trim a Binary Search Tree

Medium

Given the root of a binary search tree and the lowest and highest boundaries as low and high, trim the tree so that all its elements lies in [low, high]. Trimming the tree should not change the relative structure of the elements that will remain in the tree (i.e., any node's descendant should remain a descendant). It can be proven that there is a unique answer.

\n\n

Return the root of the trimmed binary search tree. Note that the root may change depending on the given bounds.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,0,2], low = 1, high = 2\nOutput: [1,null,2]\n
\n\n

Example 2:

\n\"\"\n
Input: root = [3,0,4,null,2,null,null,1], low = 1, high = 3\nOutput: [3,2,null,1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree in the range [1, 104].
    • \n\t
  • 0 <= Node.val <= 104
    • \n\t
  • The value of each node in the tree is unique.
    • \n\t
  • root is guaranteed to be a valid binary search tree.
    • \n\t
  • 0 <= low <= high <= 104
    • \n
\n
" }, { "path": "680-valid-palindrome-ii/680-valid-palindrome-ii.java", "content": "class Solution {\n public boolean validPalindrome(String s) {\n \n int len = s.length();\n \n if(len <= 2) \n return true;\n \n byte[] chars = s.getBytes();\n \n for(int i=0,j=len-1; i680. Valid Palindrome II

Easy

Given a string s, return true if the s can be palindrome after deleting at most one character from it.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"aba\"\nOutput: true\n
\n\n

Example 2:

\n\n
Input: s = \"abca\"\nOutput: true\nExplanation: You could delete the character 'c'.\n
\n\n

Example 3:

\n\n
Input: s = \"abc\"\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 105
    • \n\t
  • s consists of lowercase English letters.
    • \n
\n
" }, { "path": "682-baseball-game/682-baseball-game.java", "content": "class Solution {\n public int calPoints(String[] ops) {\n Deque st=new ArrayDeque<>();\n for(int i=0;i682. Baseball Game

Easy

You are keeping score for a baseball game with strange rules. The game consists of several rounds, where the scores of past rounds may affect future rounds' scores.

\n\n

At the beginning of the game, you start with an empty record. You are given a list of strings ops, where ops[i] is the ith operation you must apply to the record and is one of the following:

\n\n
    \n\t
  1. An integer x - Record a new score of x.
    2. \n\t
  2. \"+\" - Record a new score that is the sum of the previous two scores. It is guaranteed there will always be two previous scores.
    3. \n\t
  3. \"D\" - Record a new score that is double the previous score. It is guaranteed there will always be a previous score.
    4. \n\t
  4. \"C\" - Invalidate the previous score, removing it from the record. It is guaranteed there will always be a previous score.
    5. \n
\n\n

Return the sum of all the scores on the record.

\n\n

 

\n

Example 1:

\n\n
Input: ops = [\"5\",\"2\",\"C\",\"D\",\"+\"]\nOutput: 30\nExplanation:\n\"5\" - Add 5 to the record, record is now [5].\n\"2\" - Add 2 to the record, record is now [5, 2].\n\"C\" - Invalidate and remove the previous score, record is now [5].\n\"D\" - Add 2 * 5 = 10 to the record, record is now [5, 10].\n\"+\" - Add 5 + 10 = 15 to the record, record is now [5, 10, 15].\nThe total sum is 5 + 10 + 15 = 30.\n
\n\n

Example 2:

\n\n
Input: ops = [\"5\",\"-2\",\"4\",\"C\",\"D\",\"9\",\"+\",\"+\"]\nOutput: 27\nExplanation:\n\"5\" - Add 5 to the record, record is now [5].\n\"-2\" - Add -2 to the record, record is now [5, -2].\n\"4\" - Add 4 to the record, record is now [5, -2, 4].\n\"C\" - Invalidate and remove the previous score, record is now [5, -2].\n\"D\" - Add 2 * -2 = -4 to the record, record is now [5, -2, -4].\n\"9\" - Add 9 to the record, record is now [5, -2, -4, 9].\n\"+\" - Add -4 + 9 = 5 to the record, record is now [5, -2, -4, 9, 5].\n\"+\" - Add 9 + 5 = 14 to the record, record is now [5, -2, -4, 9, 5, 14].\nThe total sum is 5 + -2 + -4 + 9 + 5 + 14 = 27.\n
\n\n

Example 3:

\n\n
Input: ops = [\"1\"]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= ops.length <= 1000
    • \n\t
  • ops[i] is \"C\", \"D\", \"+\", or a string representing an integer in the range [-3 * 104, 3 * 104].
    • \n\t
  • For operation \"+\", there will always be at least two previous scores on the record.
    • \n\t
  • For operations \"C\" and \"D\", there will always be at least one previous score on the record.
    • \n
\n
" }, { "path": "695-max-area-of-island/695-max-area-of-island.java", "content": "class Solution {\n public int maxAreaOfIsland(int[][] grid) {\n\n int max=0;\n for (int i=0;imax)\n max=area;\n }\n }\n }\n return max;\n }\n public static int iarea(int [][]grid,int i,int j){\n if(i=0 && j>=0 && grid[i][j]==1){\n grid[i] [j] =0;\n int up=iarea(grid,i-1,j);\n int down=iarea(grid, i+1,j);\n int left=iarea(grid, i,j-1);\n int right=iarea(grid,i,j+1);\n return 1+left+right+up+down;\n }\n return 0; \n }\n}" }, { "path": "695-max-area-of-island/NOTES.md", "content": "​" }, { "path": "695-max-area-of-island/README.md", "content": "

695. Max Area of Island

Medium

You are given an m x n binary matrix grid. An island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.

\n\n

The area of an island is the number of cells with a value 1 in the island.

\n\n

Return the maximum area of an island in grid. If there is no island, return 0.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]\nOutput: 6\nExplanation: The answer is not 11, because the island must be connected 4-directionally.\n
\n\n

Example 2:

\n\n
Input: grid = [[0,0,0,0,0,0,0,0]]\nOutput: 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == grid.length
    • \n\t
  • n == grid[i].length
    • \n\t
  • 1 <= m, n <= 50
    • \n\t
  • grid[i][j] is either 0 or 1.
    • \n
\n
" }, { "path": "695-max-area-of-island/SolutionCode.cpp", "content": "/*\n Approach: Since we have to find the maximum Island Area, so for if have any square Island we would consider it's adjacent(Top, Bottom, Left, Right), if they have \n value 1(which will mean it's land), similarily we would check thier adjacent square positions, so on...., now we could observe here that once a land position is\n picked then we have to continue searching for land positon in all 4 directions of square, after that only total Island area could be found, then we move to another\n position which is land and also not part of any previous calculated(Traversed) Islands,\n \n By Observing above it is quite clear that we need to apply, DFS algorithm.\n\n*/\n\n\n// Code Below : \n\nclass Solution {\npublic:\nint travelMap(int r, int c, vector> &grid){\n if(r<0 || c<0 || r>=grid.size() || c>=grid[0].size() || grid[r][c]==0){\n return 0;\n }\n \n // So as to make it marked as visited position.\n grid[r][c] = 0;\n \n // int Down = travelMap(r+1, c, grid);\n // int Right = travelMap(r, c+1, grid);\n // int Up = travelMap(r-1, c, grid);\n // int Left = travelMap(r, c-1, grid);\n \n \n // 1 extra area added for the Area of Current position \n return 1 + travelMap(r+1, c, grid) + travelMap(r, c+1, grid) + \n travelMap(r-1, c, grid) + travelMap(r, c-1, grid);\n} \n int maxAreaOfIsland(vector>& grid) {\n int mxArea = 0;\n \n for(int i=0;itarget) || (i>0 && sum[i] == sum[i-1]))continue;\n \n sum[i]+=arr[ind];\n \n if(dfs(ind-1,arr,sum,k,target))return true;\n sum[i]-= arr[ind];\n }\n return false;\n }\n}" }, { "path": "698-partition-to-k-equal-sum-subsets/README.md", "content": "

698. Partition to K Equal Sum Subsets

Medium

Given an integer array nums and an integer k, return true if it is possible to divide this array into k non-empty subsets whose sums are all equal.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [4,3,2,3,5,2,1], k = 4\nOutput: true\nExplanation: It is possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.\n
\n\n

Example 2:

\n\n
Input: nums = [1,2,3,4], k = 3\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= k <= nums.length <= 16
    • \n\t
  • 1 <= nums[i] <= 104
    • \n\t
  • The frequency of each element is in the range [1, 4].
    • \n
\n
" }, { "path": "7 Segment Display.java", "content": "class Solution {\n static String sevenSegments(String S, int N) {\n int sum=0;\n int nums[]={6,2,5,5,4,5,6,3,7,5};\n for(int i=0;i=2*(N-j)){\n s1.append(\"0\");\n sum-=6;\n j++;\n }\n while(j<=N && sum>0){\n sum-=2;\n if(j==N && sum!=0){\n sum+=2;\n if(sum==5)\n s1.append(\"2\");\n else if(sum==4)\n s1.append(\"4\");\n else if(sum==3)\n s1.append(\"7\");\n else if(sum==7)\n s1.append(\"8\");\n break;\n }\n else{\n s1.append(\"1\");\n }\n j++;\n }\n return s1+\"\";\n }\n};\n" }, { "path": "70-climbing-stairs/70-climbing-stairs.java", "content": "class Solution {\n public int climbStairs(int n) {\n \n int dp[] = new int[n+1];\n dp[n] = 1;\n for(int i = n; i>=0; i--){\n if(i+1<=n){\n dp[i] = dp[i+1];\n }\n if(i+2<=n){\n dp[i] = dp[i+1] + dp[i+2];\n }\n }\n \n return dp[0];\n }\n}" }, { "path": "70-climbing-stairs/NOTES.md", "content": "" }, { "path": "70-climbing-stairs/README.md", "content": "

70. Climbing Stairs

Easy

You are climbing a staircase. It takes n steps to reach the top.

\n\n

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

\n\n

 

\n

Example 1:

\n\n
Input: n = 2\nOutput: 2\nExplanation: There are two ways to climb to the top.\n1. 1 step + 1 step\n2. 2 steps\n
\n\n

Example 2:

\n\n
Input: n = 3\nOutput: 3\nExplanation: There are three ways to climb to the top.\n1. 1 step + 1 step + 1 step\n2. 1 step + 2 steps\n3. 2 steps + 1 step\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= n <= 45
    • \n
\n
" }, { "path": "700-search-in-a-binary-search-tree/700-search-in-a-binary-search-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public TreeNode searchBST(TreeNode root, int val) {\n if(root==null)return null;\n if(root.val>val){\n return searchBST(root.left,val);\n }else if(root.val700. Search in a Binary Search Tree

Easy

You are given the root of a binary search tree (BST) and an integer val.

\n\n

Find the node in the BST that the node's value equals val and return the subtree rooted with that node. If such a node does not exist, return null.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [4,2,7,1,3], val = 2\nOutput: [2,1,3]\n
\n\n

Example 2:

\n\"\"\n
Input: root = [4,2,7,1,3], val = 5\nOutput: []\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 5000].
    • \n\t
  • 1 <= Node.val <= 107
    • \n\t
  • root is a binary search tree.
    • \n\t
  • 1 <= val <= 107
    • \n
\n
" }, { "path": "703-kth-largest-element-in-a-stream/703-kth-largest-element-in-a-stream.py", "content": "class KthLargest:\n\n def __init__(self, k: int, nums: List[int]):\n self.k=k\n self.nums=nums\n \n\n def add(self, val: int) -> int:\n self.nums.append(val)\n self.nums.sort()\n return self.nums[len(self.nums)-self.k]\n\n\n# Your KthLargest object will be instantiated and called as such:\n# obj = KthLargest(k, nums)\n# param_1 = obj.add(val)" }, { "path": "703-kth-largest-element-in-a-stream/NOTES.md", "content": "​" }, { "path": "704-binary-search/704-binary-search.java", "content": "class Solution {\n public int search(int[] nums, int target) {\n int start=0;\n int end=nums.length-1;\n while(start<=end){\n int mid=(start+end)/2;\n if(nums[mid]==target){\n return mid; \n }else if(nums[mid]>target){\n end=mid-1;\n }else{\n start=mid+1;\n }\n }\n return -1;\n }\n}" }, { "path": "704-binary-search/NOTES.md", "content": "​" }, { "path": "704-binary-search/README.md", "content": "

704. Binary Search

Easy

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.

\n\n

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

\n\n

 

\n

Example 1:

\n\n
Input: nums = [-1,0,3,5,9,12], target = 9\nOutput: 4\nExplanation: 9 exists in nums and its index is 4\n
\n\n

Example 2:

\n\n
Input: nums = [-1,0,3,5,9,12], target = 2\nOutput: -1\nExplanation: 2 does not exist in nums so return -1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 104
    • \n\t
  • -104 < nums[i], target < 104
    • \n\t
  • All the integers in nums are unique.
    • \n\t
  • nums is sorted in ascending order.
    • \n
\n
" }, { "path": "705-design-hashset/705-design-hashset.java", "content": "class MyHashSet {\n boolean[] arr;\n public MyHashSet() {\n arr=new boolean[1000001];\n }\n \n public void add(int key) {\n arr[key]=true;\n }\n \n public void remove(int key) {\n arr[key]=false;\n }\n \n public boolean contains(int key) {\n return arr[key];\n }\n}\n\n/**\n * Your MyHashSet object will be instantiated and called as such:\n * MyHashSet obj = new MyHashSet();\n * obj.add(key);\n * obj.remove(key);\n * boolean param_3 = obj.contains(key);\n */" }, { "path": "705-design-hashset/NOTES.md", "content": "​" }, { "path": "705-design-hashset/README.md", "content": "

705. Design HashSet

Easy

Design a HashSet without using any built-in hash table libraries.

\n\n

Implement MyHashSet class:

\n\n
    \n\t
  • void add(key) Inserts the value key into the HashSet.
    • \n\t
  • bool contains(key) Returns whether the value key exists in the HashSet or not.
    • \n\t
  • void remove(key) Removes the value key in the HashSet. If key does not exist in the HashSet, do nothing.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"MyHashSet\", \"add\", \"add\", \"contains\", \"contains\", \"add\", \"contains\", \"remove\", \"contains\"]\n[[], [1], [2], [1], [3], [2], [2], [2], [2]]\nOutput\n[null, null, null, true, false, null, true, null, false]\n\nExplanation\nMyHashSet myHashSet = new MyHashSet();\nmyHashSet.add(1);      // set = [1]\nmyHashSet.add(2);      // set = [1, 2]\nmyHashSet.contains(1); // return True\nmyHashSet.contains(3); // return False, (not found)\nmyHashSet.add(2);      // set = [1, 2]\nmyHashSet.contains(2); // return True\nmyHashSet.remove(2);   // set = [1]\nmyHashSet.contains(2); // return False, (already removed)
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= key <= 106
    • \n\t
  • At most 104 calls will be made to add, remove, and contains.
    • \n
\n
" }, { "path": "706-design-hashmap/706-design-hashmap.java", "content": "class MyHashMap {\n int[]map;\n public MyHashMap() {\n map=new int[1000001];\n Arrays.fill(map,-1);\n }\n \n public void put(int key, int value) {\n map[key]=value;\n }\n \n public int get(int key) {\n if(map[key]==-1)return -1;\n return map[key];\n }\n \n public void remove(int key) {\n map[key]=-1;\n }\n}\n\n/**\n * Your MyHashMap object will be instantiated and called as such:\n * MyHashMap obj = new MyHashMap();\n * obj.put(key,value);\n * int param_2 = obj.get(key);\n * obj.remove(key);\n */" }, { "path": "706-design-hashmap/NOTES.md", "content": "​" }, { "path": "706-design-hashmap/README.md", "content": "

706. Design HashMap

Easy

Design a HashMap without using any built-in hash table libraries.

\n\n

Implement the MyHashMap class:

\n\n
    \n\t
  • MyHashMap() initializes the object with an empty map.
    • \n\t
  • void put(int key, int value) inserts a (key, value) pair into the HashMap. If the key already exists in the map, update the corresponding value.
    • \n\t
  • int get(int key) returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.
    • \n\t
  • void remove(key) removes the key and its corresponding value if the map contains the mapping for the key.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"MyHashMap\", \"put\", \"put\", \"get\", \"get\", \"put\", \"get\", \"remove\", \"get\"]\n[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]\nOutput\n[null, null, null, 1, -1, null, 1, null, -1]\n\nExplanation\nMyHashMap myHashMap = new MyHashMap();\nmyHashMap.put(1, 1); // The map is now [[1,1]]\nmyHashMap.put(2, 2); // The map is now [[1,1], [2,2]]\nmyHashMap.get(1);    // return 1, The map is now [[1,1], [2,2]]\nmyHashMap.get(3);    // return -1 (i.e., not found), The map is now [[1,1], [2,2]]\nmyHashMap.put(2, 1); // The map is now [[1,1], [2,1]] (i.e., update the existing value)\nmyHashMap.get(2);    // return 1, The map is now [[1,1], [2,1]]\nmyHashMap.remove(2); // remove the mapping for 2, The map is now [[1,1]]\nmyHashMap.get(2);    // return -1 (i.e., not found), The map is now [[1,1]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= key, value <= 106
    • \n\t
  • At most 104 calls will be made to put, get, and remove.
    • \n
\n
" }, { "path": "713_Subarray_Product_Less_Than_K.cpp", "content": "class Solution {\npublic:\n int numSubarrayProductLessThanK(vector& n, int k) {\n if(k<=1){\n return 0;\n }\n int product=1,j=0,sub=0;\n for(int i =0;i=k){\n product=product/n[j++];\n }\n sub+=i-j+1;\n }\n return sub;\n }\n};\n" }, { "path": "718-Maximum-Length-of-Repeated-Subarray.cpp", "content": "int findLength(vector& nums1, vector& nums2) \n {\n int n=nums1.size();\n int m=nums2.size();\n //INITIALIZATION\n vector>dp(n+1,vector(m+1));\n for(int i=0;i> hashes = new HashMap();\n int k = 0;\n for (int x: rolling(A, guess)) {\n hashes.computeIfAbsent(x, z -> new ArrayList()).add(k++);\n }\n int j = 0;\n for (int x: rolling(B, guess)) {\n for (int i: hashes.getOrDefault(x, new ArrayList()))\n if (Arrays.equals(Arrays.copyOfRange(A, i, i+guess),\n Arrays.copyOfRange(B, j, j+guess))) {\n return true;\n }\n j++;\n }\n return false;\n }\n\n public int findLength(int[] A, int[] B) {\n int lo = 0, hi = Math.min(A.length, B.length) + 1;\n while (lo < hi) {\n int mi = (lo + hi) / 2;\n if (check(mi, A, B)) lo = mi + 1;\n else hi = mi;\n }\n return lo - 1;\n }\n}" }, { "path": "718-maximum-length-of-repeated-subarray/NOTES.md", "content": "​" }, { "path": "718-maximum-length-of-repeated-subarray/README.md", "content": "

718. Maximum Length of Repeated Subarray

Medium

Given two integer arrays nums1 and nums2, return the maximum length of a subarray that appears in both arrays.

\n\n

 

\n

Example 1:

\n\n
Input: nums1 = [1,2,3,2,1], nums2 = [3,2,1,4,7]\nOutput: 3\nExplanation: The repeated subarray with maximum length is [3,2,1].\n
\n\n

Example 2:

\n\n
Input: nums1 = [0,0,0,0,0], nums2 = [0,0,0,0,0]\nOutput: 5\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums1.length, nums2.length <= 1000
    • \n\t
  • 0 <= nums1[i], nums2[i] <= 100
    • \n
\n
" }, { "path": "718-maximum-length-of-repeated-subarray/Solved Using DP.java", "content": "class Solution {\n public int findLength(int[] nums1, int[] nums2) {\n int n = nums1.length;\n int m = nums2.length;\n \n int[][] dp = new int[n+1][m+1];\n \n int ans = 0;\n \n for(int i = 1; i <= n; i++) {\n for(int j = 1; j <= m; j++) {\n if(nums1[i-1]==nums2[j-1]){\n dp[i][j] = dp[i-1][j-1] + 1;\n ans = Math.max(ans, dp[i][j]); \n }\n else dp[i][j] = 0;\n }\n }\n return ans;\n }\n}\n" }, { "path": "718. Maximum Length of Repeated Subarray/718. Maximum Length of Repeated Subarray.cpp", "content": "class Solution {\npublic:\n int findLength(vector& nums1, vector& nums2) {\n // same as longest common substring\n int n = nums1.size(), m = nums2.size();\n int dp[n+1][m+1];\n \n for(int i=0;i<=n;i++){\n for(int j=0;j<=m;j++){\n if(i==0 || j==0) dp[i][j] = 0;\n }\n }\n \n int res = 0;\n \n for(int i=1;i<=n;i++){\n for(int j=1;j<=m;j++){\n if(nums1[i-1] == nums2[j-1]){\n dp[i][j] = 1 + dp[i-1][j-1];\n res = max(res, dp[i][j]);\n }else{\n dp[i][j] = 0;\n }\n }\n }\n \n return res;\n }\n};\n" }, { "path": "718. Maximum Length of Repeated Subarray lc med s20.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n int findLength(vector& nums1, vector& nums2) {\n // dp space optmized\n int n = nums1.size(), m = nums2.size(), res = 0;\n// swap to ensure n >m\n if(n dp(n+1), dp2(n+1);\n for(int i = 1; i<=n; i++){\n for(int j =1; j<=m; j++){\n if(nums1[i-1] == nums2[j-1]){\n// extend from the prev dp state\n dp[j] = dp2[j-1]+1;\n \n }else\n// reset to 0\n dp[j] =0;\n// record the max len\n res = max(res, dp[j]);\n }\n// the curr state now becomes the prev state for nxt round\n dp2 = dp;\n \n }\n return res;\n }\n};" }, { "path": "724-find-pivot-index/724-find-pivot-index.java", "content": "class Solution {\n public int pivotIndex(int[] nums) {\n int sum=0;\n for(int n:nums){\n sum+=n;\n }\n int left=0;\n for(int i=0;i724. Find Pivot Index

Easy

Given an array of integers nums, calculate the pivot index of this array.

\n\n

The pivot index is the index where the sum of all the numbers strictly to the left of the index is equal to the sum of all the numbers strictly to the index's right.

\n\n

If the index is on the left edge of the array, then the left sum is 0 because there are no elements to the left. This also applies to the right edge of the array.

\n\n

Return the leftmost pivot index. If no such index exists, return -1.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,7,3,6,5,6]\nOutput: 3\nExplanation:\nThe pivot index is 3.\nLeft sum = nums[0] + nums[1] + nums[2] = 1 + 7 + 3 = 11\nRight sum = nums[4] + nums[5] = 5 + 6 = 11\n
\n\n

Example 2:

\n\n
Input: nums = [1,2,3]\nOutput: -1\nExplanation:\nThere is no index that satisfies the conditions in the problem statement.
\n\n

Example 3:

\n\n
Input: nums = [2,1,-1]\nOutput: 0\nExplanation:\nThe pivot index is 0.\nLeft sum = 0 (no elements to the left of index 0)\nRight sum = nums[1] + nums[2] = 1 + -1 = 0\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 104
    • \n\t
  • -1000 <= nums[i] <= 1000
    • \n
\n\n

 

\n

Note: This question is the same as 1991: https://leetcode.com/problems/find-the-middle-index-in-array/

\n
" }, { "path": "729-my-calendar-i/729-my-calendar-i.java", "content": "class MyCalendar {\n\n class TreeNode{\n TreeNode left;\n TreeNode right;\n int start;\n int end;\n TreeNode(int start,int end){\n this.start = start;\n this.end = end;\n }\n }\n TreeNode root;\n public MyCalendar() {\n \n }\n \n public boolean book(int start, int end) {\n if(root == null){\n root = new TreeNode(start,end);\n return true;\n }\n return insert(root,start,end);\n }\n \n private boolean insert(TreeNode root, int start, int end){\n if(end <= root.start){\n if(root.left == null){\n root.left = new TreeNode(start,end);\n return true;\n }\n return insert(root.left,start,end);\n }\n if(start >= root.end){\n if(root.right == null){\n root.right = new TreeNode(start,end);\n return true;\n }\n return insert(root.right,start,end);\n }\n return false;\n }\n}" }, { "path": "729-my-calendar-i/NOTES.md", "content": "25-31\n33-40\n47-49\n​" }, { "path": "729-my-calendar-i/README.md", "content": "

729. My Calendar I

Medium

You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a double booking.

\n\n

A double booking happens when two events have some non-empty intersection (i.e., some moment is common to both events.).

\n\n

The event can be represented as a pair of integers start and end that represents a booking on the half-open interval [start, end), the range of real numbers x such that start <= x < end.

\n\n

Implement the MyCalendar class:

\n\n
    \n\t
  • MyCalendar() Initializes the calendar object.
    • \n\t
  • boolean book(int start, int end) Returns true if the event can be added to the calendar successfully without causing a double booking. Otherwise, return false and do not add the event to the calendar.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"MyCalendar\", \"book\", \"book\", \"book\"]\n[[], [10, 20], [15, 25], [20, 30]]\nOutput\n[null, true, false, true]\n\nExplanation\nMyCalendar myCalendar = new MyCalendar();\nmyCalendar.book(10, 20); // return True\nmyCalendar.book(15, 25); // return False, It can not be booked because time 15 is already booked by another event.\nmyCalendar.book(20, 30); // return True, The event can be booked, as the first event takes every time less than 20, but not including 20.
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= start < end <= 109
    • \n\t
  • At most 1000 calls will be made to book.
    • \n
\n
" }, { "path": "732-my-calendar-iii/732-my-calendar-iii.java", "content": "class MyCalendarThree {\n private Map diff;\n\n public MyCalendarThree() {\n diff = new TreeMap<>();\n }\n\n public int book(int start, int end) {\n diff.put(start, diff.getOrDefault(start, 0) + 1);\n diff.put(end, diff.getOrDefault(end, 0) - 1);\n int res = 0, cur = 0;\n for (int delta : diff.values()) {\n cur += delta;\n res = Math.max(res, cur);\n }\n return res;\n }\n}" }, { "path": "732-my-calendar-iii/NOTES.md", "content": "​" }, { "path": "732-my-calendar-iii/README.md", "content": "

732. My Calendar III

Hard

A k-booking happens when k events have some non-empty intersection (i.e., there is some time that is common to all k events.)

\n\n

You are given some events [start, end), after each given event, return an integer k representing the maximum k-booking between all the previous events.

\n\n

Implement the MyCalendarThree class:

\n\n
    \n\t
  • MyCalendarThree() Initializes the object.
    • \n\t
  • int book(int start, int end) Returns an integer k representing the largest integer such that there exists a k-booking in the calendar.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"MyCalendarThree\", \"book\", \"book\", \"book\", \"book\", \"book\", \"book\"]\n[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]\nOutput\n[null, 1, 1, 2, 3, 3, 3]\n\nExplanation\nMyCalendarThree myCalendarThree = new MyCalendarThree();\nmyCalendarThree.book(10, 20); // return 1, The first event can be booked and is disjoint, so the maximum k-booking is a 1-booking.\nmyCalendarThree.book(50, 60); // return 1, The second event can be booked and is disjoint, so the maximum k-booking is a 1-booking.\nmyCalendarThree.book(10, 40); // return 2, The third event [10, 40) intersects the first event, and the maximum k-booking is a 2-booking.\nmyCalendarThree.book(5, 15); // return 3, The remaining events cause the maximum K-booking to be only a 3-booking.\nmyCalendarThree.book(5, 10); // return 3\nmyCalendarThree.book(25, 55); // return 3\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= start < end <= 109
    • \n\t
  • At most 400 calls will be made to book.
    • \n
\n
" }, { "path": "74-search-a-2d-matrix/74-search-a-2d-matrix.java", "content": "class Solution {\n int x;\n public boolean searchMatrix(int[][] matrix, int target) {\n x=target;\n int i=0;\n int n=matrix.length;\n int m=matrix[0].length;\n while(i=x){\n return binarySearch(matrix,i);\n }else{\n i++;\n }\n }\n return false;\n }\n public boolean binarySearch(int[][]matrix,int i){\n int[]a=matrix[i];\n int l=0;\n int h=a.length;\n while(l<=h){\n int mid=(l+h)/2;\n if(a[mid]==x){\n return true;\n }else if(a[mid]74. Search a 2D Matrix

Medium

Write an efficient algorithm that searches for a value target in an m x n integer matrix matrix. This matrix has the following properties:

\n\n
    \n\t
  • Integers in each row are sorted from left to right.
    • \n\t
  • The first integer of each row is greater than the last integer of the previous row.
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13\nOutput: false\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == matrix.length
    • \n\t
  • n == matrix[i].length
    • \n\t
  • 1 <= m, n <= 100
    • \n\t
  • -104 <= matrix[i][j], target <= 104
    • \n
\n
" }, { "path": "743-network-delay-time/743-network-delay-time.java", "content": "class Solution {\n public int networkDelayTime(int[][] times, int n, int k) {\n final int INF = Integer.MAX_VALUE/2;\n \n int[][] graph = new int[n][n];\n for(int i = 0; i < n; i++){\n Arrays.fill(graph[i], INF);\n }\n for(int t[] : times){\n int x = t[0] - 1, y = t[1] - 1;\n graph[x][y] = t[2];\n }\n int[] dist = new int[n];\n Arrays.fill(dist, INF);\n boolean[] visted = new boolean[n];\n dist[k-1] = 0;\n \n for(int i = 0; i < n; i++){\n int x = -1;\n for(int y = 0; y < n; y++){\n if(!visted[y] && (x == -1 || dist[y] < dist[x]))\n x = y;\n }\n visted[x] = true;\n for(int y = 0; y < n; y++){\n dist[y] = Math.min(dist[y], dist[x]+graph[x][y]);\n }\n }\n \n int ans = 0;\n for (int i = 0; i < n; i++) {\n ans = Math.max(ans, dist[i]);\n }\n \n return ans == INF ? -1 : ans;\n\n }\n}" }, { "path": "743-network-delay-time/NOTES.md", "content": "​" }, { "path": "743-network-delay-time/README.md", "content": "

743. Network Delay Time

Medium

You are given a network of n nodes, labeled from 1 to n. You are also given times, a list of travel times as directed edges times[i] = (ui, vi, wi), where ui is the source node, vi is the target node, and wi is the time it takes for a signal to travel from source to target.

\n\n

We will send a signal from a given node k. Return the time it takes for all the n nodes to receive the signal. If it is impossible for all the n nodes to receive the signal, return -1.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2\nOutput: 2\n
\n\n

Example 2:

\n\n
Input: times = [[1,2,1]], n = 2, k = 1\nOutput: 1\n
\n\n

Example 3:

\n\n
Input: times = [[1,2,1]], n = 2, k = 2\nOutput: -1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= k <= n <= 100
    • \n\t
  • 1 <= times.length <= 6000
    • \n\t
  • times[i].length == 3
    • \n\t
  • 1 <= ui, vi <= n
    • \n\t
  • ui != vi
    • \n\t
  • 0 <= wi <= 100
    • \n\t
  • All the pairs (ui, vi) are unique. (i.e., no multiple edges.)
    • \n
\n
" }, { "path": "745-prefix-and-suffix-search/745-prefix-and-suffix-search.java", "content": "class WordFilter {\n TrieNode trie;\n public WordFilter(String[] words) {\n trie = new TrieNode();\n for (int weight = 0; weight < words.length; ++weight) {\n String word = words[weight] + \"{\";\n for (int i = 0; i < word.length(); ++i) {\n TrieNode cur = trie;\n cur.weight = weight;\n for (int j = i; j < 2 * word.length() - 1; ++j) {\n int k = word.charAt(j % word.length()) - 'a';\n if (cur.children[k] == null)\n cur.children[k] = new TrieNode();\n cur = cur.children[k];\n cur.weight = weight;\n }\n }\n }\n }\n public int f(String prefix, String suffix) {\n TrieNode cur = trie;\n for (char letter: (suffix + '{' + prefix).toCharArray()) {\n if (cur.children[letter - 'a'] == null) return -1;\n cur = cur.children[letter - 'a'];\n }\n return cur.weight;\n }\n}\n\nclass TrieNode {\n TrieNode[] children;\n int weight;\n public TrieNode() {\n children = new TrieNode[27];\n weight = 0;\n }\n}" }, { "path": "745-prefix-and-suffix-search/NOTES.md", "content": "​" }, { "path": "745-prefix-and-suffix-search/README.md", "content": "

745. Prefix and Suffix Search

Hard

Design a special dictionary with some words that searchs the words in it by a prefix and a suffix.

\n\n

Implement the WordFilter class:

\n\n
    \n\t
  • WordFilter(string[] words) Initializes the object with the words in the dictionary.
    • \n\t
  • f(string prefix, string suffix) Returns the index of the word in the dictionary, which has the prefix prefix and the suffix suffix. If there is more than one valid index, return the largest of them. If there is no such word in the dictionary, return -1.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"WordFilter\", \"f\"]\n[[[\"apple\"]], [\"a\", \"e\"]]\nOutput\n[null, 0]\n\nExplanation\nWordFilter wordFilter = new WordFilter([\"apple\"]);\nwordFilter.f(\"a\", \"e\"); // return 0, because the word at index 0 has prefix = \"a\" and suffix = 'e\".\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words.length <= 15000
    • \n\t
  • 1 <= words[i].length <= 10
    • \n\t
  • 1 <= prefix.length, suffix.length <= 10
    • \n\t
  • words[i], prefix and suffix consist of lower-case English letters only.
    • \n\t
  • At most 15000 calls will be made to the function f.
    • \n
\n
" }, { "path": "746-min-cost-climbing-stairs/746-min-cost-climbing-stairs.java", "content": "class Solution {\n public int minCostClimbingStairs(int[] cost) {\n int[] mem = new int[cost.length];\n mem[0]=cost[0];\n mem[1]=cost[1];\n for(int i=2;i746. Min Cost Climbing Stairs

Easy

You are given an integer array cost where cost[i] is the cost of ith step on a staircase. Once you pay the cost, you can either climb one or two steps.

\n\n

You can either start from the step with index 0, or the step with index 1.

\n\n

Return the minimum cost to reach the top of the floor.

\n\n

 

\n

Example 1:

\n\n
Input: cost = [10,15,20]\nOutput: 15\nExplanation: You will start at index 1.\n- Pay 15 and climb two steps to reach the top.\nThe total cost is 15.\n
\n\n

Example 2:

\n\n
Input: cost = [1,100,1,1,1,100,1,1,100,1]\nOutput: 6\nExplanation: You will start at index 0.\n- Pay 1 and climb two steps to reach index 2.\n- Pay 1 and climb two steps to reach index 4.\n- Pay 1 and climb two steps to reach index 6.\n- Pay 1 and climb one step to reach index 7.\n- Pay 1 and climb two steps to reach index 9.\n- Pay 1 and climb one step to reach the top.\nThe total cost is 6.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= cost.length <= 1000
    • \n\t
  • 0 <= cost[i] <= 999
    • \n
\n
" }, { "path": "76-minimum-window-substring/76-minimum-window-substring.java", "content": "class Solution {\n public String minWindow(String s, String t) {\n int[] cs = new int[256];\n for (char ch : t.toCharArray()) {\n cs[ch]++;\n }\n int l = 0, r = 0, cnt = t.length();\n int start = -1, end = s.length(); // substring [start, end)\n while (r < s.length()) {\n if (cs[s.charAt(r++)]-- > 0) {\n cnt--;\n }\n while (cnt == 0) {\n if (cs[s.charAt(l++)]++ == 0) {\n cnt++;\n }\n if (r - l + 1 < end - start) {\n start = l - 1;\n end = r;\n }\n }\n }\n return end - start > s.length() ? \"\" : s.substring(start, end);\n }\n}" }, { "path": "76-minimum-window-substring/NOTES.md", "content": "​" }, { "path": "76-minimum-window-substring/README.md", "content": "

76. Minimum Window Substring

Hard

Given two strings s and t of lengths m and n respectively, return the minimum window substring of s such that every character in t (including duplicates) is included in the window. If there is no such substring, return the empty string \"\".

\n\n

The testcases will be generated such that the answer is unique.

\n\n

A substring is a contiguous sequence of characters within the string.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"ADOBECODEBANC\", t = \"ABC\"\nOutput: \"BANC\"\nExplanation: The minimum window substring \"BANC\" includes 'A', 'B', and 'C' from string t.\n
\n\n

Example 2:

\n\n
Input: s = \"a\", t = \"a\"\nOutput: \"a\"\nExplanation: The entire string s is the minimum window.\n
\n\n

Example 3:

\n\n
Input: s = \"a\", t = \"aa\"\nOutput: \"\"\nExplanation: Both 'a's from t must be included in the window.\nSince the largest window of s only has one 'a', return empty string.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == s.length
    • \n\t
  • n == t.length
    • \n\t
  • 1 <= m, n <= 105
    • \n\t
  • s and t consist of uppercase and lowercase English letters.
    • \n
\n\n

 

\nFollow up: Could you find an algorithm that runs in O(m + n) time?
" }, { "path": "763-partition-labels/763-partition-labels.java", "content": "class Solution {\n public List partitionLabels(String s) {\n List ans = new ArrayList<>();\n int[] lastIndex = new int[26];\n for (int i = 0; i < 26; i++) {\n lastIndex[i] = s.lastIndexOf('a' + i);\n }\n int left = 0;\n int right;\n while (left < s.length()) {\n right = lastIndex[s.charAt(left) - 'a'];\n for (int i = left; i < right; i++) {\n right = Math.max(right, lastIndex[s.charAt(i) - 'a']);\n }\n ans.add(right - left + 1); // size: right -left + 1\n left = right + 1;\n }\n return ans;\n }\n}" }, { "path": "763-partition-labels/NOTES.md", "content": "​" }, { "path": "763-partition-labels/README.md", "content": "

763. Partition Labels

Medium

You are given a string s. We want to partition the string into as many parts as possible so that each letter appears in at most one part.

\n\n

Note that the partition is done so that after concatenating all the parts in order, the resultant string should be s.

\n\n

Return a list of integers representing the size of these parts.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"ababcbacadefegdehijhklij\"\nOutput: [9,7,8]\nExplanation:\nThe partition is \"ababcbaca\", \"defegde\", \"hijhklij\".\nThis is a partition so that each letter appears in at most one part.\nA partition like \"ababcbacadefegde\", \"hijhklij\" is incorrect, because it splits s into less parts.\n
\n\n

Example 2:

\n\n
Input: s = \"eccbbbbdec\"\nOutput: [10]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 500
    • \n\t
  • s consists of lowercase English letters.
    • \n
\n
" }, { "path": "785-is-graph-bipartite/785-is-graph-bipartite.java", "content": "class Solution {\n public boolean isBipartite(int[][] graph) {\n boolean[]vis=new boolean[100];\n boolean[]color=new boolean[100];\n Queue q=new LinkedList<>();\n for(int i=0;i785. Is Graph Bipartite?

Medium

There is an undirected graph with n nodes, where each node is numbered between 0 and n - 1. You are given a 2D array graph, where graph[u] is an array of nodes that node u is adjacent to. More formally, for each v in graph[u], there is an undirected edge between node u and node v. The graph has the following properties:

\n\n
    \n\t
  • There are no self-edges (graph[u] does not contain u).
    • \n\t
  • There are no parallel edges (graph[u] does not contain duplicate values).
    • \n\t
  • If v is in graph[u], then u is in graph[v] (the graph is undirected).
    • \n\t
  • The graph may not be connected, meaning there may be two nodes u and v such that there is no path between them.
    • \n
\n\n

A graph is bipartite if the nodes can be partitioned into two independent sets A and B such that every edge in the graph connects a node in set A and a node in set B.

\n\n

Return true if and only if it is bipartite.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: graph = [[1,2,3],[0,2],[0,1,3],[0,2]]\nOutput: false\nExplanation: There is no way to partition the nodes into two independent sets such that every edge connects a node in one and a node in the other.
\n\n

Example 2:

\n\"\"\n
Input: graph = [[1,3],[0,2],[1,3],[0,2]]\nOutput: true\nExplanation: We can partition the nodes into two sets: {0, 2} and {1, 3}.
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • graph.length == n
    • \n\t
  • 1 <= n <= 100
    • \n\t
  • 0 <= graph[u].length < n
    • \n\t
  • 0 <= graph[u][i] <= n - 1
    • \n\t
  • graph[u] does not contain u.
    • \n\t
  • All the values of graph[u] are unique.
    • \n\t
  • If graph[u] contains v, then graph[v] contains u.
    • \n
\n
" }, { "path": "791-Custom-Sort-String-Leetcode.cpp", "content": "class Solution {\npublic:\n string customSortString(string order, string s) \n {\n unordered_mapmp;\n for(auto it:s)\n mp[it]++;\n \n string ans=\"\";\n for(int i=0;i map = new HashMap<>();\n for(String str:words){\n map.put(str,map.getOrDefault(str,0)+1);\n }\n \n int ans = 0;\n char ch[] = s.toCharArray();\n \n for(String str:map.keySet()){\n \n char temp[] = str.toCharArray();\n int i = 0;\n int j = 0;\n \n while(i792. Number of Matching Subsequences

Medium

Given a string s and an array of strings words, return the number of words[i] that is a subsequence of s.

\n\n

A subsequence of a string is a new string generated from the original string with some characters (can be none) deleted without changing the relative order of the remaining characters.

\n\n
    \n\t
  • For example, \"ace\" is a subsequence of \"abcde\".
    • \n
\n\n

 

\n

Example 1:

\n\n
Input: s = \"abcde\", words = [\"a\",\"bb\",\"acd\",\"ace\"]\nOutput: 3\nExplanation: There are three strings in words that are a subsequence of s: \"a\", \"acd\", \"ace\".\n
\n\n

Example 2:

\n\n
Input: s = \"dsahjpjauf\", words = [\"ahjpjau\",\"ja\",\"ahbwzgqnuk\",\"tnmlanowax\"]\nOutput: 2\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 5 * 104
    • \n\t
  • 1 <= words.length <= 5000
    • \n\t
  • 1 <= words[i].length <= 50
    • \n\t
  • s and words[i] consist of only lowercase English letters.
    • \n
\n
" }, { "path": "802. Find Eventual Safe States.java", "content": "class Solution {\n public List eventualSafeNodes(int[][] graph) {\n int n=graph.length;\n List> adj=new ArrayList<>();\n \n for(int i=0;i list=new ArrayList<>();\n adj.add(list);\n }\n \n for(int i=0;i ans=new ArrayList<>();\n \n for(int i=0;i> adj,int node,int[] vis,int[] dfsVis,int[] check){\n vis[node]=1;\n dfsVis[node]=1;\n \n for(int e:adj.get(node)){\n if(vis[e]==0){\n if(dfs(adj,e,vis,dfsVis,check)){\n check[node]=0;\n return true;\n }\n }\n if(dfsVis[e]==1){\n check[node]=0;\n return true;\n }\n }\n dfsVis[node]=0;\n check[node]=1;\n return false;\n }\n}\n" }, { "path": "804-unique-morse-code-words/804-unique-morse-code-words.java", "content": "class Solution {\n //gou\n public int uniqueMorseRepresentations(String[] words) {\n\n String[] MORSE = new String[]{\n \".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\n \"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\"-.\",\n \"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\n \"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"};\n \n Set uniqueSet = new HashSet<>();\n for (String word : words) {\n uniqueSet.add(convertToMorseStr(MORSE, word));\n }\n \n return uniqueSet.size();\n }\n \n private String convertToMorseStr(String[] MORSE, String word) {\n StringBuilder sb = new StringBuilder();\n for (int i = 0; i < word.length(); i++) {\n sb.append(MORSE[word.charAt(i)-'a']);\n }\n return sb.toString();\n }\n \n \n}" }, { "path": "804-unique-morse-code-words/NOTES.md", "content": "​" }, { "path": "804-unique-morse-code-words/README.md", "content": "

804. Unique Morse Code Words

Easy

International Morse Code defines a standard encoding where each letter is mapped to a series of dots and dashes, as follows:

\n\n
    \n\t
  • 'a' maps to \".-\",
    • \n\t
  • 'b' maps to \"-...\",
    • \n\t
  • 'c' maps to \"-.-.\", and so on.
    • \n
\n\n

For convenience, the full table for the 26 letters of the English alphabet is given below:

\n\n
[\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\"-.\",\"---\",\".--.\",\"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"]
\n\n

Given an array of strings words where each word can be written as a concatenation of the Morse code of each letter.

\n\n
    \n\t
  • For example, \"cab\" can be written as \"-.-..--...\", which is the concatenation of \"-.-.\", \".-\", and \"-...\". We will call such a concatenation the transformation of a word.
    • \n
\n\n

Return the number of different transformations among all words we have.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"gin\",\"zen\",\"gig\",\"msg\"]\nOutput: 2\nExplanation: The transformation of each word is:\n\"gin\" -> \"--...-.\"\n\"zen\" -> \"--...-.\"\n\"gig\" -> \"--...--.\"\n\"msg\" -> \"--...--.\"\nThere are 2 different transformations: \"--...-.\" and \"--...--.\".\n
\n\n

Example 2:

\n\n
Input: words = [\"a\"]\nOutput: 1\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words.length <= 100
    • \n\t
  • 1 <= words[i].length <= 12
    • \n\t
  • words[i] consists of lowercase English letters.
    • \n
\n
" }, { "path": "804-unique-morse-code-words/unique-morse-code.cpp", "content": "class Solution {\npublic:\n int uniqueMorseRepresentations(vector& words) {\n \n vector morse = {\".-\",\"-...\",\"-.-.\",\"-..\",\".\",\"..-.\",\n \"--.\",\"....\",\"..\",\".---\",\"-.-\",\".-..\",\"--\",\"-.\",\"---\",\".--.\",\n \"--.-\",\".-.\",\"...\",\"-\",\"..-\",\"...-\",\".--\",\"-..-\",\"-.--\",\"--..\"};\n \n unordered_set s;\n \n for(int i = 0; i < words.size(); i++){\n string str = words[i];\n string morseCode = \"\";\n for(int j = 0; j < str.length(); j++){\n morseCode += morse[str[j] - 'a'];\n }\n s.insert(morseCode);\n }\n return s.size();\n }\n};\n" }, { "path": "81-search-in-rotated-sorted-array-ii/81-search-in-rotated-sorted-array-ii.java", "content": "class Solution {\n public boolean search(int[] nums, int target) {\n int left=0;\n int right=nums.length-1;\n while(left<=right){\n int mid=(left+right)/2;\n if(nums[mid]==target){\n return true;\n }\n //case: when all left right and mid are same\n else if(nums[left]==nums[mid] && nums[right]==nums[mid]){\n left++;\n right--;\n }\n //case: when mid is on higher level\n else if(nums[left]<=nums[mid]){\n //when left to mid is increasing\n if(nums[left]<=target && nums[mid]>target){\n right=mid-1;\n }else{\n left=mid+1;\n }\n }\n //case: when mid is smaller than left\n else{\n //when mid to right is increasing\n if(nums[mid]=target){\n left=mid+1;\n }else{\n right=mid-1;\n }\n }\n }\n return false;\n }\n}\n" }, { "path": "81-search-in-rotated-sorted-array-ii/NOTES.md", "content": "​" }, { "path": "81-search-in-rotated-sorted-array-ii/README.md", "content": "

81. Search in Rotated Sorted Array II

Medium

There is an integer array nums sorted in non-decreasing order (not necessarily with distinct values).

\n\n

Before being passed to your function, nums is rotated at an unknown pivot index k (0 <= k < nums.length) such that the resulting array is [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]] (0-indexed). For example, [0,1,2,4,4,4,5,6,6,7] might be rotated at pivot index 5 and become [4,5,6,6,7,0,1,2,4,4].

\n\n

Given the array nums after the rotation and an integer target, return true if target is in nums, or false if it is not in nums.

\n\n

You must decrease the overall operation steps as much as possible.

\n\n

 

\n

Example 1:

\n
Input: nums = [2,5,6,0,0,1,2], target = 0\nOutput: true\n

Example 2:

\n
Input: nums = [2,5,6,0,0,1,2], target = 3\nOutput: false\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 5000
    • \n\t
  • -104 <= nums[i] <= 104
    • \n\t
  • nums is guaranteed to be rotated at some pivot.
    • \n\t
  • -104 <= target <= 104
    • \n
\n\n

 

\n

Follow up: This problem is similar to Search in Rotated Sorted Array, but nums may contain duplicates. Would this affect the runtime complexity? How and why?

\n
" }, { "path": "814-binary-tree-pruning/814-binary-tree-pruning.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n Mapmap;\n boolean del;\n public TreeNode pruneTree(TreeNode root) {\n map=new HashMap<>();\n int sum=root.val+sum(root.right)+sum(root.left);\n if(sum==0){\n return null;\n }\n dfs(root);\n return root;\n }\n void dfs(TreeNode root){\n if(root==null)return;\n if(sum(root.left)==0){\n root.left=null;\n }\n if(sum(root.right)==0){\n root.right=null;\n }\n dfs(root.left);\n dfs(root.right);\n }\n int sum(TreeNode root){\n if(root==null)return 0;\n if(map.containsKey(root))return map.get(root);\n int sum=root.val+sum(root.left)+sum(root.right);\n map.putIfAbsent(root,sum);\n return sum;\n }\n \n}\n\n\nApproach-2 BY @Jay-Thesia\n\nclass Solution {\n public TreeNode pruneTree(TreeNode root) {\n \n return helper(root)?null:root;\n }\n \n public boolean helper(TreeNode root){\n \n if(root==null)\n return true;\n \n boolean left=helper(root.left);\n boolean right=helper(root.right);\n \n if(left)\n root.left=null;\n if(right)\n root.right=null;\n \n return root.val==0 && left && right;\n }\n}\n" }, { "path": "814-binary-tree-pruning/README.md", "content": "

814. Binary Tree Pruning

Medium

Given the root of a binary tree, return the same tree where every subtree (of the given tree) not containing a 1 has been removed.

\n\n

A subtree of a node node is node plus every node that is a descendant of node.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,null,0,0,1]\nOutput: [1,null,0,null,1]\nExplanation: \nOnly the red nodes satisfy the property \"every subtree not containing a 1\".\nThe diagram on the right represents the answer.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [1,0,1,0,0,0,1]\nOutput: [1,null,1,null,1]\n
\n\n

Example 3:

\n\"\"\n
Input: root = [1,1,0,1,1,0,1,0]\nOutput: [1,1,0,1,1,null,1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 200].
    • \n\t
  • Node.val is either 0 or 1.
    • \n
\n
" }, { "path": "82-remove-duplicates-from-sorted-list-ii/82-remove-duplicates-from-sorted-list-ii.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\npublic class Solution {\n public ListNode deleteDuplicates(ListNode A) {\n ListNode head=null;\n ListNode curr=null;\n ListNode temp=A;\n while(temp!=null){\n if(temp.next!=null){\n int value=temp.val;\n if(temp.next.val==value){\n while(temp!=null && temp.val==value){\n temp=temp.next;\n }\n }else{\n if(head==null){\n head=temp;\n curr=temp;\n }else{\n curr.next=temp;\n curr=curr.next;\n }\n temp=temp.next;\n curr.next=null;\n }\n }else{\n if(head==null){\n head=temp;\n curr=temp;\n }else{\n curr.next=temp;\n curr=curr.next;\n }\n temp=temp.next;\n curr.next=null;\n }\n }\n return head;\n }\n}\n" }, { "path": "82-remove-duplicates-from-sorted-list-ii/NOTES.md", "content": "​" }, { "path": "82-remove-duplicates-from-sorted-list-ii/README.md", "content": "

82. Remove Duplicates from Sorted List II

Medium

Given the head of a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list. Return the linked list sorted as well.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,3,3,4,4,5]\nOutput: [1,2,5]\n
\n\n

Example 2:

\n\"\"\n
Input: head = [1,1,1,2,3]\nOutput: [2,3]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is in the range [0, 300].
    • \n\t
  • -100 <= Node.val <= 100
    • \n\t
  • The list is guaranteed to be sorted in ascending order.
    • \n
\n
" }, { "path": "820-short-encoding-of-words/820-short-encoding-of-words.java", "content": "class Solution {\n public int minimumLengthEncoding(String[] words) {\n Trie trie = new Trie();\n int sum = 0;\n Arrays.sort(words, (s1, s2) -> s2.length() - s1.length());\n for (String word : words) {\n boolean isNew = trie.insert(word);\n if (isNew) {\n sum += word.length() + 1;\n }\n }\n return sum;\n }\n}\n\n// 定义tire\nclass Trie {\n \n TrieNode root;\n \n public Trie() {\n root = new TrieNode();\n }\n\n public boolean insert(String word) {\n boolean isNew = false;\n TrieNode node = root;\n for (int i = word.length() - 1; i >= 0; --i) {\n int index = word.charAt(i) - 'a';\n if (node.children[index] == null) {\n isNew = true;\n node.children[index] = new TrieNode();\n }\n node = node.children[index];\n }\n return isNew;\n }\n}\n\nclass TrieNode {\n TrieNode[] children = new TrieNode[26];\n\n public TrieNode() {}\n}" }, { "path": "820-short-encoding-of-words/NOTES.md", "content": "​" }, { "path": "820-short-encoding-of-words/README.md", "content": "

820. Short Encoding of Words

Medium

A valid encoding of an array of words is any reference string s and array of indices indices such that:

\n\n
    \n\t
  • words.length == indices.length
    • \n\t
  • The reference string s ends with the '#' character.
    • \n\t
  • For each index indices[i], the substring of s starting from indices[i] and up to (but not including) the next '#' character is equal to words[i].
    • \n
\n\n

Given an array of words, return the length of the shortest reference string s possible of any valid encoding of words.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"time\", \"me\", \"bell\"]\nOutput: 10\nExplanation: A valid encoding would be s = \"time#bell#\" and indices = [0, 2, 5].\nwords[0] = \"time\", the substring of s starting from indices[0] = 0 to the next '#' is underlined in \"time#bell#\"\nwords[1] = \"me\", the substring of s starting from indices[1] = 2 to the next '#' is underlined in \"time#bell#\"\nwords[2] = \"bell\", the substring of s starting from indices[2] = 5 to the next '#' is underlined in \"time#bell#\"\n
\n\n

Example 2:

\n\n
Input: words = [\"t\"]\nOutput: 2\nExplanation: A valid encoding would be s = \"t#\" and indices = [0].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words.length <= 2000
    • \n\t
  • 1 <= words[i].length <= 7
    • \n\t
  • words[i] consists of only lowercase letters.
    • \n
\n
" }, { "path": "823-binary-trees-with-factors/823-binary-trees-with-factors.java", "content": "class Solution {\n public int numFactoredBinaryTrees(int[] arr) {\n Arrays.sort(arr);\n int n = arr.length, mod = 1_000_000_007;\n long[] dp = new long[n];\n long res = 0;\n Map idxs = new HashMap();\n for (int i = 0; i < n; i++) {\n dp[i] = 1;\n for (int j = 0; j < i; j++) {\n if (arr[j]*arr[j] > arr[i]) break;\n if (arr[i] % arr[j] == 0 && idxs.containsKey(arr[i]/arr[j])) {\n if (arr[j]*arr[j] == arr[i]) {\n dp[i] += dp[j]*dp[j];\n dp[i] %= mod;\n }\n else {\n dp[i] += 2*dp[j]*dp[idxs.get(arr[i]/arr[j])];\n dp[i] %= mod;\n }\n }\n }\n idxs.put(arr[i], i);\n res += dp[i];\n res %= mod;\n }\n return (int) res;\n }\n}" }, { "path": "823-binary-trees-with-factors/NOTES.md", "content": "​" }, { "path": "823-binary-trees-with-factors/README.md", "content": "

823. Binary Trees With Factors

Medium

Given an array of unique integers, arr, where each integer arr[i] is strictly greater than 1.

\n\n

We make a binary tree using these integers, and each number may be used for any number of times. Each non-leaf node's value should be equal to the product of the values of its children.

\n\n

Return the number of binary trees we can make. The answer may be too large so return the answer modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: arr = [2,4]\nOutput: 3\nExplanation: We can make these trees: [2], [4], [4, 2, 2]
\n\n

Example 2:

\n\n
Input: arr = [2,4,5,10]\nOutput: 7\nExplanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= arr.length <= 1000
    • \n\t
  • 2 <= arr[i] <= 109
    • \n\t
  • All the values of arr are unique.
    • \n
\n
" }, { "path": "838-push-dominoes/838-push-dominoes.java", "content": "class Solution {\n public String pushDominoes(String dominoes) {\n int n = dominoes.length();\n char[] dArray = dominoes.toCharArray();\n char start = '.';\n char last = '.';\n int stidx = 0;\n int i = 0;\n while(i0){\n if(start=='R' && last=='L'){\n int l = stidx;\n int r = i-1;\n while(l=stidx){\n dArray[l]='L';\n l--;\n }\n }\n else if(start=='R'){\n int r = stidx;\n while(r838. Push Dominoes

Medium

There are n dominoes in a line, and we place each domino vertically upright. In the beginning, we simultaneously push some of the dominoes either to the left or to the right.

\n\n

After each second, each domino that is falling to the left pushes the adjacent domino on the left. Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right.

\n\n

When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces.

\n\n

For the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino.

\n\n

You are given a string dominoes representing the initial state where:

\n\n
    \n\t
  • dominoes[i] = 'L', if the ith domino has been pushed to the left,
    • \n\t
  • dominoes[i] = 'R', if the ith domino has been pushed to the right, and
    • \n\t
  • dominoes[i] = '.', if the ith domino has not been pushed.
    • \n
\n\n

Return a string representing the final state.

\n\n

 

\n

Example 1:

\n\n
Input: dominoes = \"RR.L\"\nOutput: \"RR.L\"\nExplanation: The first domino expends no additional force on the second domino.\n
\n\n

Example 2:

\n\"\"\n
Input: dominoes = \".L.R...LR..L..\"\nOutput: \"LL.RR.LLRRLL..\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • n == dominoes.length
    • \n\t
  • 1 <= n <= 105
    • \n\t
  • dominoes[i] is either 'L', 'R', or '.'.
    • \n
\n
" }, { "path": "844-backspace-string-compare/844-backspace-string-compare.java", "content": "class Solution {\n public boolean backspaceCompare(String s, String t) {\n int sPointer = s.length() - 1;\n int tPointer = t.length() - 1;\n \n while (sPointer >= 0 || tPointer >= 0) {\n sPointer = getNextCharacterPosition(s, sPointer); // can be negative, empty string;\n tPointer = getNextCharacterPosition(t, tPointer); // can be negative, empty string;\n \n if ((sPointer < 0 && tPointer >= 0) ||\n (tPointer < 0 && sPointer >= 0) ||\n (sPointer >= 0 && tPointer >= 0) && (s.charAt(sPointer) != t.charAt(tPointer))\n ) {\n return false;\n }\n \n sPointer--;\n tPointer--;\n }\n \n return true;\n }\n\n public int getNextCharacterPosition(String s, int start) {\n if (start < 0) {\n return start;\n }\n \n char c = s.charAt(start);\n int count = c == '#' ? 2 : 0;\n \n while (count > 0) {\n start--;\n \n if (start < 0) {\n start -= count;\n break;\n }\n \n c = s.charAt(start);\n \n if (c == '#') {\n count++;\n } else {\n count--;\n }\n }\n \n return start;\n }\n}" }, { "path": "844-backspace-string-compare/NOTES.md", "content": "​" }, { "path": "844-backspace-string-compare/README.md", "content": "

844. Backspace String Compare

Easy

Given two strings s and t, return true if they are equal when both are typed into empty text editors. '#' means a backspace character.

\n\n

Note that after backspacing an empty text, the text will continue empty.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"ab#c\", t = \"ad#c\"\nOutput: true\nExplanation: Both s and t become \"ac\".\n
\n\n

Example 2:

\n\n
Input: s = \"ab##\", t = \"c#d#\"\nOutput: true\nExplanation: Both s and t become \"\".\n
\n\n

Example 3:

\n\n
Input: s = \"a#c\", t = \"b\"\nOutput: false\nExplanation: s becomes \"c\" while t becomes \"b\".\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length, t.length <= 200
    • \n\t
  • s and t only contain lowercase letters and '#' characters.
    • \n
\n\n

 

\n

Follow up: Can you solve it in O(n) time and O(1) space?

\n
" }, { "path": "845_Longest_Mountain_in_Array.cpp", "content": "class Solution {\npublic:\n int longestMountain(vector& arr) {\n int ans = 0;\n for(int i =1;iarr[i+1]&&arr[i]>arr[i-1]){\n int x =i,y=i;\n while(x>0&&arr[x]>arr[x-1]){\n x--;\n }\n while(yarr[y+1]){\n y++;\n }\n ans = max(ans,y-x+1);\n i=y;\n }\n }\n return ans;\n }\n};\n" }, { "path": "856-score-of-parentheses/856-score-of-parentheses.java", "content": "class Solution {\n public int scoreOfParentheses(String S) {\n int ans = 0, bal = 0;\n for (int i = 0; i < S.length(); ++i) {\n if (S.charAt(i) == '(') {\n bal++;\n } else {\n bal--;\n if (S.charAt(i-1) == '(')\n ans += 1 << bal;\n }\n }\n return ans;\n }\n}" }, { "path": "856-score-of-parentheses/NOTES.md", "content": "​" }, { "path": "856-score-of-parentheses/README.md", "content": "

856. Score of Parentheses

Medium

Given a balanced parentheses string s, return the score of the string.

\n\n

The score of a balanced parentheses string is based on the following rule:

\n\n
    \n\t
  • \"()\" has score 1.
    • \n\t
  • AB has score A + B, where A and B are balanced parentheses strings.
    • \n\t
  • (A) has score 2 * A, where A is a balanced parentheses string.
    • \n
\n\n

 

\n

Example 1:

\n\n
Input: s = \"()\"\nOutput: 1\n
\n\n

Example 2:

\n\n
Input: s = \"(())\"\nOutput: 2\n
\n\n

Example 3:

\n\n
Input: s = \"()()\"\nOutput: 2\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= s.length <= 50
    • \n\t
  • s consists of only '(' and ')'.
    • \n\t
  • s is a balanced parentheses string.
    • \n
\n
" }, { "path": "86-partition-list/86-partition-list.java", "content": "/**\n * Definition for singly-linked list.\n * public class ListNode {\n * int val;\n * ListNode next;\n * ListNode() {}\n * ListNode(int val) { this.val = val; }\n * ListNode(int val, ListNode next) { this.val = val; this.next = next; }\n * }\n */\nclass Solution {\n public ListNode partition(ListNode head, int x) {\n ListNode temp=head;\n ListNode small=new ListNode(-1);\n ListNode smallEnd=small;\n ListNode large=new ListNode(-1);\n ListNode currLarge=large;\n while(temp!=null){\n ListNode curr=temp;\n temp=temp.next;\n curr.next=null;\n if(curr.val86. Partition List

Medium

Given the head of a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

\n\n

You should preserve the original relative order of the nodes in each of the two partitions.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,4,3,2,5,2], x = 3\nOutput: [1,2,2,4,3,5]\n
\n\n

Example 2:

\n\n
Input: head = [2,1], x = 2\nOutput: [1,2]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is in the range [0, 200].
    • \n\t
  • -100 <= Node.val <= 100
    • \n\t
  • -200 <= x <= 200
    • \n
\n
" }, { "path": "867-transpose-matrix/867-transpose-matrix.java", "content": "class Solution {\n public int[][] transpose(int[][] A) {\n int R = A.length, C = A[0].length;\n int[][] ans = new int[C][R];\n for (int r = 0; r < R; ++r)\n for (int c = 0; c < C; ++c) \n ans[c][r] = A[r][c];\n \n return ans;\n }\n}" }, { "path": "867-transpose-matrix/README.md", "content": "

867. Transpose Matrix

Easy

Given a 2D integer array matrix, return the transpose of matrix.

\n\n

The transpose of a matrix is the matrix flipped over its main diagonal, switching the matrix's row and column indices.

\n\n

\"\"

\n\n

 

\n

Example 1:

\n\n
Input: matrix = [[1,2,3],[4,5,6],[7,8,9]]\nOutput: [[1,4,7],[2,5,8],[3,6,9]]\n
\n\n

Example 2:

\n\n
Input: matrix = [[1,2,3],[4,5,6]]\nOutput: [[1,4],[2,5],[3,6]]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • m == matrix.length
    • \n\t
  • n == matrix[i].length
    • \n\t
  • 1 <= m, n <= 1000
    • \n\t
  • 1 <= m * n <= 105
    • \n\t
  • -109 <= matrix[i][j] <= 109
    • \n
\n
" }, { "path": "869-Reordered-Power-of-2/869-Reordered-Power-of-2.cpp", "content": "class Solution {\npublic:\n bool reorderedPowerOf2(int n) {\n string res = to_string(n);\n sort(res.begin(), res.end());\n for(int i =0; i<30; i++){\n string res1 = to_string(1<= stations[i][0] && stations[i][1] > curMax) {\n curMax = stations[i][1];\n curPos = i;\n }\n }\n if (curMax == 0) {\n break;\n }\n ans++;\n maxPos += curMax;\n stations[curPos][0] = Integer.MAX_VALUE;\n }\n return maxPos >= target ? ans : -1;\n }\n}" }, { "path": "871-minimum-number-of-refueling-stops/Minimum-Number-of-Refueling-Stops.cpp", "content": "class Solution {\npublic:\n int minRefuelStops(int target, int startFuel, vector>& stations) {\n priority_queue pq;\n stations.push_back({target, 0});\n int pumps=0;\n for(int i=0;i871. Minimum Number of Refueling Stops

Hard

A car travels from a starting position to a destination which is target miles east of the starting position.

\n\n

There are gas stations along the way. The gas stations are represented as an array stations where stations[i] = [positioni, fueli] indicates that the ith gas station is positioni miles east of the starting position and has fueli liters of gas.

\n\n

The car starts with an infinite tank of gas, which initially has startFuel liters of fuel in it. It uses one liter of gas per one mile that it drives. When the car reaches a gas station, it may stop and refuel, transferring all the gas from the station into the car.

\n\n

Return the minimum number of refueling stops the car must make in order to reach its destination. If it cannot reach the destination, return -1.

\n\n

Note that if the car reaches a gas station with 0 fuel left, the car can still refuel there. If the car reaches the destination with 0 fuel left, it is still considered to have arrived.

\n\n

 

\n

Example 1:

\n\n
Input: target = 1, startFuel = 1, stations = []\nOutput: 0\nExplanation: We can reach the target without refueling.\n
\n\n

Example 2:

\n\n
Input: target = 100, startFuel = 1, stations = [[10,100]]\nOutput: -1\nExplanation: We can not reach the target (or even the first gas station).\n
\n\n

Example 3:

\n\n
Input: target = 100, startFuel = 10, stations = [[10,60],[20,30],[30,30],[60,40]]\nOutput: 2\nExplanation: We start with 10 liters of fuel.\nWe drive to position 10, expending 10 liters of fuel.  We refuel from 0 liters to 60 liters of gas.\nThen, we drive from position 10 to position 60 (expending 50 liters of fuel),\nand refuel from 10 liters to 50 liters of gas.  We then drive to and reach the target.\nWe made 2 refueling stops along the way, so we return 2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= target, startFuel <= 109
    • \n\t
  • 0 <= stations.length <= 500
    • \n\t
  • 0 <= positioni <= positioni+1 < target
    • \n\t
  • 1 <= fueli < 109
    • \n
\n
" }, { "path": "871. Minimum Number of Refueling Stops.cpp", "content": " int minRefuelStops(int target, int sf, vector>& s) {\n priority_queuepq;\n int i=0,res;\n \n for(res=0;sf876. Middle of the Linked List

Easy

Given the head of a singly linked list, return the middle node of the linked list.

\n\n

If there are two middle nodes, return the second middle node.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,3,4,5]\nOutput: [3,4,5]\nExplanation: The middle node of the list is node 3.\n
\n\n

Example 2:

\n\"\"\n
Input: head = [1,2,3,4,5,6]\nOutput: [4,5,6]\nExplanation: Since the list has two middle nodes with values 3 and 4, we return the second one.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is in the range [1, 100].
    • \n\t
  • 1 <= Node.val <= 100
    • \n
\n
" }, { "path": "88-merge-sorted-array/88-merge-sorted-array.java", "content": "class Solution {\n public void merge(int[] nums1, int m, int[] nums2, int n) {\n int index = m + n - 1;\n int index1 = m - 1;\n int index2 = n - 1;\n while (index1 >= 0 && index2 >= 0) {\n if (nums1[index1] > nums2[index2]) {\n nums1[index] = nums1[index1];\n index1--;\n } else {\n nums1[index] = nums2[index2];\n index2--;\n }\n index--;\n }\n while (index2 >= 0) {\n nums1[index--] = nums2[index2--];\n }\n }\n}" }, { "path": "88-merge-sorted-array/NOTES.md", "content": "​" }, { "path": "88-merge-sorted-array/README.md", "content": "

88. Merge Sorted Array

Easy

You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively.

\n\n

Merge nums1 and nums2 into a single array sorted in non-decreasing order.

\n\n

The final sorted array should not be returned by the function, but instead be stored inside the array nums1. To accommodate this, nums1 has a length of m + n, where the first m elements denote the elements that should be merged, and the last n elements are set to 0 and should be ignored. nums2 has a length of n.

\n\n

 

\n

Example 1:

\n\n
Input: nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3\nOutput: [1,2,2,3,5,6]\nExplanation: The arrays we are merging are [1,2,3] and [2,5,6].\nThe result of the merge is [1,2,2,3,5,6] with the underlined elements coming from nums1.\n
\n\n

Example 2:

\n\n
Input: nums1 = [1], m = 1, nums2 = [], n = 0\nOutput: [1]\nExplanation: The arrays we are merging are [1] and [].\nThe result of the merge is [1].\n
\n\n

Example 3:

\n\n
Input: nums1 = [0], m = 0, nums2 = [1], n = 1\nOutput: [1]\nExplanation: The arrays we are merging are [] and [1].\nThe result of the merge is [1].\nNote that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • nums1.length == m + n
    • \n\t
  • nums2.length == n
    • \n\t
  • 0 <= m, n <= 200
    • \n\t
  • 1 <= m + n <= 200
    • \n\t
  • -109 <= nums1[i], nums2[j] <= 109
    • \n
\n\n

 

\n

Follow up: Can you come up with an algorithm that runs in O(m + n) time?

\n
" }, { "path": "881-boats-to-save-people/881-boats-to-save-people.java", "content": "class Solution {\n public int numRescueBoats(int[] people, int limit) {\n Arrays.sort(people);\n int i = 0, j = people.length - 1;\n int ans = 0;\n\n while (i <= j) {\n ans++;\n if (people[i] + people[j] <= limit)\n i++;\n j--;\n }\n\n return ans;\n }\n}" }, { "path": "881-boats-to-save-people/NOTES.md", "content": "​" }, { "path": "881-boats-to-save-people/README.md", "content": "

881. Boats to Save People

Medium

You are given an array people where people[i] is the weight of the ith person, and an infinite number of boats where each boat can carry a maximum weight of limit. Each boat carries at most two people at the same time, provided the sum of the weight of those people is at most limit.

\n\n

Return the minimum number of boats to carry every given person.

\n\n

 

\n

Example 1:

\n\n
Input: people = [1,2], limit = 3\nOutput: 1\nExplanation: 1 boat (1, 2)\n
\n\n

Example 2:

\n\n
Input: people = [3,2,2,1], limit = 3\nOutput: 3\nExplanation: 3 boats (1, 2), (2) and (3)\n
\n\n

Example 3:

\n\n
Input: people = [3,5,3,4], limit = 5\nOutput: 4\nExplanation: 4 boats (3), (3), (4), (5)\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= people.length <= 5 * 104
    • \n\t
  • 1 <= people[i] <= limit <= 3 * 104
    • \n
\n
" }, { "path": "890-find-and-replace-pattern/890-find-and-replace-pattern.java", "content": "class Solution {\n public static List findAndReplacePattern(String[] words, String pattern) {\n List list=new LinkedList<>();\n for(int i=0;i890. Find and Replace Pattern

Medium

Given a list of strings words and a string pattern, return a list of words[i] that match pattern. You may return the answer in any order.

\n\n

A word matches the pattern if there exists a permutation of letters p so that after replacing every letter x in the pattern with p(x), we get the desired word.

\n\n

Recall that a permutation of letters is a bijection from letters to letters: every letter maps to another letter, and no two letters map to the same letter.

\n\n

 

\n

Example 1:

\n\n
Input: words = [\"abc\",\"deq\",\"mee\",\"aqq\",\"dkd\",\"ccc\"], pattern = \"abb\"\nOutput: [\"mee\",\"aqq\"]\nExplanation: \"mee\" matches the pattern because there is a permutation {a -> m, b -> e, ...}. \n\"ccc\" does not match the pattern because {a -> c, b -> c, ...} is not a permutation, since a and b map to the same letter.\n
\n\n

Example 2:

\n\n
Input: words = [\"a\",\"b\",\"c\"], pattern = \"a\"\nOutput: [\"a\",\"b\",\"c\"]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= pattern.length <= 20
    • \n\t
  • 1 <= words.length <= 50
    • \n\t
  • words[i].length == pattern.length
    • \n\t
  • pattern and words[i] are lowercase English letters.
    • \n
\n
" }, { "path": "895-maximum-frequency-stack/895-maximum-frequency-stack.java", "content": "class FreqStack {\n Map cnt;//frequency count for every digit\n int max;//max frequency present for any num(we don't know which)\n \n //used to store frequency-wise stacks of inputs.eg.\n //([2,1,2,5,5,5])(1 freq-[2,1,5],2 freq-[2,5],3 freq-[5])\n Map> stack;//stack assigned with num of frequencies\n public FreqStack() {\n //initialise our members\n cnt=new HashMap<>();\n stack=new HashMap<>();\n max=0;\n }\n \n public void push(int val) {\n //increment val count\n int valCnt=cnt.getOrDefault(val,0)+1;\n cnt.put(val,valCnt);\n //if current cal count is more than max\n if(valCnt>max){\n max=valCnt;\n stack.put(max,new ArrayList<>());//add new stack for this new max count\n }\n stack.get(valCnt).add(val);//add this num to its stacks\n }\n \n public int pop() {\n //remove last element of max freq\n int res=stack.get(max).remove(stack.get(max).size()-1);\n cnt.put(res,cnt.get(res)-1);//reduce freq of number\n if(stack.get(max).size()==0){//if now this freq have no num left\n max--;//reduce the freq\n }\n return res;\n }\n}\n\n/**\n * Your FreqStack object will be instantiated and called as such:\n * FreqStack obj = new FreqStack();\n * obj.push(val);\n * int param_2 = obj.pop();\n */" }, { "path": "895-maximum-frequency-stack/NOTES.md", "content": "​" }, { "path": "895-maximum-frequency-stack/README.md", "content": "

895. Maximum Frequency Stack

Hard

Design a stack-like data structure to push elements to the stack and pop the most frequent element from the stack.

\n\n

Implement the FreqStack class:

\n\n
    \n\t
  • FreqStack() constructs an empty frequency stack.
    • \n\t
  • void push(int val) pushes an integer val onto the top of the stack.
    • \n\t
  • int pop() removes and returns the most frequent element in the stack.\n\t
      \n\t\t
    • If there is a tie for the most frequent element, the element closest to the stack's top is removed and returned.
      • \n\t
    \n\t
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"FreqStack\", \"push\", \"push\", \"push\", \"push\", \"push\", \"push\", \"pop\", \"pop\", \"pop\", \"pop\"]\n[[], [5], [7], [5], [7], [4], [5], [], [], [], []]\nOutput\n[null, null, null, null, null, null, null, 5, 7, 5, 4]\n\nExplanation\nFreqStack freqStack = new FreqStack();\nfreqStack.push(5); // The stack is [5]\nfreqStack.push(7); // The stack is [5,7]\nfreqStack.push(5); // The stack is [5,7,5]\nfreqStack.push(7); // The stack is [5,7,5,7]\nfreqStack.push(4); // The stack is [5,7,5,7,4]\nfreqStack.push(5); // The stack is [5,7,5,7,4,5]\nfreqStack.pop();   // return 5, as 5 is the most frequent. The stack becomes [5,7,5,7,4].\nfreqStack.pop();   // return 7, as 5 and 7 is the most frequent, but 7 is closest to the top. The stack becomes [5,7,5,4].\nfreqStack.pop();   // return 5, as 5 is the most frequent. The stack becomes [5,7,4].\nfreqStack.pop();   // return 4, as 4, 5 and 7 is the most frequent, but 4 is closest to the top. The stack becomes [5,7].\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= val <= 109
    • \n\t
  • At most 2 * 104 calls will be made to push and pop.
    • \n\t
  • It is guaranteed that there will be at least one element in the stack before calling pop.
    • \n
\n
" }, { "path": "897-increasing-order-search-tree/897-increasing-order-search-tree.java", "content": "class Solution {\n public TreeNode increasingBST(TreeNode root){\n List list=new ArrayList<>();\n inOrder(root,list);\n TreeNode newHead=new TreeNode(-1);\n TreeNode temp=newHead;\n for(int i=0;i list){\n if(root==null)return;\n TreeNode lefty=root.left;\n root.left=null;\n TreeNode righty=root.right;\n root.right=null;\n inOrder(lefty,list);\n list.add(root);\n inOrder(righty,list);\n }\n}" }, { "path": "897-increasing-order-search-tree/NOTES.md", "content": "​" }, { "path": "897-increasing-order-search-tree/README.md", "content": "

897. Increasing Order Search Tree

Easy

Given the root of a binary search tree, rearrange the tree in in-order so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only one right child.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [5,3,6,2,4,null,8,1,null,null,null,7,9]\nOutput: [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]\n
\n\n

Example 2:

\n\"\"\n
Input: root = [5,1,7]\nOutput: [1,null,5,null,7]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the given tree will be in the range [1, 100].
    • \n\t
  • 0 <= Node.val <= 1000
    • \n
" }, { "path": "905-sort-array-by-parity/905-sort-array-by-parity.java", "content": "class Solution {\n public int[] sortArrayByParity(int[] nums) {\n int left = 0, right = nums.length-1;\n while (left < right) {\n if (nums[left]%2 == 1) {\n if (nums[right]%2 == 0) {\n int temp = nums[left];\n nums[left] = nums[right];\n nums[right] = temp;\n left++;\n }\n right--;\n } else {\n left++;\n }\n }\n return nums;\n }\n}" }, { "path": "905-sort-array-by-parity/NOTES.md", "content": "​" }, { "path": "905-sort-array-by-parity/README.md", "content": "

905. Sort Array By Parity

Easy

Given an integer array nums, move all the even integers at the beginning of the array followed by all the odd integers.

\n\n

Return any array that satisfies this condition.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [3,1,2,4]\nOutput: [2,4,3,1]\nExplanation: The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.\n
\n\n

Example 2:

\n\n
Input: nums = [0]\nOutput: [0]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 5000
    • \n\t
  • 0 <= nums[i] <= 5000
    • \n
\n
" }, { "path": "91-decode-ways/91-decode-ways.java", "content": "class Solution {\n public int numDecodings(String s) {\n int[] dp=new int[s.length()];\n if(s.charAt(0)=='0'){\n return 0;\n }\n dp[0]=1;\n for(int i=1;i=10&&two<=26){\n if(i==1){\n dp[i]++;\n }\n else{\n dp[i]+=dp[i-2];\n }\n \n }\n }\n return dp[dp.length-1];\n }\n}" }, { "path": "91-decode-ways/NOTES.md", "content": "​" }, { "path": "91-decode-ways/README.md", "content": "

91. Decode Ways

Medium

A message containing letters from A-Z can be encoded into numbers using the following mapping:

\n\n
'A' -> \"1\"\n'B' -> \"2\"\n...\n'Z' -> \"26\"\n
\n\n

To decode an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, \"11106\" can be mapped into:

\n\n
    \n\t
  • \"AAJF\" with the grouping (1 1 10 6)
    • \n\t
  • \"KJF\" with the grouping (11 10 6)
    • \n
\n\n

Note that the grouping (1 11 06) is invalid because \"06\" cannot be mapped into 'F' since \"6\" is different from \"06\".

\n\n

Given a string s containing only digits, return the number of ways to decode it.

\n\n

The test cases are generated so that the answer fits in a 32-bit integer.

\n\n

 

\n

Example 1:

\n\n
Input: s = \"12\"\nOutput: 2\nExplanation: \"12\" could be decoded as \"AB\" (1 2) or \"L\" (12).\n
\n\n

Example 2:

\n\n
Input: s = \"226\"\nOutput: 3\nExplanation: \"226\" could be decoded as \"BZ\" (2 26), \"VF\" (22 6), or \"BBF\" (2 2 6).\n
\n\n

Example 3:

\n\n
Input: s = \"06\"\nOutput: 0\nExplanation: \"06\" cannot be mapped to \"F\" because of the leading zero (\"6\" is different from \"06\").\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= s.length <= 100
    • \n\t
  • s contains only digits and may contain leading zero(s).
    • \n
\n
" }, { "path": "916-word-subsets/916-word-subsets.java", "content": "class Solution {\n public List wordSubsets(String[] A, String[] B) {\n int[] bmax = count(\"\");\n for (String b: B) {\n int[] bCount = count(b);\n for (int i = 0; i < 26; ++i)\n bmax[i] = Math.max(bmax[i], bCount[i]);\n }\n\n List ans = new ArrayList();\n search: for (String a: A) {\n int[] aCount = count(a);\n for (int i = 0; i < 26; ++i)\n if (aCount[i] < bmax[i])\n continue search;\n ans.add(a);\n }\n\n return ans;\n }\n\n public int[] count(String S) {\n int[] ans = new int[26];\n for (char c: S.toCharArray())\n ans[c - 'a']++;\n return ans;\n }\n}" }, { "path": "916-word-subsets/NOTES.md", "content": "​" }, { "path": "916-word-subsets/README.md", "content": "

916. Word Subsets

Medium

You are given two string arrays words1 and words2.

\n\n

A string b is a subset of string a if every letter in b occurs in a including multiplicity.

\n\n
    \n\t
  • For example, \"wrr\" is a subset of \"warrior\" but is not a subset of \"world\".
    • \n
\n\n

A string a from words1 is universal if for every string b in words2, b is a subset of a.

\n\n

Return an array of all the universal strings in words1. You may return the answer in any order.

\n\n

 

\n

Example 1:

\n\n
Input: words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"e\",\"o\"]\nOutput: [\"facebook\",\"google\",\"leetcode\"]\n
\n\n

Example 2:

\n\n
Input: words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"l\",\"e\"]\nOutput: [\"apple\",\"google\",\"leetcode\"]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= words1.length, words2.length <= 104
    • \n\t
  • 1 <= words1[i].length, words2[i].length <= 10
    • \n\t
  • words1[i] and words2[i] consist only of lowercase English letters.
    • \n\t
  • All the strings of words1 are unique.
    • \n
\n
" }, { "path": "92-reverse-linked-list-ii/92-reverse-linked-list-ii.java", "content": "class Solution {\n public ListNode reverseBetween(ListNode head, int left, int right) {\n if (left == right || head == null) return head;\n\n ListNode dummy = new ListNode(0);\n dummy.next = head;\n ListNode pre = dummy, post = dummy; \n \n for (int i = 1; i <= right+1; i++) {\n if (i < left) pre = pre.next; //Find the pre node (i.e. node before Start node)\n post = post.next; //Find the post node (i.e. node after End node)\n }\n ListNode start = pre.next;\n ListNode temp = post; //temp is reverse part which is followed by post node\n\t\t\n while (start != post) {\n ListNode next = start.next;\n start.next = temp;\n temp = start;\n start = next;\n }\n\t\t\n pre.next = temp; // pre node is followed by reversed part \n return dummy.next;\n }\n}" }, { "path": "92-reverse-linked-list-ii/NOTES.md", "content": "​" }, { "path": "92-reverse-linked-list-ii/README.md", "content": "

92. Reverse Linked List II

Medium

Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the list from position left to position right, and return the reversed list.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: head = [1,2,3,4,5], left = 2, right = 4\nOutput: [1,4,3,2,5]\n
\n\n

Example 2:

\n\n
Input: head = [5], left = 1, right = 1\nOutput: [5]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is n.
    • \n\t
  • 1 <= n <= 500
    • \n\t
  • -500 <= Node.val <= 500
    • \n\t
  • 1 <= left <= right <= n
    • \n
\n\n

 

\nFollow up: Could you do it in one pass?
" }, { "path": "923-3sum-with-multiplicity/923-3sum-with-multiplicity.java", "content": "class Solution {\n public int threeSumMulti(int[] A, int target) {\n int MOD = 1_000_000_007;\n\n // Initializing as long saves us the trouble of\n // managing count[x] * count[y] * count[z] overflowing later.\n long[] count = new long[101];\n int uniq = 0;\n for (int x: A) {\n count[x]++;\n if (count[x] == 1)\n uniq++;\n }\n\n int[] keys = new int[uniq];\n int t = 0;\n for (int i = 0; i <= 100; ++i)\n if (count[i] > 0)\n keys[t++] = i;\n\n long ans = 0;\n // Now, let's do a 3sum on \"keys\", for i <= j <= k.\n // We will use count to add the correct contribution to ans.\n\n for (int i = 0; i < keys.length; i++) {\n int x = keys[i];\n int T = target - x;\n int j = i, k = keys.length - 1;\n while (j <= k) {\n int y = keys[j], z = keys[k];\n if (y + z < T) {\n j++;\n } else if (y + z > T) {\n k--;\n } else { // # x+y+z == T, now calc the size of the contribution\n if (i < j && j < k) {\n ans += count[x] * count[y] * count[z];\n } else if (i == j && j < k) {\n ans += count[x] * (count[x] - 1) / 2 * count[z];\n } else if (i < j && j == k) {\n ans += count[x] * count[y] * (count[y] - 1) / 2;\n } else { // i == j == k\n ans += count[x] * (count[x] - 1) * (count[x] - 2) / 6;\n }\n\n ans %= MOD;\n j++;\n k--;\n }\n }\n }\n\n return (int) ans;\n }\n}" }, { "path": "923-3sum-with-multiplicity/NOTES.md", "content": "​" }, { "path": "923-3sum-with-multiplicity/README.md", "content": "

923. 3Sum With Multiplicity

Medium

Given an integer array arr, and an integer target, return the number of tuples i, j, k such that i < j < k and arr[i] + arr[j] + arr[k] == target.

\n\n

As the answer can be very large, return it modulo 109 + 7.

\n\n

 

\n

Example 1:

\n\n
Input: arr = [1,1,2,2,3,3,4,4,5,5], target = 8\nOutput: 20\nExplanation: \nEnumerating by the values (arr[i], arr[j], arr[k]):\n(1, 2, 5) occurs 8 times;\n(1, 3, 4) occurs 8 times;\n(2, 2, 4) occurs 2 times;\n(2, 3, 3) occurs 2 times.\n
\n\n

Example 2:

\n\n
Input: arr = [1,1,2,2,2,2], target = 5\nOutput: 12\nExplanation: \narr[i] = 1, arr[j] = arr[k] = 2 occurs 12 times:\nWe choose one 1 from [1,1] in 2 ways,\nand two 2s from [2,2,2,2] in 6 ways.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 3 <= arr.length <= 3000
    • \n\t
  • 0 <= arr[i] <= 100
    • \n\t
  • 0 <= target <= 300
    • \n
\n
" }, { "path": "936-stamping-the-sequence/936-stamping-the-sequence.java", "content": "class Solution {\n public int[] movesToStamp(String stamp, String target) {\n char[] s = stamp.toCharArray();\n char[] t = target.toCharArray();\n int m = s.length, n = t.length, count = 0; // count chars replaced successfully\n\n boolean[] visited = new boolean[n];\n int[] res = new int[n];\n int top = res.length;\n while (count < n) {\n boolean stamped = false;\n for (int i = 0; i <= n - m; i++)\n if (!visited[i] && canStamp(i, s, t)) {\n visited[i] = true;\n // System.out.printf(\"%s%d\\n%s\\n%s%s\\n\\n\", \" \".repeat(i), i, new String(t), \" \".repeat(i), new String(s));\n count = stamp(i, s, t, count);\n stamped = true; // successfully stamped this round\n res[--top] = i; // add result\n if (count == n) break; // all stamped\n }\n \n if (!stamped) return new int[0]; // nothing found, return an empty array\n }\n \n return Arrays.copyOfRange(res, top, res.length);\n }\n \n private int stamp(int start, char[] s, char[] t, int count) {\n for (int i = 0; i < s.length; i++)\n if (t[start + i] != '*') {\n t[start + i] = '*';\n count++;\n }\n \n return count;\n }\n \n private boolean canStamp(int start, char[] s, char[] t) {\n int count = 0;\n for (int i = 0; i < s.length; i++) {\n if (t[start + i] == '*') count++;\n else if (t[start + i] != '*' && s[i] != t[start + i])\n return false;\n }\n\n return count != s.length;\n }\n}\n\n/*\nCase 0:\n\"abc\"\n\"abababcbcbababcbc\"\n\n 4\nabababcbcbababcbc\n abc\n\n 6\nabab***bcbababcbc\n abc\n\n 12\nabab*****bababcbc\n abc\n\n 14\nabab*****bab***bc\n abc\n\n 2\nabab*****bab*****\n abc\n\n 10\nab*******bab*****\n abc\n\n0\nab*******b*******\nabc\n\n 8\n*********b*******\n abc\n\n\n\nCase 1:\n\"abc\"\n\"ababc\"\n\n 2\nababc\n abc\n \n0\nab***\nabc\n\n\"abca\"\n\"aabcaca\"\n\n 1\naabcaca\n abca\n \n 3\na****ca\n abca\n \n0\na******\nabca\n\n*/" }, { "path": "936-stamping-the-sequence/NOTES.md", "content": "​" }, { "path": "936-stamping-the-sequence/README.md", "content": "

936. Stamping The Sequence

Hard

You are given two strings stamp and target. Initially, there is a string s of length target.length with all s[i] == '?'.

\n\n

In one turn, you can place stamp over s and replace every letter in the s with the corresponding letter from stamp.

\n\n
    \n\t
  • For example, if stamp = \"abc\" and target = \"abcba\", then s is \"?????\" initially. In one turn you can:\n\n\t
      \n\t\t
    • place stamp at index 0 of s to obtain \"abc??\",
      • \n\t\t
    • place stamp at index 1 of s to obtain \"?abc?\", or
      • \n\t\t
    • place stamp at index 2 of s to obtain \"??abc\".
      • \n\t
    \n\tNote that stamp must be fully contained in the boundaries of s in order to stamp (i.e., you cannot place stamp at index 3 of s).
    • \n
\n\n

We want to convert s to target using at most 10 * target.length turns.

\n\n

Return an array of the index of the left-most letter being stamped at each turn. If we cannot obtain target from s within 10 * target.length turns, return an empty array.

\n\n

 

\n

Example 1:

\n\n
Input: stamp = \"abc\", target = \"ababc\"\nOutput: [0,2]\nExplanation: Initially s = \"?????\".\n- Place stamp at index 0 to get \"abc??\".\n- Place stamp at index 2 to get \"ababc\".\n[1,0,2] would also be accepted as an answer, as well as some other answers.\n
\n\n

Example 2:

\n\n
Input: stamp = \"abca\", target = \"aabcaca\"\nOutput: [3,0,1]\nExplanation: Initially s = \"???????\".\n- Place stamp at index 3 to get \"???abca\".\n- Place stamp at index 0 to get \"abcabca\".\n- Place stamp at index 1 to get \"aabcaca\".\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= stamp.length <= target.length <= 1000
    • \n\t
  • stamp and target consist of lowercase English letters.
    • \n
\n
" }, { "path": "936-stamping-the-sequence/Stamping The Sequence.cpp", "content": "class Solution {\npublic:\n // Function to check whether the substring can be replaced with stamp\n bool canReplace(string &stamp, string &target, int i, int n)\n { \n for(int p=0; p movesToStamp(string stamp, string target) {\n \n int n = stamp.length(), m = target.length(), cnt = 0;\n \n vector ans;\n vector visited(m,false);\n \n while(cnt < m)\n {\n bool f = false;\n \n for(int i=0; i<=m-n; i++)\n if(!visited[i] and canReplace(stamp, target, i, n))\n {\n replace(stamp, target, i, n, cnt);\n ans.push_back(i);\n visited[i] = f = true;\n }\n \n if(!f)\n break;\n }\n \n if(cnt < m)\n return {};\n \n reverse(ans.begin(), ans.end());\n \n return ans;\n }\n};\n" }, { "path": "936-stamping-the-sequence/stamping-the-sequence.cpp", "content": "// What I basiclly did here is trying to reverse the whole operations.\n// The operation token later will be more apperant than the operation token before. The letters which stamped later will cover the letters stamped before and we really don't care about the letters which are covered.\n\n// * * * * * * *\n// * * * |a b c a|\n// |a b c a| b c a\n// a |a b c a| c a\n// We just try to match the stamp with the target. Since we do not care about the letters which are coverd by others, so we can apply a * match any letters. For example:\n\n// \"aabcaca\" -> \"a****ca\" -> \"*****ca\"->\"*******\"\n\n\nclass Solution {\npublic:\n vector movesToStamp(string stamp, string target) {\n vector ans;\n vector output;\n string str = target;\n string aim(target.length(),'*');\n while(str != aim){\n int tmp = remove(str,stamp); // index of first match case when stamp is found in str or target.\n if(tmp == str.length()) return output;\n ans.push_back(tmp);\n }\n for(int iter=ans.size()-1;iter>=0;--iter) output.push_back(ans[iter]);\n return output;\n }\n int remove(string& str, string stamp){\n for(int iter=0;iter inorderTraversal(TreeNode root) {\n List list=new ArrayList<>();\n inOrder(root,list);\n return list;\n }\n void inOrder(TreeNode root,List list){\n if(root==null)return;\n inOrder(root.left,list);\n list.add(root.val);\n inOrder(root.right,list);\n }\n}" }, { "path": "94-binary-tree-inorder-traversal/Binary Tree InOrder Traversal lc.cpp", "content": "#include\nusing namespace std;\n\n/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode() : val(0), left(nullptr), right(nullptr) {}\n * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n vector res;\n void inorder(TreeNode* node){\n if(!node) return;\n// traverse the left node\n inorder(node->left);\n// do something with node value here\n res.push_back(node->val);\n// traverse right\n inorder(node->right);\n }\n vector inorderTraversal(TreeNode* root) {\n inorder(root);\n return res;\n }\n};" }, { "path": "94-binary-tree-inorder-traversal/NOTES.md", "content": "​" }, { "path": "94-binary-tree-inorder-traversal/README.md", "content": "

94. Binary Tree Inorder Traversal

Easy

Given the root of a binary tree, return the inorder traversal of its nodes' values.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,null,2,3]\nOutput: [1,3,2]\n
\n\n

Example 2:

\n\n
Input: root = []\nOutput: []\n
\n\n

Example 3:

\n\n
Input: root = [1]\nOutput: [1]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 100].
    • \n\t
  • -100 <= Node.val <= 100
    • \n
\n\n

 

\nFollow up: Recursive solution is trivial, could you do it iteratively?
" }, { "path": "94. Binary Tree Inorder Traversal.cpp", "content": "class Solution {\npublic:\n void solve(TreeNode *root,vector &result)\n {\n if(root == NULL){\n return ;\n }\n solve(root->left,result);\n result.push_back(root->val);\n solve(root->right,result);\n }\n vector inorderTraversal(TreeNode* root) {\n vector result;\n solve(root,result);\n return result;\n }\n};\n" }, { "path": "948 Bag of Tokens lc med.cpp", "content": "class Solution {\npublic:\n int bagOfTokensScore(vector& tokens, int power) {\n// approach 2 pointer tech\n // sort, then define 2 pointer , start =0, and end\n// check\n sort(tokens.begin(), tokens.end());\n int left_start =0, right_end = tokens.size()-1;\n int score =0; // initializing score 0\n while(left_start<=right_end){\n if(power>=tokens[left_start]){\n \n power-=tokens[left_start++];\n score++;\n }else{\n if(power+tokens[right_end]>= tokens[left_start] && score!=0 && right_end !=left_start){\n power+= tokens[right_end--];\n score--;\n }else break;\n }\n }\n return score;\n }\n};" }, { "path": "948-bag-of-tokens/948-bag-of-tokens.java", "content": "class Solution {\n public int bagOfTokensScore(int[] tokens, int power) {\n Arrays.sort(tokens);\n int i=0;\n int j=tokens.length-1;\n int ans=0;\n int curr=0;\n while(i<=j){\n if(power>=tokens[i]){\n power-=tokens[i];\n curr++;\n ans=Math.max(ans,curr);\n i++;\n }else{\n if(curr==0)break;\n power+=tokens[j];\n curr--;\n j--;\n }\n }\n return ans;\n }\n}" }, { "path": "948-bag-of-tokens/NOTES.md", "content": "​" }, { "path": "948-bag-of-tokens/README.md", "content": "

948. Bag of Tokens

Medium

You have an initial power of power, an initial score of 0, and a bag of tokens where tokens[i] is the value of the ith token (0-indexed).

\n\n

Your goal is to maximize your total score by potentially playing each token in one of two ways:

\n\n
    \n\t
  • If your current power is at least tokens[i], you may play the ith token face up, losing tokens[i] power and gaining 1 score.
    • \n\t
  • If your current score is at least 1, you may play the ith token face down, gaining tokens[i] power and losing 1 score.
    • \n
\n\n

Each token may be played at most once and in any order. You do not have to play all the tokens.

\n\n

Return the largest possible score you can achieve after playing any number of tokens.

\n\n

 

\n

Example 1:

\n\n
Input: tokens = [100], power = 50\nOutput: 0\nExplanation: Playing the only token in the bag is impossible because you either have too little power or too little score.\n
\n\n

Example 2:

\n\n
Input: tokens = [100,200], power = 150\nOutput: 1\nExplanation: Play the 0th token (100) face up, your power becomes 50 and score becomes 1.\nThere is no need to play the 1st token since you cannot play it face up to add to your score.\n
\n\n

Example 3:

\n\n
Input: tokens = [100,200,300,400], power = 200\nOutput: 2\nExplanation: Play the tokens in this order to get a score of 2:\n1. Play the 0th token (100) face up, your power becomes 100 and score becomes 1.\n2. Play the 3rd token (400) face down, your power becomes 500 and score becomes 0.\n3. Play the 1st token (200) face up, your power becomes 300 and score becomes 1.\n4. Play the 2nd token (300) face up, your power becomes 0 and score becomes 2.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= tokens.length <= 1000
    • \n\t
  • 0 <= tokens[i], power < 104
    • \n
\n
" }, { "path": "96-Unique Binary Search Trees.java", "content": "// Using Memoization\n\npublic static int helper(int n, int[] dp) {\n if(n<=1) return dp[n] = 1;\n \n if(dp[n] != -1) {\n return dp[n];\n }\n int ans = 0;\n for(int i = 0; i < n; i++) {\n ans += helper(i, dp) * helper(n-i-1, dp);\n }\n return dp[n] = ans;\n }\n public int numTrees(int n) {\n int[] dp = new int[n+1];\n Arrays.fill(dp, -1);\n return helper(n, dp); \n }\n\n// Using Tabulation\n\npublic int numTrees(int n) {\n int[] dp = new int[n+1];\n dp[0] = 1;\n dp[1] = 1;\n \n for(int i = 2; i <= n; i++) {\n for(int j =0; j < i; j++) {\n dp[i] += (dp[j] * dp[i-j-1]);\n }\n }\n return dp[n]; \n }\n" }, { "path": "967-numbers-with-same-consecutive-differences/967-numbers-with-same-consecutive-differences.java", "content": "class Solution {\n List ans;\n public int[] numsSameConsecDiff(int n, int k) {\n ans=new ArrayList<>();\n for(int i=1;i<10;i++){\n dfs(i,n,k);\n }\n int[] arr=new int[ans.size()];\n int i=0;\n for(int ele:ans){\n arr[i++]=ele;\n }\n return arr;\n }\n void dfs(int num,int n,int k){\n if((int)Math.floor(Math.log10(num) + 1)==n){\n ans.add(num);\n return;\n }\n int last=num%10;\n if(k==0){\n dfs(num*10+(last+k),n,k);\n return;\n }\n if(last+k<10){\n dfs(num*10+(last+k),n,k);\n }\n if(last-k>-1){\n dfs(num*10+(last-k),n,k);\n }\n }\n}" }, { "path": "967-numbers-with-same-consecutive-differences/NOTES.md", "content": "​" }, { "path": "967-numbers-with-same-consecutive-differences/README.md", "content": "

967. Numbers With Same Consecutive Differences

Medium

Return all non-negative integers of length n such that the absolute difference between every two consecutive digits is k.

\n\n

Note that every number in the answer must not have leading zeros. For example, 01 has one leading zero and is invalid.

\n\n

You may return the answer in any order.

\n\n

 

\n

Example 1:

\n\n
Input: n = 3, k = 7\nOutput: [181,292,707,818,929]\nExplanation: Note that 070 is not a valid number, because it has leading zeroes.\n
\n\n

Example 2:

\n\n
Input: n = 2, k = 1\nOutput: [10,12,21,23,32,34,43,45,54,56,65,67,76,78,87,89,98]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 2 <= n <= 9
    • \n\t
  • 0 <= k <= 9
    • \n
\n
" }, { "path": "968-binary-tree-cameras/968-binary-tree-cameras.java", "content": "class Solution {\n private int NOT_MONITORED = 0;\n private int MONITORED_NOCAM = 1;\n private int MONITORED_WITHCAM = 2;\n private int cameras = 0;\n \n public int minCameraCover(TreeNode root) {\n int top = dfs(root);\n return top == NOT_MONITORED ? cameras+1 :cameras;\n }\n \n private int dfs (TreeNode root){\n if(root == null)return MONITORED_NOCAM;\n int left = dfs(root.left);\n int right = dfs(root.right);\n \n if (left == MONITORED_NOCAM && right == MONITORED_NOCAM) {\n return NOT_MONITORED;\n } else if (left == NOT_MONITORED || right == NOT_MONITORED) {\n cameras++;\n return MONITORED_WITHCAM;\n } else {\n return MONITORED_NOCAM;\n }\n }\n}" }, { "path": "968-binary-tree-cameras/NOTES.md", "content": "​" }, { "path": "968-binary-tree-cameras/README.md", "content": "

968. Binary Tree Cameras

Hard

You are given the root of a binary tree. We install cameras on the tree nodes where each camera at a node can monitor its parent, itself, and its immediate children.

\n\n

Return the minimum number of cameras needed to monitor all nodes of the tree.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [0,0,null,0,0]\nOutput: 1\nExplanation: One camera is enough to monitor all nodes if placed as shown.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [0,0,null,0,null,0,null,null,0]\nOutput: 2\nExplanation: At least two cameras are needed to monitor all nodes of the tree. The above image shows one of the valid configurations of camera placement.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 1000].
    • \n\t
  • Node.val == 0
    • \n
\n
" }, { "path": "97-interleaving-string/97-interleaving-string.java", "content": "class Solution {\n public boolean isInterleave(String s1, String s2, String s3) {\n boolean[][] canReach = new boolean[s1.length()][s2.length()];\n return isInterleaveHelper(s1, s2, s3, 0, 0, 0, canReach);\n }\n \n private boolean isInterleaveHelper(String s1, String s2, String s3, int i1, int i2, int i3, boolean[][] canReach) {\n if (i3 == s3.length()) {\n if (i1 == s1.length() && i2 == s2.length()) return true;\n return false;\n }\n if (i1 == s1.length()) {\n return s2.substring(i2, s2.length()).equals(s3.substring(i3, s3.length()));\n }\n if (i2 == s2.length()) {\n return s1.substring(i1, s1.length()).equals(s3.substring(i3, s3.length()));\n }\n if (canReach[i1][i2]) return false;\n canReach[i1][i2] = true;\n boolean s1Match = (s1.charAt(i1) == s3.charAt(i3));\n boolean s2Match = (s2.charAt(i2) == s3.charAt(i3));\n if (s1Match && s2Match) {\n return isInterleaveHelper(s1, s2, s3, i1 + 1, i2, i3 + 1, canReach) || isInterleaveHelper(s1, s2, s3, i1, i2 + 1, i3 + 1, canReach);\n }\n else if (s1Match) {\n return isInterleaveHelper(s1, s2, s3, i1 + 1, i2, i3 + 1, canReach);\n }\n else if (s2Match) {\n return isInterleaveHelper(s1, s2, s3, i1, i2 + 1, i3 + 1, canReach);\n }\n else {\n return false;\n }\n }\n}" }, { "path": "97-interleaving-string/NOTES.md", "content": "​" }, { "path": "97-interleaving-string/README.md", "content": "

97. Interleaving String

Medium

Given strings s1, s2, and s3, find whether s3 is formed by an interleaving of s1 and s2.

\n\n

An interleaving of two strings s and t is a configuration where they are divided into non-empty substrings such that:

\n\n
    \n\t
  • s = s1 + s2 + ... + sn
    • \n\t
  • t = t1 + t2 + ... + tm
    • \n\t
  • |n - m| <= 1
    • \n\t
  • The interleaving is s1 + t1 + s2 + t2 + s3 + t3 + ... or t1 + s1 + t2 + s2 + t3 + s3 + ...
    • \n
\n\n

Note: a + b is the concatenation of strings a and b.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbcbcac\"\nOutput: true\n
\n\n

Example 2:

\n\n
Input: s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbbaccc\"\nOutput: false\n
\n\n

Example 3:

\n\n
Input: s1 = \"\", s2 = \"\", s3 = \"\"\nOutput: true\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= s1.length, s2.length <= 100
    • \n\t
  • 0 <= s3.length <= 200
    • \n\t
  • s1, s2, and s3 consist of lowercase English letters.
    • \n
\n\n

 

\n

Follow up: Could you solve it using only O(s2.length) additional memory space?

\n
" }, { "path": "98-validate-binary-search-tree/98-validate-binary-search-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n public boolean isValidBST(TreeNode root) {\n return dfs(root,Long.MIN_VALUE,Long.MAX_VALUE);\n }\n boolean dfs(TreeNode root,long lower,long upper){\n if(root==null)return true;\n if(root.val<=lower || root.val>=upper)return false;\n return dfs(root.left,lower,root.val) && dfs(root.right,root.val,upper);\n }\n}" }, { "path": "98-validate-binary-search-tree/NOTES.md", "content": "​" }, { "path": "98-validate-binary-search-tree/README.md", "content": "

98. Validate Binary Search Tree

Medium

Given the root of a binary tree, determine if it is a valid binary search tree (BST).

\n\n

A valid BST is defined as follows:

\n\n
    \n\t
  • The left subtree of a node contains only nodes with keys less than the node's key.
    • \n\t
  • The right subtree of a node contains only nodes with keys greater than the node's key.
    • \n\t
  • Both the left and right subtrees must also be binary search trees.
    • \n
\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [2,1,3]\nOutput: true\n
\n\n

Example 2:

\n\"\"\n
Input: root = [5,1,4,null,null,3,6]\nOutput: false\nExplanation: The root node's value is 5 but its right child's value is 4.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 104].
    • \n\t
  • -231 <= Node.val <= 231 - 1
    • \n
\n
" }, { "path": "981-time-based-key-value-store/981-time-based-key-value-store.java", "content": "class TimeValue {\n \n public int time;\n public String value;\n \n public TimeValue(int time, String value) {\n \n this.time = time;\n this.value = value;\n }\n \n public String toString() {\n \n return \"TimeValue with time \" + this.time \n + \" and value \" + this.value;\n }\n}\n\nclass TimeMap {\n \n private Map> map = new HashMap<>();\n\n public TimeMap() {\n \n }\n \n public void set(String key, String value, int timestamp) {\n \n // Add the given (key, timestamp) combination \n \n TimeValue newTimeValue = new TimeValue(timestamp, value);\n \n if (!this.map.containsKey(key)) {\n \n this.map.put(key, new ArrayList<>());\n }\n \n this.map.get(key).add(newTimeValue);\n \n // System.out.println(this.map.get(key));\n }\n \n public String get(String key, int timestamp) {\n \n List list = this.map.get(key);\n \n if (list == null) {\n \n return \"\";\n }\n \n // Binary search \n int left = 0;\n int right = list.size() - 1;\n \n TimeValue best = null;\n \n while (left <= right) {\n \n int mid = left + (right - left) / 2;\n \n if (list.get(mid).time <= timestamp) {\n \n // Valid time \n best = list.get(mid);\n left = mid + 1;\n } else {\n \n right = mid - 1;\n }\n }\n \n return (best != null ? best.value : \"\");\n }\n}" }, { "path": "981-time-based-key-value-store/NOTES.md", "content": "​" }, { "path": "981-time-based-key-value-store/README.md", "content": "

981. Time Based Key-Value Store

Medium

Design a time-based key-value data structure that can store multiple values for the same key at different time stamps and retrieve the key's value at a certain timestamp.

\n\n

Implement the TimeMap class:

\n\n
    \n\t
  • TimeMap() Initializes the object of the data structure.
    • \n\t
  • void set(String key, String value, int timestamp) Stores the key key with the value value at the given time timestamp.
    • \n\t
  • String get(String key, int timestamp) Returns a value such that set was called previously, with timestamp_prev <= timestamp. If there are multiple such values, it returns the value associated with the largest timestamp_prev. If there are no values, it returns \"\".
    • \n
\n\n

 

\n

Example 1:

\n\n
Input\n[\"TimeMap\", \"set\", \"get\", \"get\", \"set\", \"get\", \"get\"]\n[[], [\"foo\", \"bar\", 1], [\"foo\", 1], [\"foo\", 3], [\"foo\", \"bar2\", 4], [\"foo\", 4], [\"foo\", 5]]\nOutput\n[null, null, \"bar\", \"bar\", null, \"bar2\", \"bar2\"]\n\nExplanation\nTimeMap timeMap = new TimeMap();\ntimeMap.set(\"foo\", \"bar\", 1);  // store the key \"foo\" and value \"bar\" along with timestamp = 1.\ntimeMap.get(\"foo\", 1);         // return \"bar\"\ntimeMap.get(\"foo\", 3);         // return \"bar\", since there is no value corresponding to foo at timestamp 3 and timestamp 2, then the only value is at timestamp 1 is \"bar\".\ntimeMap.set(\"foo\", \"bar2\", 4); // store the key \"foo\" and value \"bar2\" along with timestamp = 4.\ntimeMap.get(\"foo\", 4);         // return \"bar2\"\ntimeMap.get(\"foo\", 5);         // return \"bar2\"\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= key.length, value.length <= 100
    • \n\t
  • key and value consist of lowercase English letters and digits.
    • \n\t
  • 1 <= timestamp <= 107
    • \n\t
  • All the timestamps timestamp of set are strictly increasing.
    • \n\t
  • At most 2 * 105 calls will be made to set and get.
    • \n
\n
" }, { "path": "985 Sum of Even Numbers After Queries lc med.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n vector sumEvenAfterQueries(vector& nums, vector>& queries) {\n int S =0;\n for(auto x : nums)\n if(x%2==0) S+=x;\n \n vectorres;\n \n for(auto q : queries ){\n int val = q[0], idx = q[1];\n// if original nums[idx] is even, then we deduct it from evenSum\n if(nums[idx] % 2==0) S-=nums[idx];\n// in-place update nums\n nums[idx]+=val;\n// check if we need to update evenSum for the new value\n if (nums[idx] % 2 == 0) S += nums[idx];\n// then we have evenSum after this query, push it to ans \n res.push_back(S);\n\n }\n return res;\n }\n};" }, { "path": "985-sum-of-even-numbers-after-queries/985-sum-of-even-numbers-after-queries.java", "content": "class Solution {\n public int[] sumEvenAfterQueries(int[] nums, int[][] queries) {\n int sum=0;\n for(int i:nums){\n if((i&1)==0)sum+=i;\n }\n int[]ans=new int[queries.length];\n for(int i=0;i985. Sum of Even Numbers After Queries

Medium

You are given an integer array nums and an array queries where queries[i] = [vali, indexi].

\n\n

For each query i, first, apply nums[indexi] = nums[indexi] + vali, then print the sum of the even values of nums.

\n\n

Return an integer array answer where answer[i] is the answer to the ith query.

\n\n

 

\n

Example 1:

\n\n
Input: nums = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]\nOutput: [8,6,2,4]\nExplanation: At the beginning, the array is [1,2,3,4].\nAfter adding 1 to nums[0], the array is [2,2,3,4], and the sum of even values is 2 + 2 + 4 = 8.\nAfter adding -3 to nums[1], the array is [2,-1,3,4], and the sum of even values is 2 + 4 = 6.\nAfter adding -4 to nums[0], the array is [-2,-1,3,4], and the sum of even values is -2 + 4 = 2.\nAfter adding 2 to nums[3], the array is [-2,-1,3,6], and the sum of even values is -2 + 6 = 4.\n
\n\n

Example 2:

\n\n
Input: nums = [1], queries = [[4,0]]\nOutput: [0]\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= nums.length <= 104
    • \n\t
  • -104 <= nums[i] <= 104
    • \n\t
  • 1 <= queries.length <= 104
    • \n\t
  • -104 <= vali <= 104
    • \n\t
  • 0 <= indexi < nums.length
    • \n
\n
" }, { "path": "987-vertical-order-traversal-of-a-binary-tree/987-vertical-order-traversal-of-a-binary-tree.java", "content": "/**\n * Definition for a binary tree node.\n * public class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode() {}\n * TreeNode(int val) { this.val = val; }\n * TreeNode(int val, TreeNode left, TreeNode right) {\n * this.val = val;\n * this.left = left;\n * this.right = right;\n * }\n * }\n */\nclass Solution {\n Map> map;\n int min;\n public List> verticalTraversal(TreeNode root) {\n map=new HashMap<>();\n min=Integer.MAX_VALUE;\n dfs(root,0,0);\n List> ans=new ArrayList<>();\n while(map.containsKey(min)){\n PriorityQueuepq=map.get(min);\n List ls=new ArrayList<>();\n while(pq.size()>0){\n ls.add(pq.remove()[0]);\n }\n ans.add(ls);\n min++;\n }\n return ans;\n }\n void dfs(TreeNode root,int row,int col){\n if(root==null)return;\n min=Math.min(min,col);\n PriorityQueue pq;\n if(map.containsKey(col)){\n pq=map.get(col);\n }else{\n pq=new PriorityQueue<>((a,b)->{\n if(a[1]==b[1]){\n return a[0]-b[0];\n }\n return a[1]-b[1];\n });\n }\n pq.add(new int[]{root.val,row});\n map.put(col,pq);\n dfs(root.left,row+1,col-1);\n dfs(root.right,row+1,col+1);\n }\n}\n\n################ Approach-2 by @Jay-Thesia ###########################3\n\nclass Solution {\n\n class Pair{\n\n TreeNode value;\n int hdist;\n\n Pair(TreeNode value,int hdist){\n this.value=value;\n this.hdist=hdist;\n }\n\n }\n public List> verticalTraversal(TreeNode root) {\n\n List> outter=new ArrayList<>();\n\n TreeMap> tm=new TreeMap();\n\n Deque q=new LinkedList<>();\n q.add(new Pair(root,0));\n\n while(q.size()>0){\n\n int len=q.size();\n HashMap> hm=new HashMap<>();\n\n for(int i=0;i inner=hm.getOrDefault(cHdist,new ArrayList<>());\n inner.add(cVal.val);\n Collections.sort(inner);\n\n hm.put(cHdist,new ArrayList<>(inner));\n\n if(cVal.left!=null) q.add(new Pair(cVal.left,cHdist-1));\n if(cVal.right!=null) q.add(new Pair(cVal.right,cHdist+1));\n }\n\n for(Map.Entry> item:hm.entrySet()){\n\n ArrayList list=tm.getOrDefault(item.getKey(),new ArrayList<>());\n list.addAll(item.getValue());\n tm.put(item.getKey(),list);\n\n }\n }\n\n return new ArrayList<>(tm.values());\n\n\n }\n}\n" }, { "path": "987-vertical-order-traversal-of-a-binary-tree/NOTES.md", "content": "key=col\nval=pq -> sorting acc to row || val\n[0] -> val\n[1] -> row" }, { "path": "987-vertical-order-traversal-of-a-binary-tree/README.md", "content": "

987. Vertical Order Traversal of a Binary Tree

Hard

Given the root of a binary tree, calculate the vertical order traversal of the binary tree.

\n\n

For each node at position (row, col), its left and right children will be at positions (row + 1, col - 1) and (row + 1, col + 1) respectively. The root of the tree is at (0, 0).

\n\n

The vertical order traversal of a binary tree is a list of top-to-bottom orderings for each column index starting from the leftmost column and ending on the rightmost column. There may be multiple nodes in the same row and same column. In such a case, sort these nodes by their values.

\n\n

Return the vertical order traversal of the binary tree.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [3,9,20,null,null,15,7]\nOutput: [[9],[3,15],[20],[7]]\nExplanation:\nColumn -1: Only node 9 is in this column.\nColumn 0: Nodes 3 and 15 are in this column in that order from top to bottom.\nColumn 1: Only node 20 is in this column.\nColumn 2: Only node 7 is in this column.
\n\n

Example 2:

\n\"\"\n
Input: root = [1,2,3,4,5,6,7]\nOutput: [[4],[2],[1,5,6],[3],[7]]\nExplanation:\nColumn -2: Only node 4 is in this column.\nColumn -1: Only node 2 is in this column.\nColumn 0: Nodes 1, 5, and 6 are in this column.\n          1 is at the top, so it comes first.\n          5 and 6 are at the same position (2, 0), so we order them by their value, 5 before 6.\nColumn 1: Only node 3 is in this column.\nColumn 2: Only node 7 is in this column.\n
\n\n

Example 3:

\n\"\"\n
Input: root = [1,2,3,4,6,5,7]\nOutput: [[4],[2],[1,5,6],[3],[7]]\nExplanation:\nThis case is the exact same as example 2, but with nodes 5 and 6 swapped.\nNote that the solution remains the same since 5 and 6 are in the same location and should be ordered by their values.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [1, 1000].
    • \n\t
  • 0 <= Node.val <= 1000
    • \n
\n
" }, { "path": "99-recover-binary-search-tree/99-recover-binary-search-tree.java", "content": "class Solution {\n TreeNode prev = null;\n TreeNode first = null;\n TreeNode second = null;\n public void recoverTree(TreeNode root) {\n inorder(root);\n swap(first,second);\n }\n public void swap(TreeNode a, TreeNode b) {\n int temp = a.val;\n a.val=b.val;\n b.val=temp;\n }\n public void inorder(TreeNode root) {\n if(root!=null) {\n if(root.left!=null) {\n inorder(root.left);\n }\n if(prev!=null && prev.val>root.val) {\n if(first==null) {\n first=prev;\n } \n if(first!=null) {\n second=root;\n }\n }\n prev=root;\n if(root.right!=null) {\n inorder(root.right);\n }\n }\n }\n}" }, { "path": "99-recover-binary-search-tree/README.md", "content": "

99. Recover Binary Search Tree

Medium

You are given the root of a binary search tree (BST), where the values of exactly two nodes of the tree were swapped by mistake. Recover the tree without changing its structure.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [1,3,null,null,2]\nOutput: [3,1,null,null,2]\nExplanation: 3 cannot be a left child of 1 because 3 > 1. Swapping 1 and 3 makes the BST valid.\n
\n\n

Example 2:

\n\"\"\n
Input: root = [3,1,4,null,null,2]\nOutput: [2,1,4,null,null,3]\nExplanation: 2 cannot be in the right subtree of 3 because 2 < 3. Swapping 2 and 3 makes the BST valid.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [2, 1000].
    • \n\t
  • -231 <= Node.val <= 231 - 1
    • \n
\n\n

 

\nFollow up: A solution using O(n) space is pretty straight-forward. Could you devise a constant O(1) space solution?
" }, { "path": "990-satisfiability-of-equality-equations/990-satisfiability-of-equality-equations.java", "content": "class Solution {\n int[] parent = new int[26];\n public int find(int x) {\n // with path compression\n if (parent[x] == x) return x;\n return parent[x] = find(parent[x]);\n // without path compression\n // return parent[x] == x ? x : find(parent[x]);\n }\n // the idea is to put all characters in the same group if they are equal\n // in order to do that, we can use Disjoint Set Union (dsu) aka Union Find\n // for dsu tutorial, please check out https://wingkwong.github.io/leetcode-the-hard-way/tutorials/graph-theory/disjoint-set-union\n public boolean equationsPossible(String[] equations) {\n int n = equations.length;\n // at the beginning, put each character index in its own group\n // so we will have 26 groups with one character each\n // i.e. 'a' in group 0, 'b' in group 1, ..., 'z' in group 25\n for (int i = 0; i < 26; i++) parent[i] = i;\n for (String e : equations) {\n // if two character is equal, \n if (e.charAt(1) == '=') {\n // e.g. a = b\n // then we group them together\n // how? we use `find` function to find out the parent group of the target character index\n // then update parent. a & b would be in group 1 (i.e. a merged into the group where b belongs to)\n // or you can also do `parent[find(e.charAt(3)- 'a')] = find(e.charAt(0) - 'a');` (i.e. b merged into the group where a belongs to)\n parent[find(e.charAt(0)- 'a')] = find(e.charAt(3) - 'a');\n }\n }\n // handle != case\n for (String e : equations) {\n // if two characters are not equal\n // then which means their parent must not be equal\n if (e.charAt(1) == '!' && find(e.charAt(0) - 'a') == find(e.charAt(3) - 'a')) {\n return false;\n }\n }\n return true;\n }\n}" }, { "path": "990-satisfiability-of-equality-equations/NOTES.md", "content": "​" }, { "path": "990-satisfiability-of-equality-equations/README.md", "content": "

990. Satisfiability of Equality Equations

Medium

You are given an array of strings equations that represent relationships between variables where each string equations[i] is of length 4 and takes one of two different forms: \"xi==yi\" or \"xi!=yi\".Here, xi and yi are lowercase letters (not necessarily different) that represent one-letter variable names.

\n\n

Return true if it is possible to assign integers to variable names so as to satisfy all the given equations, or false otherwise.

\n\n

 

\n

Example 1:

\n\n
Input: equations = [\"a==b\",\"b!=a\"]\nOutput: false\nExplanation: If we assign say, a = 1 and b = 1, then the first equation is satisfied, but not the second.\nThere is no way to assign the variables to satisfy both equations.\n
\n\n

Example 2:

\n\n
Input: equations = [\"b==a\",\"a==b\"]\nOutput: true\nExplanation: We could assign a = 1 and b = 1 to satisfy both equations.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= equations.length <= 500
    • \n\t
  • equations[i].length == 4
    • \n\t
  • equations[i][0] is a lowercase letter.
    • \n\t
  • equations[i][1] is either '=' or '!'.
    • \n\t
  • equations[i][2] is '='.
    • \n\t
  • equations[i][3] is a lowercase letter.
    • \n
\n
" }, { "path": "991-broken-calculator/991-broken-calculator.java", "content": "class Solution {\n public int brokenCalc(int startValue, int target) {\n int ans = 0;\n while (target > startValue) {\n ans++;\n if (target % 2 == 1)\n target++;\n else\n target /= 2;\n }\n\n return ans + startValue - target;\n }\n}" }, { "path": "991-broken-calculator/NOTES.md", "content": "​" }, { "path": "991-broken-calculator/README.md", "content": "

991. Broken Calculator

Medium

There is a broken calculator that has the integer startValue on its display initially. In one operation, you can:

\n\n
    \n\t
  • multiply the number on display by 2, or
    • \n\t
  • subtract 1 from the number on display.
    • \n
\n\n

Given two integers startValue and target, return the minimum number of operations needed to display target on the calculator.

\n\n

 

\n

Example 1:

\n\n
Input: startValue = 2, target = 3\nOutput: 2\nExplanation: Use double operation and then decrement operation {2 -> 4 -> 3}.\n
\n\n

Example 2:

\n\n
Input: startValue = 5, target = 8\nOutput: 2\nExplanation: Use decrement and then double {5 -> 4 -> 8}.\n
\n\n

Example 3:

\n\n
Input: startValue = 3, target = 10\nOutput: 3\nExplanation: Use double, decrement and double {3 -> 6 -> 5 -> 10}.\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • 1 <= x, y <= 109
    • \n
\n
" }, { "path": "Add 1 to linked list.java", "content": "class Solution\n{\n public static Node addOne(Node head) \n { \n //code here.\n Node newHead=reverse(head);\n Node list=newHead;\n while(list!=null){\n if(list.data<9){\n list.data++;\n break;\n }else{\n if(list.next==null){\n list.next=new Node(0);\n }\n list.data=0;\n list=list.next;\n }\n }\n return reverse(newHead);\n \n }\n public static Node reverse(Node head){\n Node cur=head;\n Node prev=null;\n while(cur!=null){\n Node temp=cur.next;\n cur.next=prev;\n prev=cur;\n cur=temp;\n }\n return prev;\n }\n}\n" }, { "path": "Add Binary Strings.java", "content": "import java.math.BigInteger;\npublic class Solution {\n public String addBinary(String A, String B) {\n BigInteger a = new BigInteger(A, 2);\n BigInteger b = new BigInteger(B, 2);\n BigInteger c=a.add(b);\n return c.toString(2);\n }\n}\n\n==========================================================\n public class Solution {\n public String addBinary(String A, String B) {\n StringBuilder sb = new StringBuilder();\n int i = A.length() - 1;\n int j = B.length() - 1;\n int carry = 0;\n while(i>=0||j>=0){\n int sum = carry;\n if(i>=0) sum =sum+A.charAt(i)-'0';\n if(j>=0) sum += B.charAt(j)-'0';\n sb.append(sum%2);\n carry = sum/2;\n i--;j--;\n }\n if(carry!=0) sb.append(carry);\n return sb.reverse().toString();\n }\n}\n" }, { "path": "Add Digits.java", "content": "class Solution {\n public int addDigits(int num) {\n if(num % 9 == 0 && num != 0) return 9;\n return num % 9;\n }\n}\n" }, { "path": "Add One To Array.java", "content": "public class Solution {\n public int[] plusOne(int[] a) {\n //if all elements are 9 than increase size\n if(allNines(a)){\n int[]ans=new int[a.length+1];\n ans[0]=1;\n return ans;\n }else{\n // add 1 to specified position\n for(int i=a.length-1;i>=0;i--){\n if(a[i]+1<10){\n a[i]=a[i]+1;\n break;\n }else{\n a[i]=0;\n }\n }\n //check if there are preceding zeroes if yes then store index of first nonzero digit index\n int start=0;\n for(int i=0;i=0 || j>=0){\n int sum=carry;\n if(i>=0)sum+=a.charAt(i)-'0';\n if(j>=0)sum+=b.charAt(j)-'0';\n carry=sum>1? 1:0;\n sb.append(sum%2);\n i--;\n j--;\n }\n if(carry != 0) sb.append(carry);\n return sb.reverse().toString();\n }\n}\n" }, { "path": "Adding Array Elements.java", "content": "class Solution {\n int minOperations(int[] arr, int n, int k) {\n // code here\n if(n==1)return 0;\n PriorityQueue pq=new PriorityQueue<>();\n for(int i:arr)pq.add(i);\n int count=0;\n while(pq.size()>1){\n if(pq.peek()>=k)break;\n int f=pq.remove();\n int s=pq.remove();\n int sum=f+s;\n count++;\n pq.add(sum);\n }\n if(pq.peek()\n

You have got a maze, which is a n*n Grid. Every cell of the maze contains these numbers 1, 2 or 3. 
\nIf it contains 1 : means we can go Right from that cell only.
\nIf it contains 2 : means we can go Down from that cell only.
\nIf it contains 3 : means we can go Right and Down to both paths from that cell.
\nWe cant go out of the maze at any time.
\nInitially, You are on the Top Left Corner of The maze(Entry). And, You need to go to the Bottom Right Corner of the Maze(Exit).
\nYou need to find the total number of paths from Entry to Exit Point.
\nThere may be many paths but you need to select that path which contains the maximum number of Adventure.
\nThe Adventure on a path is calculated by taking the sum of all the cell values thatlies in the path.
\n 

\n\n

Example 1:

\n\n
Input: matrix = {{1,1,3,2,1},{3,2,2,1,2},\n{1,3,3,1,3},{1,2,3,1,2},{1,1,1,3,1}}\nOutput: {4,18}\nExplanation: There are total 4 Paths Available \nout of which The Max Adventure is 18. Total \npossible Adventures are 18,17,17,16. Of these \n18 is the maximum.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function FindWays() which takes matrix as input parameter and returns a list containg total number of ways to reach at (n, n) modulo 109 + 7 and maximum number of Adventure.
\n 

\n\n

Expected Time Complexity: O(n2)
\nExpected Space Complexity: O(n2)
\n 

\n\n

Constraints:
\n1 <= n <= 100 

\n

\n " }, { "path": "Adventure in a Maze - GFG/adventure-in-a-maze.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n int[][] matrix = new int[n][n];\n for(int i = 0; i < n; i++){\n String[] s = br.readLine().trim().split(\" \");\n for(int j = 0; j < n; j++)\n matrix[i][j] = Integer.parseInt(s[j]);\n }\n Solution obj = new Solution();\n int[] ans = obj.FindWays(matrix);\n for(int i = 0; i < ans.length; i++){\n System.out.print(ans[i] + \" \");\n }\n System.out.println();\n\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static int MOD = 1000000007;\n public int[] FindWays(int[][] matrix){\n int n = matrix.length;\n \n int max_dp[][] = new int[n][n];\n int count_dp[][] = new int[n][n];\n \n for(int i=n-1; i>=0; i--){\n for(int j=n-1; j>=0; j--){\n if(i==n-1 && j==n-1){\n count_dp[i][j] = 1;\n max_dp[i][j] = matrix[i][j];\n }else{\n int val = matrix[i][j];\n if(val==1){\n if(j+1\r\nusing namespace std;\r\n\r\n // } Driver Code Ends\r\n// User function Template for C++\r\n\r\nclass Solution{\r\nvoid solve(int i,vector> v,vector &vis,string &res){\r\n vis[i] = 1;\r\n \r\n for(auto a:v[i]){\r\n if(!vis[a])\r\n solve(a,v,vis,res);\r\n }\r\n \r\n char ch = i+'a';\r\n res =ch+res;\r\n }\r\n \r\n public:\r\n string findOrder(string dict[], int n, int k) {\r\n vector> v(k);\r\n int i,j;\r\n \r\n for(i=0;i vis(k,0);\r\n string res = \"\";\r\n \r\n \r\n for(i=0;i> t;\r\n while (t--) {\r\n int N, K;\r\n cin >> N >> K;\r\n string dict[N];\r\n for (int i = 0; i < N; i++) cin >> dict[i];\r\n \r\n Solution obj;\r\n string ans = obj.findOrder(dict, N, K);\r\n order = \"\";\r\n for (int i = 0; i < ans.size(); i++) order += ans[i];\r\n\r\n string temp[N];\r\n std::copy(dict, dict + N, temp);\r\n sort(temp, temp + N, f);\r\n\r\n bool f = true;\r\n for (int i = 0; i < N; i++)\r\n if (dict[i] != temp[i]) f = false;\r\n\r\n if(f)cout << 1;\r\n else cout << 0;\r\n cout << endl;\r\n }\r\n return 0;\r\n}\r\n // } Driver Code Ends\r\n" }, { "path": "All Elements in Two Binary Search Trees.java", "content": "class Solution {\n public List getAllElements(TreeNode root1, TreeNode root2) {\n LinkedList ret = new LinkedList<>();\n List ret2 = new ArrayList<>();\n \n dfs(root1, ret);\n dfs2(root2, ret2, ret);\n \n if (ret.size()>0) ret2.addAll(ret);\n return ret2;\n }\n \n private void dfs(TreeNode node, LinkedList ret) {\n if (node==null) return;\n if (node.left!=null) dfs(node.left, ret);\n ret.add(node.val);\n if (node.right!=null) dfs(node.right, ret);\n }\n \n private void dfs2(TreeNode node, List ret, LinkedList ex) {\n if (node==null) return;\n if (node.left!=null) dfs2(node.left, ret, ex);\n while(!ex.isEmpty() && ex.peekFirst() specialStrings(ArrayList A) {\n ArrayList ans=new ArrayList<>();\n dfs(ans,A,new StringBuilder());\n return ans;\n }\n void dfs(ArrayList ans,ArrayList arr,StringBuilder sb){\n if(sb.length()==arr.size()){\n ans.add(sb.toString());\n return;\n }\n String s=arr.get(sb.length());\n for(int i=0;i> lists;\n boolean[] added;\n\n public ArrayList> permute(ArrayList nums) {\n lists = new ArrayList<>();\n Collections.sort(nums);\n added = new boolean[nums.size()];\n permuteUnique(nums, new ArrayList<>());\n return lists;\n }\n\n private void permuteUnique(ArrayList nums, List list) {\n if(list.size() == nums.size()) {\n lists.add(new ArrayList(list));\n return;\n }\n for(int i = 0; i < nums.size(); i++) {\n if(added[i])\n continue;\n if(i > 0 && nums.get(i) == nums.get(i-1) && !added[i - 1])\n continue;\n list.add(nums.get(i));\n added[i] = true;\n permuteUnique(nums, list);\n list.remove(list.size() - 1);\n added[i] = false;\n }\n }\n}\n" }, { "path": "Allocate minimum number of pages.cpp", "content": "\nclass Solution \n{\n public:\n //Function to find minimum number of pages.\n bool allocationPoss(int p,int M,int A[],int n){\n int stds = 0, pages = p;\n for(int i=0;ip) return false;\n if(A[i]+pages>p){\n stds++;\n pages = A[i];\n }else pages+=A[i];\n \n if(stds>M) return false;\n }\n \n return true;\n }\n int findPages(int A[], int N, int M) \n {\n if(M>N) return -1;\n int start = A[0],end = A[0];\n for(int i=1;i st,st1;\n for(int i=n-1;i>=0;i--){\n if(arr[i]>=0) st.push(arr[i]);\n else st1.push(arr[i]);\n }\n for(int i=0;i=0){\n //need pos\n if(needNeg==false){\n needNeg=true;\n }else{\n //find neg\n int j=i+1;\n while(j=0){\n j++;\n }\n if(j==n)return;\n int ele=arr[j];\n j--;\n while(j>=i){\n arr[j+1]=arr[j];\n j--;\n }\n arr[i]=ele;\n needNeg=false;\n }\n }else{\n //needed neg\n if(needNeg==true){\n needNeg=false;\n }else{\n //find pos\n int j=i+1;\n while(j=i){\n arr[j+1]=arr[j];\n j--;\n }\n arr[i]=ele;\n needNeg=true;\n }\n }\n }\n }\n}\n" }, { "path": "Anagram of String.java", "content": "class GfG\n{\n\tpublic int remAnagrams(String s,String s1){\n //add code here.\n int[]fq=new int[26];\n for(char c:s.toCharArray()){\n fq[c-'a']++;\n }\n for(char c:s1.toCharArray()){\n fq[c-'a']--;\n }\n int ans=0;\n for(int i:fq){\n ans+=Math.abs(i);\n }\n return ans;\n }\n}\n" }, { "path": "Anagrams.java", "content": "public class Solution {\n // DO NOT MODIFY THE LIST. IT IS READ ONLY\n public ArrayList> anagrams(final List A) {\n ArrayList> ans=new ArrayList<>();\n HashMap,Integer> map=new HashMap<>();\n int listIndex=0;\n for(int i=0;i curr=new HashMap<>();\n for(char c:s.toCharArray())curr.put(c,curr.getOrDefault(c,0)+1);\n if(!map.containsKey(curr)){\n map.put(curr,listIndex);\n ans.add(new ArrayList<>());\n ans.get(listIndex).add(i+1);\n listIndex++;\n }else{\n int idx=map.get(curr);\n ans.get(idx).add(i+1);\n }\n }\n return ans;\n }\n}\n" }, { "path": "Anti Diagonals.py", "content": "class Solution:\n def diagonal(self, A):\n output=[]\n outputIndex=0\n # UPPER\n for i in range(0, len(A)):\n x = 0\n y = i\n output.append([])\n for j in range(i+1):\n output[outputIndex].append(A[x][y])\n x += 1\n y -= 1\n outputIndex += 1\n # LOWER\n for i in range(1, len(A)):\n x = i\n y = len(A) - 1\n output.append([]) \n for j in range(len(A)-i):\n output[outputIndex].append(A[x][y])\n x += 1\n y -= 1\n outputIndex += 1\n return output\n" }, { "path": "Arithmetic Slices.java", "content": "class Solution {\n public int numberOfArithmeticSlices(int[] nums) {\n int n = nums.length;\n if (n<3){\n return 0;\n }\n int ans=0;\n int[] dp = new int[n];\n for(int i=2;i A, final List B, final List C) {\n int diff = Integer.MAX_VALUE;\n int res_i =0, res_j = 0, res_k = 0;\n int i = 0, j = 0, k = 0;\n while (i < A.size() && j < B.size() && k < C.size()){\n int minimum = Math.min(A.get(i),\n Math.min(B.get(j), C.get(k)));\n int maximum = Math.max(A.get(i),\n Math.max(B.get(j), C.get(k)));\n // Update result if current diff is\n // less than the min diff so far\n if (maximum-minimum < diff){\n res_i = i;\n res_j = j;\n res_k = k;\n diff = maximum - minimum;\n }\n // We can't get less than 0\n // as values are absolute\n if (diff == 0) break;\n \n // Increment index of array\n // with smallest value\n if (A.get(i)== minimum) i++;\n else if (B.get(j) == minimum) j++;\n else k++;\n }\n \n int minimum = Math.min(A.get(res_i),\n Math.min(B.get(res_j), C.get(res_k)));\n int maximum = Math.max(A.get(res_i),\n Math.max(B.get(res_j), C.get(res_k)));\n return maximum-minimum;\n }\n \n public int abs(int a){\n if(a<0){\n return -a;\n }\n return a;\n }\n \n \n}\n\n" }, { "path": "Array Partition - GFG/README.md", "content": "# Array Partition\n## Hard \n
\n

Given an array of N integers, you have to find if it is possible to partition the array with following rules:

\n\n
    \n\t
  • Each element should belong to exactly one partition.
    • \n\t
  • Each partition should have atleast K elements.
    • \n\t
  • Absolute difference between any pair of elements in the same partition should not exceed M.
    • \n
\n\n

Example 1:

\n\n
Input:\nN = 5\nK = 2\nM = 3\nA[] = {8, 3, 9, 1, 2}\nOutput:\nYES\nExplanation:\nWe can partition the array into two \npartitions: {8, 9} and {3, 1, 2} such that\nall rules are satisfied.\n
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function partitionArray() which takes the number of elements N, integer K, integer M and array A[ ] as input parameters and returns true if we can partition the array such that all rules are satisfied, else returns false.

\n\n

Expected Time Complexity: O(N * Log(N))
\nExpected Auxiliary Space: O(N)

\n\n

Constraints:
\n1 ≤ N ≤ 2*105
\n1 ≤ K ≤ N
\n1 ≤ M ≤ 109
\n1 ≤ A[i] ≤ 109

\n

\n
" }, { "path": "Array Partition - GFG/array-partition.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nimport java.lang.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n \tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n \tint test = Integer.parseInt(br.readLine());\n \twhile(test-- > 0) {\n \t\tString [] str = br.readLine().trim().split(\" \");\n \t\tint N = Integer.parseInt(str[0]);\n \t\tint K = Integer.parseInt(str[1]);\n \t\tint M = Integer.parseInt(str[2]);\n \t\tint [] A = new int[N];\n \t\tstr = br.readLine().trim().split(\" \");\n \t\tfor(int i = 0; i < N; i++)\n \t\t\tA[i] = Integer.parseInt(str[i]);\n \t\tSolution obj = new Solution();\n \t\tboolean ans = obj.partitionArray(N, K, M, A);\n \t\tif(ans){\n System.out.println(\"YES\");\n }\n else{\n \tSystem.out.println(\"NO\");\n }\n \t}\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n boolean rec( int start , int[] A , int K , int M ){\n int n = A.length ;\n if(start >= n)\n return true ;\n for ( int i = start + K - 1 ; i < n ; i ++ ){\n if( (A[i] - A[start]) > M)\n return false ;\n if(rec(i+1 , A , K , M ))\n return true ;\n \n }\n return false ;\n }\n\tboolean partitionArray(int N, int K, int M, int [] A){\n // code here\n Arrays.sort(A);\n return rec(0 , A , K , M ) ; \n }\n}" }, { "path": "Array Sum.java", "content": "public class Solution {\n public int[] addArrays(int[] A, int[] B) {\n int n1=A.length;\n int n2=B.length;\n int[] sum = new int[n1>n2?n1:n2];\n int i=n1-1;\n int j=n2-1;\n int k=sum.length-1;\n\n int c=0;\n\n while(k>=0){\n int d = c;\n\n if(i>=0){\n d+=A[i];\n }\n\n if(j>=0){\n d+=B[j];\n }\n\n c=d/10;\n d=d%10;\n\n sum[k]=d;\n\n i--;\n j--;\n k--;\n }\n\n if(c!=0){\n int[] ans = new int[(n1>n2?n1:n2) + 1];\n ans[0]=c;\n for (i = 0; i < ans.length-1; i++)\n ans[i+1] = sum[i];\n \n return ans;\n }\n return sum;\n }\n}\n" }, { "path": "Array to BST - GFG/README.md", "content": "# Array to BST\n## Easy \n
\n

Given a sorted array. Convert it into a Height balanced Binary Search Tree (BST). Find the preorder traversal of height balanced BST. If there exist many such balanced BST consider the tree whose preorder is lexicographically smallest.
\nHeight balanced BST means a binary tree in which the depth of the left subtree and the right subtree of every node never differ by more than 1.

\n\n

Example 1:

\n\n
Input: nums = {1, 2, 3, 4}\nOutput: {2, 1, 3, 4}\nExplanation: \nThe preorder traversal of the following \nBST formed is {2, 1, 3, 4}:\n           2\n         /   \\\n           1     3\n               \\\n                4\n
\n\n

 

\n\n

Example 2:

\n\n
Input: nums = {1,2,3,4,5,6,7}\nOuput: {4,2,1,3,6,5,7}\nExplanation: \nThe preorder traversal of the following\nBST formed is {4,2,1,3,6,5,7} :\n        4\n       / \\\n      2   6\n     / \\  / \\\n    1   3 5  7\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function sortedArrayToBST() which takes the sorted array nums as input paramater and returns the preorder traversal of height balanced BST. If there exist many such balanced BST consider the tree whose preorder is lexicographically smallest.

\n\n

Expected Time Complexity: O(n)
\nExpected Space Complexity: O(n)

\n\n

Constraints:
\n1 ≤ |nums| ≤ 104
\n-104 ≤ nums[i] ≤ 104
\n 

\n

\n
" }, { "path": "Array to BST - GFG/array-to-bst.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n int[] nums = new int[n];\n String[] S = br.readLine().trim().split(\" \");\n for(int i = 0; i < n; i++){\n nums[i] = Integer.parseInt(S[i]);\n }\n Solution obj = new Solution();\n int[] ans = obj.sortedArrayToBST(nums);\n for(int i = 0; i < ans.length; i++)\n System.out.print(ans[i] + \" \");\n System.out.println();\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n public void fillArray(int[] res,int[] n, int s, int e, int[] i){\n if(s>e)return;\n int mid=s+(e-s)/2;\n res[i[0]]=n[mid];\n i[0]++; \n fillArray(res,n,s,mid-1,i);\n fillArray(res,n,mid+1,e,i);\n }\n public int[] sortedArrayToBST(int[] n){\n int[] res=new int[n.length], i=new int[1];\n int s=0,e=n.length-1;\n fillArray(res,n,s,e,i);\n return res;\n }\n}" }, { "path": "Assign Mice to Holes.java", "content": "public class Solution {\n public int mice(int[] A, int[] B) {\n\t\tArrays.sort(A);\n\t\tArrays.sort(B);\n\t\tint ans=0;\n\t\tfor(int i=0;i\n

You are the head of a firm and you have to assign jobs to people. You have N persons working under you and you have N jobs that are to be done by these persons. Each person has to do exactly one job and each job has to be done by exactly one person. Each person has his own capability (in terms of time taken) to do any particular job. Your task is to assign the jobs to the persons in such a way that the total time taken is minimum. A job can be assigned to only one person and a person can do only one job.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 2\nArr[] = {3, 5, 10, 1}\nOutput:\n4\nExplanation:\nThe first person takes times 3 and 5\nfor jobs 1 and 2 respectively. The second\nperson takes times 10 and 1 for jobs 1 and\n2 respectively. We can see that the optimal\nassignment will be to give job 1 to person 1\nand job 2 to person 2 for a total for 3+1 = 4.
\n\n

Example 2:

\n\n
Input:\nN = 3\nArr[] = {2, 1, 2, 9, 8, 1, 1, 1, 1}\nOutput:\n3 \nExplanation: \nThe optimal arrangement would be to assign \njob 1 to person 3,job 2 to person 1 and job \n3 to person 2.
\n\n

 

\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function assignmentProblem() which takes an Integer N and an array Arr[] of size N2 as input and returns the time taken for the best possible assignment.

\n\n

 

\n\n

Expected Time Complexity: O(N2)
\nExpected Auxiliary Space: O(N2)

\n\n

 

\n\n

Constraints:
\n1 <= N <= 30
\n1 <= Arr[i] <= 100

\n

\n " }, { "path": "Assignment Problem - GFG/assignment-problem.cpp", "content": "// { Driver Code Starts\n#include \nusing namespace std;\n\n // } Driver Code Ends\nclass Solution {\n public:\n \n int cost[31][31]; //cost matrix\n int n, max_match; //n workers and n jobs\n int lx[31], ly[31]; //labels of X and Y parts\n int xy[31]; //xy[x] - vertex that is matched with x,\n int yx[31]; //yx[y] - vertex that is matched with y\n bool S[31], T[31]; //sets S and T in algorithm\n int slack[31]; //as in the algorithm description\n int slackx[31]; //slackx[y] such a vertex, that\n int prev_ious[31]; //array for memorizing alternating p\n \n void init_labels()\n {\n memset(lx, 0, sizeof(lx));\n memset(ly, 0, sizeof(ly));\n for (int x = 0; x < n; x++)\n for (int y = 0; y < n; y++)\n lx[x] = max(lx[x], cost[x][y]);\n }\n \n \n void update_labels()\n {\n int x, y;\n int delta = 99999999; //init delta as infinity\n for (y = 0; y < n; y++) //calculate delta using slack\n if (!T[y])\n delta = min(delta, slack[y]);\n for (x = 0; x < n; x++) //update X labels\n if (S[x])\n lx[x] -= delta;\n for (y = 0; y < n; y++) //update Y labels\n if (T[y])\n ly[y] += delta;\n for (y = 0; y < n; y++) //update slack array\n if (!T[y])\n slack[y] -= delta;\n }\n \n \n void add_to_tree(int x, int prev_iousx) \n //x - current vertex,prev_iousx - vertex from X before x in the alternating path,\n //so we add edges (prev_iousx, xy[x]), (xy[x], x)\n {\n S[x] = true; //add x to S\n prev_ious[x] = prev_iousx; //we need this when augmenting\n for (int y = 0; y < n; y++) //update slacks, because we add new vertex to S\n if (lx[x] + ly[y] - cost[x][y] < slack[y])\n {\n slack[y] = lx[x] + ly[y] - cost[x][y];\n slackx[y] = x;\n }\n }\n \n \n \n void augment() //main function of the algorithm\n {\n if (max_match == n) return; //check wether matching is already perfect\n int x, y, root; //just counters and root vertex\n int q[31], wr = 0, rd = 0; //q - queue for bfs, wr,rd - write and read\n //pos in queue\n memset(S, false, sizeof(S)); //init set S\n memset(T, false, sizeof(T)); //init set T\n memset(prev_ious, -1, sizeof(prev_ious)); //init set prev_ious - for the alternating tree\n \n for (x = 0; x < n; x++) //finding root of the tree\n {\n if (xy[x] == -1)\n {\n q[wr++] = root = x;\n prev_ious[x] = -2;\n S[x] = true;\n break;\n }\n }\n \n for (y = 0; y < n; y++) //initializing slack array\n {\n slack[y] = lx[root] + ly[y] - cost[root][y];\n slackx[y] = root;\n }\n \n //second part of augment() function\n while (true) //main cycle\n {\n while (rd < wr) //building tree with bfs cycle\n {\n x = q[rd++]; //current vertex from X part\n for (y = 0; y < n; y++) //iterate through all edges in equality graph\n if (cost[x][y] == lx[x] + ly[y] && !T[y])\n {\n if (yx[y] == -1) break; //an exposed vertex in Y found, so\n //augmenting path exists!\n T[y] = true; //else just add y to T,\n q[wr++] = yx[y]; //add vertex yx[y], which is matched\n //with y, to the queue\n add_to_tree(yx[y], x); //add edges (x,y) and (y,yx[y]) to the tree\n }\n if (y < n)\n break; //augmenting path found!\n }\n if (y < n)\n break; //augmenting path found!\n \n update_labels(); //augmenting path not found, so improve labeling\n \n wr = rd = 0; \n for (y = 0; y < n; y++) \n //in this cycle we add edges that were added to the equality graph as a\n //result of improving the labeling, we add edge (slackx[y], y) to the tree if\n //and only if !T[y] && slack[y] == 0, also with this edge we add another one\n //(y, yx[y]) or augment the matching, if y was exposed\n if (!T[y] && slack[y] == 0)\n {\n if (yx[y] == -1) //exposed vertex in Y found - augmenting path exists!\n {\n x = slackx[y];\n break;\n }\n else\n {\n T[y] = true; //else just add y to T,\n if (!S[yx[y]]) \n {\n q[wr++] = yx[y]; //add vertex yx[y], which is matched with\n //y, to the queue\n add_to_tree(yx[y], slackx[y]); //and add edges (x,y) and (y,\n //yx[y]) to the tree\n }\n }\n }\n if (y < n) break; //augmenting path found!\n }\n \n if (y < n) //we found augmenting path!\n {\n max_match++; //increment matching\n //in this cycle we inverse edges along augmenting path\n for (int cx = x, cy = y, ty; cx != -2; cx = prev_ious[cx], cy = ty)\n {\n ty = xy[cx];\n yx[cy] = cx;\n xy[cx] = cy;\n }\n augment(); //recall function, go to step 1 of the algorithm\n }\n }//end of augment() function\n \n int hungarian()\n {\n int ret = 0; //weight of the optimal matching\n max_match = 0; //number of vertices in current matching\n memset(xy, -1, sizeof(xy)); \n memset(yx, -1, sizeof(yx));\n init_labels(); //step 0\n augment(); //steps 1-3\n \n for (int x = 0; x < n; x++) //forming answer there\n ret += cost[x][xy[x]];\n \n return ret;\n }\n \n int assignmentProblem(int Arr[], int N) {\n \n n = N;\n for(int i=0; i> t;\n while (t--) {\n int n;\n cin>>n;\n \n int Arr[n*n];\n for(int i=0; i>Arr[i];\n\n Solution ob;\n cout << ob.assignmentProblem(Arr,n) << endl;\n }\n return 0;\n} // } Driver Code Ends" }, { "path": "Assignment Problem - GFG/assignment-problem.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n String S[] = read.readLine().split(\" \");\n \n int[] Arr = new int[N*N];\n \n for(int i=0; i0){\n for(int col=0;col averageOfLevels(TreeNode* root) {\n vector ans;\n queue q;\n q.push(root);\n \n // while there are nodes remaining to be visited\n while(!q.empty()){\n double temp = q.size();\n double sum = 0;\n // iterating each level of binary tree\n for(int i = 0; i < temp; i++){\n auto tt = q.front();\n q.pop();\n sum += (tt->val);\n\t\t\t\t// check for not NULL and pushing into queue.\n if(tt->left){\n q.push(tt->left);\n }\n if(tt->right){\n q.push(tt->right);\n }\n }\n ans.push_back(sum/ temp);\n }\n return ans;\n }\n};\n" }, { "path": "Average of levels in binary tree.java", "content": "class Solution {\n public List averageOfLevels(TreeNode root) {\n List result=new ArrayList<>();\n Queue que=new LinkedList<>();\n que.add(root);\n while(!que.isEmpty()){\n int size=que.size();\n double sum=0;\n for(int i=0;i&pq)\n {\n if(!root)\n return;\n \n pq.push(root->data);\n recur(root->left,pq);\n recur(root->right,pq);\n\n }\n void change(Node *root,priority_queue&pq)\n {\n if(!root or pq.empty())\n return;\n \n root->data=pq.top();\n pq.pop();\n change(root->right,pq);\n change(root->left,pq);\n \n }\n void convertToMaxHeapUtil(Node* root)\n {\n // Your code goes here\n priority_queuepq;\n recur(root,pq);\n \n change(root,pq);\n } \n};\n" }, { "path": "BST to greater sum tree - GFG/README.md", "content": "# BST to greater sum tree\n## Medium \n
\n

Given a BST, transform it into greater sum tree where each node contains sum of all nodes greater than that node.

\n\n

Example 1:

\n\n
Input:\n           2\n         /    \\\n        1      6\n              /  \\\n             3    7\nOutput: 18 16 13 7 0\nExplanation:\nEvery node is replaced with the \nsum of nodes greater than itself. \nThe resultant tree is:\n               16\n             /    \\\n           18       7\n                  /   \\\n                 13    0\n
\n\n

Example 2:

\n\n
Input:\n          2\n         /\n        1\nOutput: 2 0\nExplanation:\nThe resultant tree is :\n             0\n            /\n          2\n
\n\n
Your task :
\n\n
You don't have to read input or print anything. Your task is to complete the function transformTree() which takes the root of the tree as input and transforms the BST to a greater sum tree.
\n\n
Note : The driver code prints the inorder traversal of the transformed BST.
\n\n
 
\n\n
Expected Time Complexity: O(N), N = number of nodes
\n\n
Expected Auxiliary Space: O(N), N = number of nodes
\n\n
 
\n\n
Constraints :
\n\n
1 ≤ N ≤ 104
\n

\n
" }, { "path": "BST to greater sum tree - GFG/bst-to-greater-sum-tree.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.LinkedList; \nimport java.util.Queue; \nimport java.io.*;\nimport java.util.*;\n\nclass Node{\n int data;\n Node left;\n Node right;\n Node(int data){\n this.data = data;\n left=null;\n right=null;\n }\n}\n\nclass Tree {\n \n static Node buildTree(String str){\n \n if(str.length()==0 || str.charAt(0)=='N'){\n return null;\n }\n \n String ip[] = str.split(\" \");\n // Create the root of the tree\n Node root = new Node(Integer.parseInt(ip[0]));\n // Push the root to the queue\n \n Queue queue = new LinkedList<>(); \n \n queue.add(root);\n // Starting from the second element\n \n int i = 1;\n while(queue.size()>0 && i < ip.length) {\n \n // Get and remove the front of the queue\n Node currNode = queue.peek();\n queue.remove();\n \n // Get the current node's value from the string\n String currVal = ip[i];\n \n // If the left child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the left child for the current node\n currNode.left = new Node(Integer.parseInt(currVal));\n // Push it to the queue\n queue.add(currNode.left);\n }\n \n // For the right child\n i++;\n if(i >= ip.length)\n break;\n \n currVal = ip[i];\n \n // If the right child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the right child for the current node\n currNode.right = new Node(Integer.parseInt(currVal));\n \n // Push it to the queue\n queue.add(currNode.right);\n }\n i++;\n }\n \n return root;\n }\n static void inOrder(Node root)\n {\n if(root == null)\n return;\n \n inOrder(root.left);\n System.out.print(root.data+\" \");\n inOrder(root.right);\n \n \n }\n \n\tpublic static void main (String[] args) throws IOException{\n\t BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t \n\t int t=Integer.parseInt(br.readLine());\n \n\t while(t > 0){\n\t String s = br.readLine();\n \t \tNode root = buildTree(s);\n \t \t\n Solution g = new Solution();\n g.transformTree(root);\n inOrder(root);\n \n System.out.println();\n \n t--;\n \n }\n }\n}\n\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\n/*class Node{\n int data;\n Node left;\n Node right;\n Node(int data){\n this.data = data;\n left=null;\n right=null;\n }\n} */\nclass Solution\n{\n static int sum;\n public static void transformTree (Node root)\n {\n //code here\n sum=0;\n dfs(root);\n }\n static void dfs(Node root){\n if(root==null)return;\n dfs(root.right);\n int temp=root.data;\n root.data=sum;\n sum+=temp;\n dfs(root.left);\n }\n}" }, { "path": "BST to max heap GFG/BstToMaxHeap.cpp", "content": "\n void helper1(Node *root,vector&ans){\n if(root==NULL){\n return;\n }\n helper1(root->left,ans);\n ans.push_back(root->data);\n helper1(root->right,ans);\n }\n \n void helper2(Node *root,vector&ans,int &index){\n if(root==NULL)return;\n helper2(root->left,ans,index);\n helper2(root->right,ans,index);\n root->data=ans[index];\n index++;\n \n \n }\n void convertToMaxHeapUtil(Node* root)\n {\n \n vectorans;\n helper1(root,ans);\n int index=0;\n helper2(root,ans,index);\n \n } \n" }, { "path": "BST to max heap gfg med.cpp", "content": "//{ Driver Code Starts\n//Initial Template for C++\n\n#include \nusing namespace std;\n\nstruct Node {\n int data;\n Node *left, *right;\n};\n\n/* Helper function that allocates a new node\nwith the given data and NULL left and right\npointers. */\nNode* newNode(int val)\n{\n Node* temp = new Node;\n temp->data = val;\n temp->left = NULL;\n temp->right = NULL;\n\n return temp;\n}\n\nNode* buildTree(string str)\n{\n // Corner Case\n if (str.length() == 0 || str[0] == 'N')\n return NULL;\n\n // Creating vector of strings from input\n // string after spliting by space\n vector ip;\n\n istringstream iss(str);\n for (string str; iss >> str; )\n ip.push_back(str);\n\n // Create the root of the tree\n Node* root = newNode(stoi(ip[0]));\n\n // Push the root to the queue\n queue queue;\n queue.push(root);\n\n // Starting from the second element\n int i = 1;\n while (!queue.empty() && i < ip.size()) {\n\n // Get and remove the front of the queue\n Node* currNode = queue.front();\n queue.pop();\n\n // Get the current node's value from the string\n string currVal = ip[i];\n\n // If the left child is not null\n if (currVal != \"N\") {\n\n // Create the left child for the current node\n currNode->left = newNode(stoi(currVal));\n\n // Push it to the queue\n queue.push(currNode->left);\n }\n\n // For the right child\n i++;\n if (i >= ip.size())\n break;\n currVal = ip[i];\n\n // If the right child is not null\n if (currVal != \"N\") {\n\n // Create the right child for the current node\n currNode->right = newNode(stoi(currVal));\n\n // Push it to the queue\n queue.push(currNode->right);\n }\n i++;\n }\n\n return root;\n}\nvoid postorderTraversal(Node* root)\n{\n if (!root)\n return;\n\n // recur on left subtree\n postorderTraversal(root->left);\n\n // then recur on right subtree\n postorderTraversal(root->right);\n\n // print the root's data\n cout << root->data << \" \";\n}\nclass Solution{\n public:\n vector v;\n int i =0;\n void postorder(Node* root){\n if(!root) return;\n postorder(root->left);\n postorder(root->right);\n root->data = v[i++];\n }\n void inorder(Node *root){\n if(!root) return;\n inorder(root->left);\n v.push_back(root->data);\n inorder(root->right);\n }\n void convertToMaxHeapUtil(Node* root)\n {\n // Your code goes here\n inorder(root);\n postorder(root);\n } \n};\nint main()\n{\n int t;\n cin >> t;\n getchar();\n while (t--)\n {\n string inp, ch;\n getline(cin, inp);\n struct Node* root = buildTree(inp);\n Solution ob;\n ob.convertToMaxHeapUtil(root);\n postorderTraversal(root);\n cout << \"\\n\";\n }\n return 0;\n}" }, { "path": "BST-to-max-Heap/BSTtoMaxHeap.java", "content": "class Solution\n{\n static int i=0;\n public static void convertToMaxHeapUtil(Node root)\n {\n //code here\n ArrayList nodes=new ArrayList<>();\n i=0;\n inOrder(root, nodes);\n }\n \n public static void inOrder(Node root, ArrayList nodes) {\n if(root==null) return ;\n \n inOrder(root.left, nodes);\n nodes.add(root.data); //adding data to ArrayList stores in Ascending order\n inOrder(root.right, nodes);\n root.data=nodes.get(i++); //Modifying root value in postOrder Traversal, so that All Left and Right Nodes store lesser value compared to root as ArrayList stores in Ascending Order\n }\n \n}\n" }, { "path": "BST-to-max-Heap/Solution.cpp", "content": "class Solution{\n\n public:\n\n Node* helper(Node* root){\n\n if(!root)return NULL;\n\n Node* left=helper(root->left);\n\n Node* right=helper(root->right);\n\n if(!left&&!right)return root;\n\n if(!left&&right){\n\n if(right->data>root->data){swap(root->data,right->data);helper(root->right);} \n\n }\n\n else if(left&&!right){\n\n if(left->data>root->data){swap(root->data,left->data); helper( root->left);}\n\n }\n\n else{\n\n if(left->data>root->data){swap(root->data,left->data); helper( root->left);}\n\n if(right->data>root->data){swap(root->data,right->data);helper(root->right);}\n\n }\n\n return root;\n\n }\n\n void convertToMaxHeapUtil(Node* root)\n\n {\n\n helper(root);\n\n } \n\n};" }, { "path": "BST-to-max-Heap/question.md", "content": "### BST to max heap\n\n**Medium**Accuracy: **70.68%**Submissions: **4473**Points: **4**\n\nGiven a Binary Search Tree. Convert a given BST into a Special Max Heap with the condition that all the values in the left subtree of a node should be less than all the values in the right subtree of the node. This condition is applied on all the nodes in the so converted Max Heap.\n\n**Example 1:**\n\n```\nInput :\n 4\n / \\\n 2 6\n / \\ / \\\n 1 3 5 7 \n\nOutput : 1 2 3 4 5 6 7 \nExaplanation :\n 7\n / \\\n 3 6\n / \\ / \\\n 1 2 4 5\nThe given BST has been transformed into a\nMax Heap and it's postorder traversal is\n1 2 3 4 5 6 7.\n```\n\n**Your task :**\n\nYou don't need to read input or print anything. Your task is to complete the function convertToMaxHeapUtil() which takes the root of the tree as input and converts the BST to max heap.\n\nNote : The driver code prints the postorder traversal of the converted BST.\n\n**Expected Time Complexity : **O(n)\n\n**Expected Auxiliary Space : **O(n)\n\n**Constraints :**\n\n1 ≤ n ≤ 10^5^\n" }, { "path": "Bag Of Tokens.java", "content": "class Solution {\n public int bagOfTokensScore(int[] tokens, int power) {\n int ans=0;\n Arrays.sort(tokens); //sorted the tokens as in question they mentioned to take in any order\n int i=0, j=tokens.length-1, steps=0;\n while(i<=j) {\n if(tokens[i]<=power) { //if current value is less than equal to power we reduce power and increase steps \n power-=tokens[i]; \n steps+=1;\n i+=1;\n }\n else { //else we need to increase power to continue further\n if(steps>0) { //if steps > 0, we can increase power and reduces steps by 1\n power+=tokens[j];\n j-=1;\n steps-=1;\n }\n else { // if steps ==0 , we cannot increase power according to question and we cannot increase power. As array is sorted, we cannot increase steps as power is less than all other tokens hence break loop\n break;\n } \n } \n ans=Math.max(ans, steps); // At each step calculate max Ans as we no need to consider all the tokens\n }\n return ans;\n \n }\n}\n" }, { "path": "Balance Array.java", "content": "class Solution:\n # @param A : list of integers\n # @return an integer\n def solve(self, A):\n arr=A\n s1=0\n s2=0\n n=len(A)\n s3=0\n s4=0\n for i in range(n):\n if i%2:\n s2+=arr[i]\n else:\n s1+=arr[i]\n c=0\n for i in range(n):\n if i%2:\n s2-=arr[i]\n if s2+s4==s1+s3:\n c+=1\n s3+=arr[i]\n else:\n s1-=arr[i]\n if s2+s4==s3+s1:\n c+=1\n s4+=arr[i]\n return c\n" }, { "path": "Balanced Binary Tree.java", "content": "public class Solution {\n public int isBalanced(TreeNode A) {\n if(A==null)\n return 1;\n Queue queue=new LinkedList<>();\n queue.add(A);\n while(!queue.isEmpty()){\n TreeNode current=queue.remove();\n if(Math.abs(getHeight(current.left)-getHeight(current.right))>1)\n return 0;\n\n if(current.left!=null)\n queue.add(current.left);\n if(current.right!=null)\n queue.add(current.right);\n }\n return 1; \n}\n\n\n int getHeight(TreeNode root){\n if(root==null)\n return -1;\n else\n return 1+Math.max(getHeight(root.left),getHeight(root.right));\n }\n}\n" }, { "path": "Balanced Parantheses!.java", "content": "public class Solution {\n public int solve(String A) {\n ArrayDeque st=new ArrayDeque<>();\n for(int i=0;i0)return 0;\n return 1;\n }\n}\n" }, { "path": "Ball Coloring.cpp", "content": "class Solution {\n public:\n unsigned long long int noOfWays(unsigned long long int n){\n // code here\n if(n<3){\n return n*2;\n }\n else{\n return ((n*n)-(n-2));\n }\n }\n};\n" }, { "path": "Ball coloring.cpp", "content": "class Solution {\n public:\n unsigned long long int noOfWays(unsigned long long int n){\n // code here\n if(n<3){\n return n*2;\n }\n else{\n return ((n*n)-(n-2));\n }\n }\n};\n" }, { "path": "Ball coloring.java", "content": "class Solution {\n static long noOfWays(long n){\n // code here\n return 2 + n * (n - 1);\n }\n}\n" }, { "path": "Ball coloring.py", "content": "class Solution:\n def noOfWays (self, n):\n return (n*(n-1))+2;\n" }, { "path": "Ball-Coloring/ball_coloring.java", "content": "class Solution{\n static long noOfWays(long n){\n // code here\n return (n*(n-1)+2);\n }\n}\n" }, { "path": "Ball-Coloring/question.md", "content": "Given n balls . All of them are initially uncolored . You have to color the balls with two colors RED and BLUE such that there can be atmost 2 positions where a RED ball is touching BLUE ball or vice versa. You have to color all the balls.Find the number of ways in which balls can be colored.\n\n**Example 1:**\n\n```\nInput: n = 1\nOutput: 2\nExplanation: Possible ways to color are {{R},{B}}. \nSo the answer is 2 .\n```\n\n**Example 2:**\n\n```\nInput: n = 2\nOutput: 4\nExplanation: Possible ways to color are \n{{RB},{BR},{RR},{BB}}.So the answer is 4.\n```\n\n**Your Task: **\nYou dont need to read input or print anything. Complete the function **noOfWays() **which takes n as input parameter and returns the number of ways in which balls can be colored.\n\n**Expected Time Complexity:** O(1)\n**Expected Auxiliary Space:** O(1)\n\n**Constraints:**\n1<= n <=10^5^\n" }, { "path": "Best Time to Buy and Sell Stock IV.java", "content": "class Solution {\n public int maxProfit(int k, int[] prices) {\n int [][][]dp=new int[k+1][prices.length+1][2];\n for(int i=0;i=prices.length) return 0;\n if(k==0) return 0;\n \n if(dp[k][ind][buy]!=-1) {\n return dp[k][ind][buy];\n }\n int ans1=0, ans2=0, ans3=0, ans4=0;\n if(buy==0) {\n ans1=maximumProfit(prices, k, ind+1, buy, dp); //not buying in this index and continuing\n ans2=-prices[ind]+maximumProfit(prices, k, ind+1, 1, dp); //buying at this index by passing 1 by subtracting the current amount and continuing\n }\n else {\n ans3=maximumProfit(prices, k, ind+1, buy, dp); //not selling at this index and continuing\n ans4=(prices[ind])+maximumProfit(prices, k-1, ind+1, 0, dp); //selling at this index by adding current index amount and reducing transactions by 1 and continuing\n }\n return dp[k][ind][buy]=Math.max(ans1, Math.max(ans2, Math.max(ans3, ans4))); // taking maximum of all these combinations\n \n }\n}\n" }, { "path": "Best Time to Buy and Sell Stock.java", "content": "class Solution {\n public int maxProfit(int[] prices) {\n int min=Integer.MAX_VALUE;\n int max=0;\n for(int i=0;i\n

Geek is organising a bike race with N bikers. The initial speed of the ith biker is denoted by Hi Km/hr and the acceleration of ith biker as Ai Km/Hr2. A biker whose speed is 'L' or more, is considered be a fast biker. The total speed on the track for every hour is calculated by adding the speed of each fast biker in that hour. When the total speed on the track is 'M' kilometers per hour or more, the safety alarm turns on. 
\nFind the minimum number of hours after which the safety alarm will start.

\n\n


\nExample 1:

\n\n
Input: \nN = 3, M = 400, L = 120\nH = {20, 50, 20}\nA = {20, 70, 90}\nOutput: 3\nExplaination: \nSpeeds of all the Bikers at ith hour\nBiker1= [20  40  60  80 100] \nBiker2= [50 120 190 260 330]\nBiker3= [20 110 200 290 380] \n\nInitial Speed on track  = 0 \nbecause none of the biker's speed is fast enough.\nSpeed on track after 1st Hour= 120\nSpeed on track after 2nd Hour= 190+200=390\nSpeed on track after 3rd Hour= 260+290=550\nAlarm will start at 3rd Hour.
\n\n


\nExample 2:

\n\n
Input: \nN = 2, M = 60, L = 120\nH = {50, 30}\nA = {20, 40}\nOutput: 3\nExplaination: \nSpeeds of all the Bikers at ith hour\nBiker1= [50 70  90 110 130] \nBiker2= [30 70 110 150 190]\n\nInitial Speed on track = 0 because none of the \nbiker's speed is fast enough.\nSpeed on track at 1st Hour= 0\nSpeed on track at 2nd Hour= 0\nSpeed on track at 3rd Hour= 150\nAlarm will buzz at 3rd Hour.
\n\n


\nYour Task:
\nYou do not need to read input or print anything. Your task is to complete the function buzzTime() which takes N, M, L and array H and array A as input parameters and returns the time when alarm buzzes.

\n\n


\nExpected Time Complexity: O(N*log(max(L,M)))
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 ≤ N ≤ 105
\n1 ≤ L, M ≤ 1010
\n1 ≤ Hi, Ai ≤ 109  

\n

\n " }, { "path": "Bike Racing - GFG/bike-racing.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException{\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(a[0]);\n long M = Long.parseLong(a[1]);\n long L = Long.parseLong(a[2]);\n long H[] = new long[N];\n long A[] = new long[N];\n for(int i = 0; i < N; i++){\n String a1[] = in.readLine().trim().split(\"\\\\s+\");\n H[i] = Long.parseLong(a1[0]);\n A[i] = Long.parseLong(a1[1]);\n }\n \n Solution ob = new Solution();\n System.out.println(ob.buzzTime(N, M, L, H, A));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static boolean check(long T, long L, long S[], long A[], long N, long M){\n\n long ans = 0;\n\n for(int i=0;i=L ? x : 0);\n\n }\n return ans >= M;\n\n }\n\n static long buzzTime(long N, long M, long L, long H[], long A[])\n\n {\n\n long low,high,mid;\n low = 0;\n high = M;\n\n \n\n while(low largestSquare(ArrayList> M, int R, int C, int K, int Q, int[] q_i, int[] q_j) {\n // code here\n ArrayList ans=new ArrayList<>();\n int[][]dp=new int[R][C];\n dp[0][0]=M.get(0).get(0);\n \n for(int i=1;i0)count-=dp[x2][y1-1];\n if(x1>0)count-=dp[x1-1][y2];\n if(x1>0 && y1>0)count+=dp[x1-1][y1-1];\n \n if(count<=K){\n curr=2*k+1;\n l=k+1;\n }else{\n h=k-1;\n }\n }\n ans.add(curr);\n }\n return ans;\n }\n};\n" }, { "path": "Binary Tree Pruning lc.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n// TC: O(N) where N is the number of the nodes in the tree\n// SC: O(H) where H is the height of the tree\n// In worse case, H can be N when it is a left skewed binary tree / right skewed binary tree\n TreeNode* pruneTree(TreeNode* root) {\n// if root is nullptr, then return nullptr\n if(!root) return nullptr;\n// DFS on left sub tree\n root->left = pruneTree(root->left);\n// DFS on right sub tree\n root->right = pruneTree(root->right);\n// !root->left means left sub tree does not contain 1\n// !root->right means right sub tree does not contain 1\n// !root->val means curr_node val is 0\n// for this case , return nullptr else keep node\n return(!root->left && !root->right && !root->val) ? nullptr : root;\n }\n};\n\n" }, { "path": "Binary Tree Pruning.java", "content": "class Solution {\n public TreeNode pruneTree(TreeNode root) {\n make(root); //In this function checked all childs of root, whether they contain root node 1 as sub tree, if does not exist removed the node\n if(root.left==null && root.right==null && root.val==0) return null; // This is the case when only single node present and it is 0 In that case we should return null\n return root;\n }\n public boolean make(TreeNode root) {\n if(root==null) return false;\n \n boolean left=make(root.left);\n boolean right=make(root.right);\n \n if(left==false) {\n if(root.left!=null) root.left=null;\n }\n \n if(right==false) {\n if(root.right!=null) root.right=null;\n }\n \n if(left==true || right==true) return true;\n \n if(root.val==1) return true;\n \n return false;\n }\n}\n" }, { "path": "Bipartite Graph - GFG/README.md", "content": "# Bipartite Graph\n## Medium \n
\n

Given an adjacency list of a graph adj  of V no. of vertices having 0 based index. Check whether the graph is bipartite or not.
\n 

\n\n

Example 1:

\n\n
Input: \n\"\"\nOutput: 1\nExplanation: The given graph can be colored \nin two colors so, it is a bipartite graph.\n
\n\n

Example 2:

\n\n
Input:\n\"\"\nOutput: 0\nExplanation: The given graph cannot be colored \nin two colors such that color of adjacent \nvertices differs. \n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function isBipartite() which takes V denoting no. of vertices and adj denoting adjacency list of the graph and returns a boolean value true if the graph is bipartite otherwise returns false.
\n 

\n\n

Expected Time Complexity: O(V + E)
\nExpected Space Complexity: O(V)
\n
\nConstraints:
\n1 ≤ V, E ≤ 105

\n

\n
" }, { "path": "Bipartite Graph - GFG/bipartite-graph.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String[] S = br.readLine().trim().split(\" \");\n int V = Integer.parseInt(S[0]);\n int E = Integer.parseInt(S[1]);\n ArrayList> adj = new ArrayList<>();\n for(int i = 0; i < V; i++){\n adj.add(new ArrayList());\n }\n for(int i = 0; i < E; i++){\n String[] s = br.readLine().trim().split(\" \");\n int u = Integer.parseInt(s[0]);\n int v = Integer.parseInt(s[1]);\n adj.get(u).add(v);\n adj.get(v).add(u);\n }\n Solution obj = new Solution();\n boolean ans = obj.isBipartite(V, adj);\n if(ans)\n System.out.println(\"1\");\n else System.out.println(\"0\");\n }\n }\n}// } Driver Code Ends\n\n\nclass Solution\n{\n public boolean isBipartite(int V, ArrayList>adj)\n {\n boolean[] vis=new boolean[V+1];\n boolean[] color=new boolean[V+1];\n Queue q=new LinkedList<>();\n for(int i=0;i\r\nusing namespace std;\r\n\r\n // } Driver Code Ends\r\n// User function Template for C++\r\n\r\nclass Solution{\r\npublic:\r\n int countBits(int N, long long int A[])\r\n {\r\n int m=log2(*max_element(A,A+N));\r\n int mod=1000000007;\r\n int r=0;\r\n for(int i=0;i<=m;i++)\r\n {\r\n long long c=0;\r\n for(int j=0;j>t;\r\n while(t--){\r\n int N;\r\n cin>>N;\r\n long long int A[N];\r\n for(int i = 0;i < N; i++)\r\n cin>>A[i];\r\n \r\n Solution ob;\r\n cout<=0;i--){\n int bit=(X>>i)&1;\n if(bit==1){\n p=p|(1<\nusing namespace std;\nbool isPossible(int arr[],int m,int n,int mid)\n{\n\tint StudentCount = 1;\n\tint pageSum = 0;\n\t\n\tfor(int i = 0; i m || arr[i] > mid)\n\t\t\t{\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tpageSum = arr[i];\n\t\t}\n\t}\n\treturn true;\n}\nint allocatedBooK(int arr[],int m,int n)\n{\n\tint start = 0;\n\tint sum = 0;\n\tfor(int i =0;i\n

Given an array p[] of length n used to denote the dimensions of a series of matrices such that dimension of i'th matrix is p[i] * p[i+1]. There are a total of n-1 matrices. Find the most efficient way to multiply these matrices together. 
\nThe problem is not actually to perform the multiplications, but merely to decide in which order to perform the multiplications such that you need to perform minimum number of multiplications. There are many options to multiply a chain of matrices because matrix multiplication is associative i.e. no matter how one parenthesize the product, the result will be the same.

\n\n


\nExample 1:

\n\n
Input: \nn = 5\np[] = {1, 2, 3, 4, 5}\nOutput: (((AB)C)D)\nExplaination: The total number of \nmultiplications are (1*2*3) + (1*3*4) \n+ (1*4*5) = 6 + 12 + 20 = 38.
\n\n

 

\n\n

Example 2:

\n\n
Input: \nn = 3\np = {3, 3, 3}\nOutput: (AB)\nExplaination: The total number of \nmultiplications are (3*3*3) = 27.
\n\n

 

\n\n

Your Task:
\nYou do not need to read input or print anything. Your task is to complete the function matrixChainOrder() which takes n and p[] as input parameters and returns the string with the proper order of parenthesis for n-1 matrices. Use uppercase alphabets to denote each matrix.

\n\n


\nExpected Time Complexity: O(n3)
\nExpected Auxiliary Space: O(n2)

\n\n


\nConstraints:
\n2 ≤ n ≤ 26 
\n1 ≤ p[i] ≤ 500 

\n

\n " }, { "path": "Brackets in Matrix Chain Multiplication - GFG/brackets-in-matrix-chain-multiplication.cpp", "content": "// { Driver Code Starts\n// Initial Template for C++\n\n#include \nusing namespace std;\n\n // } Driver Code Ends\n// User function Template for C++\n\nclass Solution {\n \n // Cache\n map> dp;\n \n public:\n string matrixChainOrder(int A[], int n) {\n return matrixChainOrderUtil(A, 0, n - 1).second;\n }\n \n pair matrixChainOrderUtil(int p[], int l, int r) {\n \t// Base case\n \t/*\n\t\tFor [1, 2, 3], base case will hit when l = 0, r = 1 or l = 1, r = 2\n\t\tor we can say we are at matrix A or B\n \tl = 0 -> A\n \tl = 1 -> B\n \tso on..\n \t*/\n if(l + 1 == r) return {0, \"\" + string(1, l + 'A')};\n string key = to_string(l) + \";\" + to_string(r);\n if(dp.count(key)) return dp[key];\n \n int currMin = INT_MAX;\n string minString;\n for(int k = l + 1; k < r; k++) {\n auto p1 = matrixChainOrderUtil(p, l, k), p2 = matrixChainOrderUtil(p, k, r);\n if(p1.first + p2.first + p[l] * p[k] * p[r] < currMin) {\n currMin = p1.first + p2.first + p[l] * p[k] * p[r];\n // Multiply te 2 strings\n minString = p1.second + p2.second;\n }\n }\n // Enclose them in brackets and return\n return dp[key] = {currMin, \"(\" + minString + \")\"};\n }\n};\n// { Driver Code Starts.\n\nint main(){\n int t;\n cin>>t;\n while(t--){\n int n;\n cin>>n;\n int p[n];\n for(int i = 0;i < n;i++)\n cin>>p[i];\n \n Solution ob;\n cout< 0){\n int n = Integer.parseInt(in.readLine());\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n int p[] = new int[n];\n for(int i = 0;i < n;i++)\n p[i] = Integer.parseInt(a[i]);\n \n Solution ob = new Solution();\n System.out.println(ob.matrixChainOrder(p, n));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static char matrix;\n static String ans;\n static String matrixChainOrder(int p[], int n){\n // code here\n matrix='A';\n ans=\"\";\n int[][]dp=new int[n][n];\n int[][]path=new int[n][n];\n for(int pair=2;pair\n

2 players A and B take turns alternatively to play a game in which they have N numbers on a paper. In one turn, a player can replace one of the numbers by any of its factor (except for 1 & the number itself). The player who is unable to make a move looses the game. Find the winner of the game if A starts the game and both play optimally.
\n 

\n\n

Example 1:

\n\n
Input: nums = [5, 7, 3]\nOutput: B\nExplanation: Since all the numbers are prime,\nso A will not be able to make the first move. \n
\n\n


\nExample 2:

\n\n
Input: nums = [2, 4, 7, 11]\nOutptut: A\nExplanation: In the first move A will replace 4\nby 2, so the numbers will become [2, 2, 7, 11]\nnow B will not be able to make a move since all \nthe remaining numbers can only be divided by 1 \nor the number itself.  \n\n
\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function brainGame() which takes the list of numbers as input parameter and returns true if A wins and false if B wins.
\n 

\n\n

Expected Time Complexity: O(N2)
\nExpected Space Complexity: O(N)
\n 

\n\n

Constraints
\n1 <= N <= 1000
\n1 <= nums[i] <= 1000

\n

\n " }, { "path": "Brain Game - GFG/brain-game.cpp", "content": "// { Driver Code Starts\n#include\nusing namespace std;\n\n // } Driver Code Ends\nclass Solution{\n\tpublic:\n bool brainGame(vectornums) {\n // Code here.\n vectora(1005);\n for(int i=2;i<=1000;i++){\n for(int j=2*i;j<=1000;j+=i){\n a[j]=max(a[j],a[i]+1);\n }\n }\n int x=0;\n for(int i=0;i> tc;\n\twhile(tc--){\n\t\tint n;\n\t\tcin >> n;\n\t\tvectornums(n);\n\t\tfor(int i = 0; i < n; i++)cin >> nums[i];\n\t\tSolution ob;\n\t\tbool ans = ob.brainGame(nums);\n\t\tif(ans)\n\t\t\tcout << \"A\\n\";\n\t\telse cout << \"B\\n\";\n\t} \n\treturn 0;\n} // } Driver Code Ends" }, { "path": "Brain Game - GFG/brain-game.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n String s = br.readLine().trim();\n String[] S = s.split(\" \");\n int[] nums = new int[n];\n for(int i = 0; i < n; i++){\n nums[i] = Integer.parseInt(S[i]);\n }\n Solution ob = new Solution();\n boolean ans = ob.brainGame(nums);\n if(ans)\n System.out.println(\"A\");\n else \n System.out.println(\"B\"); \n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n//2\n\n\n//2 4 4 0\n//00010\n\n\nclass Solution\n{\n public boolean brainGame(int[] nums)\n {\n int ans=0;\n for(int num:nums){\n if(!isPrime(num))ans=ans^(primeFactors(num)-1);\n }\n return ans!=0;\n }\n \n int primeFactors(int n)\n {\n int ans = 0;\n int num =n;\n for(int i=2; i<=num/2; i++)\n {\n while(n%i == 0)\n {\n ans++;\n n/= i;\n }\n }\n return ans;\n }\n \n boolean isPrime(int n){\n for(int i=2;i<=Math.sqrt(n);i++){\n if(n%i==0)\n return false;\n }\n return true;\n }\n}" }, { "path": "Breadth first search.cpp", "content": "#include \n#include \n#include \nusing namespace std;\n\nvoid bfs(int node,vector* adj,vector* visited) \n{\n queue q;\n q.push(node);\n visited[node]=1;\n \n while(!q.empty())\n {\n int node=q.front();\n q.pop();\n cout<>n>>e; // n is number of vertix\n // e is number of edges\n \n vector adj[n];\n while(e--)\n {\n int u,v;\n cin>>u>>v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n \n vector visited(n,0);\n for(int i=0;i\n

In the game of Broken Blocks, the player is allowed to move on m x n blocks i.e. m levels and n stone blocks on each level such that one level is vertically above the previous level (as in a staircase), with some of its stone blocks replaced by wooden blocks.
\nThe player at the start of the game is present on the ground level (which should be considered as level 0 or it can be considered as level -1). The player can start from any of the blocks present on the level 0 and start moving further to next levels. The player can only move to the stone-block just above to the present stone-block or diagonally to the left or to the right. The player cant move on the same level.
\nIf the player steps on any of the wooden block (denoted by -1), he will fall off the board and die as the wood-block will not able to hold players weight. Each of the stone-block has some gold coins present on it (wooden blocks doesnt have any coins on them). If at any point the player cant move to further level due to any reason, the game ends and his present total coin score will be considered.
\nThe players aim is to collect as many gold coins as he can without falling off the board.
\n 

\n\n

Example 1:

\n\n
Input: matrix = {{2,5,6},{-1,3,2},{4,-1,5}}\nOutput: 14\nExplanation: Assume 0-based indexing.The matrix \nis:\n2 5 6 (level 0)\n-1 3 2 (level 1)\n4 -1 5 (lever 2)\nThe player can collect maximum number of coins \nby moving through:matrix[0][2] + matrix[1][1] \n+ matrix[2][2] = 6 + 3 + 5 = 14 coins.
\n\n

Example 2:

\n\n
Input: matrix = {{-1,2,3,4},{5,-1,-1,2},\n{4,3,-1,-1}}\nOutput: 11\nExplanation: The matrix is:\n-1 2 3 4(level 0)\n5 -1 -1 2(level 1)\n4 3 -1 1(level 2)\nThe player can collect maximum number of coins \nby moving through:a[0][1] + a[1][0] + a[2][0] \n= 2 + 5 + 4 = 11 coins.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function MaxGold() which takes matrix as input parameter and returns the maximum number of gold coins.
\n 

\n\n

Expected Time Complexity: O(n*m)
\nExpected Space Complexity: O(1)

\n

\n " }, { "path": "Broken blocks - GFG/broken-blocks.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String[] S = br.readLine().trim().split(\" \");\n int m = Integer.parseInt(S[0]);\n int n = Integer.parseInt(S[1]);\n int[][] matrix = new int[m][n];\n for(int i = 0; i < m; i++){\n String[] s = br.readLine().trim().split(\" \");\n for(int j = 0; j < n; j++)\n matrix[i][j] = Integer.parseInt(s[j]);\n }\n Solution obj = new Solution();\n int ans = obj.MaxGold(matrix);\n System.out.println(ans);\n\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n int[][]dp;\n public int MaxGold(int[][] a){\n int ans=0;\n dp=new int[a.length][a[0].length];\n for(int i=0;i parent;\n \n queue Q;\n Q.push(root);\n \n while(!Q.empty())\n {\n int sz = Q.size();\n \n while(sz--)\n {\n Node* cur = Q.front();\n Q.pop();\n \n if(cur->data == target)\n start = cur;\n \n if(cur->left)\n {\n Q.push(cur->left);\n parent[cur->left] = cur;\n }\n \n if(cur->right)\n {\n Q.push(cur->right);\n parent[cur->right] = cur;\n }\n }\n }\n \n Q.push(start);\n \n set burned;\n \n int t = -1;\n \n while(!Q.empty())\n {\n int sz = Q.size();\n \n while(sz--)\n {\n Node* cur = Q.front();\n Q.pop();\n \n burned.insert(cur->data);\n \n if(cur != root and burned.find(parent[cur]->data) == burned.end())\n Q.push(parent[cur]);\n \n if(cur->left and burned.find(cur->left->data) == burned.end())\n Q.push(cur->left);\n \n if(cur->right and burned.find(cur->right->data) == burned.end())\n Q.push(cur->right);\n }\n \n t++;\n }\n \n return t;\n }\n};\n" }, { "path": "CODE_OF_CONDUCT.md", "content": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nWe as members, contributors, and leaders pledge to make participation in our\ncommunity a harassment-free experience for everyone, regardless of age, body\nsize, visible or invisible disability, ethnicity, sex characteristics, gender\nidentity and expression, level of experience, education, socio-economic status,\nnationality, personal appearance, race, religion, or sexual identity\nand orientation.\n\nWe pledge to act and interact in ways that contribute to an open, welcoming,\ndiverse, inclusive, and healthy community.\n\n## Our Standards\n\nExamples of behavior that contributes to a positive environment for our\ncommunity include:\n\n* Demonstrating empathy and kindness toward other people\n* Being respectful of differing opinions, viewpoints, and experiences\n* Giving and gracefully accepting constructive feedback\n* Accepting responsibility and apologizing to those affected by our mistakes,\n and learning from the experience\n* Focusing on what is best not just for us as individuals, but for the\n overall community\n\nExamples of unacceptable behavior include:\n\n* The use of sexualized language or imagery, and sexual attention or\n advances of any kind\n* Trolling, insulting or derogatory comments, and personal or political attacks\n* Public or private harassment\n* Publishing others' private information, such as a physical or email\n address, without their explicit permission\n* Other conduct which could reasonably be considered inappropriate in a\n professional setting\n\n## Enforcement Responsibilities\n\nCommunity leaders are responsible for clarifying and enforcing our standards of\nacceptable behavior and will take appropriate and fair corrective action in\nresponse to any behavior that they deem inappropriate, threatening, offensive,\nor harmful.\n\nCommunity leaders have the right and responsibility to remove, edit, or reject\ncomments, commits, code, wiki edits, issues, and other contributions that are\nnot aligned to this Code of Conduct, and will communicate reasons for moderation\ndecisions when appropriate.\n\n## Scope\n\nThis Code of Conduct applies within all community spaces, and also applies when\nan individual is officially representing the community in public spaces.\nExamples of representing our community include using an official e-mail address,\nposting via an official social media account, or acting as an appointed\nrepresentative at an online or offline event.\n\n## Enforcement\n\nInstances of abusive, harassing, or otherwise unacceptable behavior may be\nreported to the community leaders responsible for enforcement at sagar.0dev@gmail.com.\nAll complaints will be reviewed and investigated promptly and fairly.\n\nAll community leaders are obligated to respect the privacy and security of the\nreporter of any incident.\n\n## Enforcement Guidelines\n\nCommunity leaders will follow these Community Impact Guidelines in determining\nthe consequences for any action they deem in violation of this Code of Conduct:\n\n### 1. Correction\n\n**Community Impact**: Use of inappropriate language or other behavior deemed\nunprofessional or unwelcome in the community.\n\n**Consequence**: A private, written warning from community leaders, providing\nclarity around the nature of the violation and an explanation of why the\nbehavior was inappropriate. A public apology may be requested.\n\n### 2. Warning\n\n**Community Impact**: A violation through a single incident or series\nof actions.\n\n**Consequence**: A warning with consequences for continued behavior. No\ninteraction with the people involved, including unsolicited interaction with\nthose enforcing the Code of Conduct, for a specified period of time. This\nincludes avoiding interactions in community spaces as well as external channels\nlike social media. Violating these terms may lead to a temporary or\npermanent ban.\n\n### 3. Temporary Ban\n\n**Community Impact**: A serious violation of community standards, including\nsustained inappropriate behavior.\n\n**Consequence**: A temporary ban from any sort of interaction or public\ncommunication with the community for a specified period of time. No public or\nprivate interaction with the people involved, including unsolicited interaction\nwith those enforcing the Code of Conduct, is allowed during this period.\nViolating these terms may lead to a permanent ban.\n\n### 4. Permanent Ban\n\n**Community Impact**: Demonstrating a pattern of violation of community\nstandards, including sustained inappropriate behavior, harassment of an\nindividual, or aggression toward or disparagement of classes of individuals.\n\n**Consequence**: A permanent ban from any sort of public interaction within\nthe community.\n\n## Attribution\n\nThis Code of Conduct is adapted from the [Contributor Covenant][homepage],\nversion 2.0, available at\nhttps://www.contributor-covenant.org/version/2/0/code_of_conduct.html.\n\nCommunity Impact Guidelines were inspired by [Mozilla's code of conduct\nenforcement ladder](https://github.com/mozilla/diversity).\n\n[homepage]: https://www.contributor-covenant.org\n\nFor answers to common questions about this code of conduct, see the FAQ at\nhttps://www.contributor-covenant.org/faq. Translations are available at\nhttps://www.contributor-covenant.org/translations.\n" }, { "path": "CONTRIBUTING.md", "content": "# 🔥Best repository for you to start your open source journey!!\n## 🔼 Prerequisite required to Contribute\n\n### Contributing Code\n- Git/GitHub\n- Programming Language\n- Data structures and algorithms\n- Problem solving\n \n### Contributing in docs/repo maintainance/others\n- Git/GitHub\n- Markdown/Html\n- GitHub Actions/Yaml\n- CI/CD\n\n---\n\n## ✅ How to Contribute\n\n### Pull Requests\n\n> **Must Use PR templates according to your requirement.**\n### 💻Code PRs\n- Currently, we only cover problems of [LeetCode](https://leetcode.com/problemset/all/), [GeeksForGeeks](https://practice.geeksforgeeks.org/explore?page=1&sortBy=submissions) and [InterviewBit](https://practice.geeksforgeeks.org/explore?page=1&sortBy=submissions). Problems of other good platforms can be accepted(ONLY AFTER [DISCUSSIONS](https://github.com/Sagar0-0/DsA/discussions)).\n- We maintain the structure of repositroy by creating specific directories corresponding to coding platoforms i.e. [Leetcode](https://github.com/Sagar0-0/DsA/tree/main/Leetcode), [GFG](https://github.com/Sagar0-0/DsA/tree/main/GFG), [Interviewbit](https://github.com/Sagar0-0/DsA/tree/main/Interviewbit).\n- ⚠️Please contribute your code in the right directory!! Example - LeetCode questions should be in the [LeetCode directory](https://github.com/Sagar0-0/DsA/tree/main/Leetcode) and same for others.\n- [LeetHub](https://github.com/QasimWani/LeetHub) users, only you can upload your code in the [main directory](https://github.com/Sagar0-0/DsA) from now.(when using extension)\n- **MUST CHECK** if that question already exists or not!! Follow following steps: \nExample- A solution named \"Nine divisors.java\" is to be added, then first check if any directory(or new PR) with the name \"Nine divisors\" exists or not and if yes, then move to \"Nine divisors\" directory and then add your code there(if java file exists then append in that file) or if that folder doesn't exists then create a folder/directory with the name \"Nine divisors\" and then add your code. [How to create a folder/directory?](https://stackoverflow.com/a/34259067/16775065)\n- File naming convention: \n - Every word in the file should be separated by a space. eg. \"Rat in the maze\" , \"19. Remove Nth Node From End of List\", etc.\n - ❌No other naming format will be accepted from now.(to maintian the structure)\n - Do not use \"/\" in the name of any file!(this will leads to creating a directory) \n- We strictly avoid removing the code of other contributors.\n- Check [Beginner's Guide](https://youtu.be/7r05126pOk8) for any issues faced.\n\n#### Migration PRs\n> Help us structure this repository.\n- Select a code file from the main/home directory **that was not contributed by LeetHub extension**.\n- Add it to the directory of their corresponding coding platform(with a folder name of that problem). Eg. \"Nine divisors.java\" file should be in the directory \"GFG/Nine divisors\".\n- Delete that file from the home directory.\n\n### ❌Note: Creating multiple wrong PRs can lead to a permanent ban.❌\n" }, { "path": "Can Make Triangle.java", "content": "class Solution \n{ \n int[] canMakeTriangle(int A[], int N) \n { \n // code here\n int[]ans=new int[N-2];\n for(int i=0;ic && a+c>b && b+c>a){\n return true;\n }\n return false;\n }\n}\n" }, { "path": "Can Place Flowers.java", "content": "class Solution {\n public boolean canPlaceFlowers(int[] flowerbed, int n) {\n if(n==0) return true;\n if(flowerbed.length==1 && flowerbed[0]==0)\n return true;\n if(flowerbed[0]==0 && flowerbed[1]==0 && n>0){\n n--;\n flowerbed[0]=1;\n }\n if(flowerbed[flowerbed.length-1]==0 && flowerbed[flowerbed.length-2]==0 && n>0){ \n n--;\n flowerbed[flowerbed.length-1]=1;\n }\n \n for(int i=1;i0;i++){\n //condition when we need to ignore \n if(flowerbed[i-1] == 1 || flowerbed[i+1]==1 || flowerbed[i]==1)\n continue;\n \n flowerbed[i]=1;\n n--;\n if(n==0) return true;\n }\n \n return n==0;\n }\n}\n" }, { "path": "Capacity To Ship Packages Within D Days.java", "content": "class Solution {\n static int leastWeightCapacity(int[] a, int n, int d) {\n // code here\n int min=largest(a);\n int max=sum(a);\n int res=0;\n while(min<=max){\n int mid=(min+max)/2;\n if(isValid(a,d,mid)){\n res=mid;\n max=mid-1;\n }else{\n min=mid+1;\n }\n }\n return res;\n }\n static boolean isValid(int[]a,int k,int res){\n int day=1,sum=0;\n for(int i=0;ires){\n day++;\n sum=a[i];\n }else{\n sum+=a[i];\n }\n }\n return day<=k;\n }\n static int sum(int[]a){\n int sum=0;\n for(int i:a){\n sum+=i;\n }\n return sum;\n }\n static int largest(int[]arr)\n {\n int i;\n \n // Initialize maximum element\n int max = arr[0];\n \n // Traverse array elements from second and\n // compare every element with current max \n for (i = 1; i < arr.length; i++)\n if (arr[i] > max)\n max = arr[i];\n \n return max;\n }\n};\n" }, { "path": "Capitalize the Title", "content": "class Solution {\n public String capitalizeTitle(String s) {\n List list=new ArrayList<>();\n String word=\"\";\n for(int i=0;i2){\n //uppercase first char\n str=str.substring(0, 1).toUpperCase() + str.substring(1);\n }\n if(i==0){\n s+=str;\n }else{\n s+=\" \"+str;\n }\n }\n return s;\n }\n}\n" }, { "path": "Case-specific Sorting of Strings.java", "content": "class Solution\n\n{\n //Function to perform case-specific sorting of strings.\n public static String caseSort(String str)\n {\n // Your code here\n char[] arr=str.toCharArray();\n Arrays.sort(arr);\n \n int upper=-1;\n int lower=-1;\n \n if(arr[0]<97){\n upper=0;\n }\n for(int i=0;i=97){\n lower=i;\n break;\n }\n }\n \n if(upper==-1 || lower==-1)return new String(arr);\n \n StringBuilder sb=new StringBuilder();\n \n for(int i=0;i=97){\n sb.append(arr[lower]);\n lower++;\n }else{\n sb.append(arr[upper]);\n upper++;\n }\n }\n return sb.toString();\n }\n}\n" }, { "path": "Case-specific Sorting of Strings.py", "content": "class Solution:\n\n #Function to perform case-specific sorting of strings.\n def caseSort(self,s,n):\n #code here\n up,low=[],[]\n res=[]\n for i in s:\n if i.isupper():\n up.append(i)\n elif i.islower():\n low.append(i)\n up.sort()\n low.sort()\n x,y=0,0\n for i in s:\n if i.isupper():\n res.append(up[x])\n x+=1\n elif i.islower():\n res.append(low[y])\n y+=1\n ans=''.join(res)\n return ans\n" }, { "path": "Case-specific Sorting string.cpp", "content": "include\nusing namespace std;\n\n\n// } Driver Code Ends\nclass Solution\n{\n public:\n //Function to perform case-specific sorting of strings.\n string caseSort(string str, int n)\n {\n \n vectorsmall;\n vectorcap;\n \n for(int i=0;i=65&&str[i]<92){\n cap.push_back(i);\n }\n else{\n small.push_back(i);\n }\n }\n \n sort(str.begin(),str.end());\n \n int s=0,c=0;\n \n char ans[n+1];\n for(int i=0;i=65&&str[i]<92){\n ans[cap[c]]=str[i]; \n c++;\n }\n else{\n ans[small[s]]=str[i];\n s++;\n }\n \n }\n ans[n]='\\0';\n \n return ans;\n \n }\n};\n\n//{ Driver Code Starts.\n\nint main()\n{\n\tint t;\n\tcin>>t;\n\twhile(t--)\n\t{\n\t\tint n;\n\t\tcin>>n;\n\t\tstring str;\n\t\tcin>>str;\n\t\tSolution obj;\n\t\tcout<key){\n if(root.data 0) {\n champagneTower[row + 1][column] += splittingWine;\n champagneTower[row + 1][column + 1] += splittingWine;\n }\n }\n }\n return Math.min(1, champagneTower[query_row][query_glass]);\n }\n} \n\n//======================================================================================================\n\nclass Solution {\n public double champagneTower(int poured, int queryRow, int queryGlass) {\n\t if (poured == 0)\n\t\t return 0;\n\t var prevRow = new ArrayList<>(List.of((double) poured));\n\n\t while (queryRow-- > 0) {\n\t\t var currentRow = new ArrayList();\n\t\t var champagneInEnds = Math.max(0, (prevRow.get(0) - 1) / 2); // min champagne can be 0\n\t\t currentRow.add(champagneInEnds); // first glass\n\n\t\t for (var i = 1; i < prevRow.size(); i++)\n\t\t\t currentRow.add(Math.max(0, (prevRow.get(i - 1) - 1) / 2) + // flow from top-left glass\n\t\t\t\t\t\t Math.max(0, (prevRow.get(i) - 1) / 2)); // flow from top-right glass\n\n\t\t currentRow.add(champagneInEnds); // last glass\n\t\t prevRow = currentRow;\n\t }\n\t return Math.min(1, prevRow.get(queryGlass)); // max champagne can be 1\n }\n} \n" }, { "path": "Change Bits - GFG/README.md", "content": "# Change Bits\n## Easy \n
\n

Given a number N, complete the following tasks,
\nTask 1. Generate a new number from N by changing the zeroes in the binary representation of N to 1.
\nTask  2. Find the difference between N and the newly generated number.

\n\n

 

\n\n

Example 1:

\n\n
Input: N = 8 \nOutput: 7 15\nExplanation:\nThere are 3 zeroes in binary representation\nof 8. Changing them to 1 will give 15.\nDifference between these two is 7.
\n\n


\nExample 2:

\n\n
Input: N = 6 \nOutput: 1 7\nExplanation:\nThere is 1 zero in binary representation\nof 6. Changing it to 1 will give 7.\nDifference between these two is 1.
\n\n

 

\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function changeBits() which takes an integer N as input parameter and returns a list of two integers containing the difference and the generated number respectively.

\n\n

 

\n\n

Expected Time Complexity: O(log(N))
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n0 <= N <= 108

\n

\n
" }, { "path": "Change Bits - GFG/change-bits.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n\n Solution ob = new Solution();\n int[] ans = ob.changeBits(N);\n System.out.println(ans[0]+ \" \"+ ans[1]);\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution {\n static int[] changeBits(int N) {\n int newNum=0;\n int n=N;\n while(n>0){\n newNum|=1;\n newNum=newNum<<=1;\n n=n>>1;\n }\n newNum=newNum>>1;\n int diff=Math.abs(N-newNum);\n int ans[]=new int[]{diff,newNum};\n return ans;\n }\n};" }, { "path": "Check Mirror in N-ary tree.java", "content": "class Solution {\n static int checkMirrorTree(int n, int e, int[] A, int[] B) {\n // code here\n HashMap> mp = new HashMap>();\n for(int i=0;i ls = mp.get(A[i]);\n ls.push(A[i+1]);\n mp.put(A[i],ls);\n }\n else{\n Stack ls = new Stack();\n ls.push(A[i+1]);\n mp.put(A[i],ls);\n }\n i++;\n }\n \n for(int i=0;i ls = new Stack();\n ls = mp.get(B[i]);\n if(ls.pop()!=B[i+1]){\n return 0;\n }\n mp.put(B[i],ls);\n }\n i++;\n }\n return 1;\n }\n};\n" }, { "path": "Check Palindrome!.java", "content": "public class Solution {\n public int solve(String s) {\n int[]arr=new int[26];\n for(char c:s.toCharArray()){\n arr[c-'a']++;\n }\n boolean one=false;\n for(int i:arr){\n if(i%2==1){\n if(one){\n return 0;\n }else{\n one=true;\n }\n }\n }\n return 1;\n }\n}\n" }, { "path": "Check if Every Row and Column Contains All Numbers", "content": "class Solution {\n public boolean checkValid(int[][] matrix) {\n int n=matrix.length;\n int[][] check=new int[n][n];\n for(int row=0;row= 0){ \n for(int d1: dir){ \n col1 = d1 + c1;\n for(int d2: dir){ \n col2 = d2 + c2;\n if(inRange(col1, col) && inRange(col2, col)){\n dp[i][col1][col2] = Math.max(dp[i][col1][col2], prev+(col1 == col2 ? grid[i][col1] : (grid[i][col1] + grid[i][col2]))); \n max = Math.max(max, dp[i][col1][col2]); \n }\n }\n }\n }\n \n }\n }\n }\n return max;\n }\n\n public boolean inRange(int val, int limit){\n return 0 <= val && val < limit;\n }\n}\n" }, { "path": "Chips Factory.java", "content": "public class Solution {\n public int[] solve(int[] A) {\n int n=A.length;\n int[]ans=new int[n];\n int i=0;\n for(int num:A){\n if(num!=0){\n ans[i]=num;\n i++;\n }\n }\n return ans;\n }\n}\n" }, { "path": "Chocolate_Distribution_Problem_gfg.cpp", "content": "#include\nusing namespace std;\n\n\nclass Solution{\n public:\n long long findMinDiff(vector a, long long n, long long m){\n // sliding window approach\n if(n \n

You are given a string s of lower case english alphabets. You can choose any two characters in the string and replace all the occurences of the first character with the second character and replace all the occurences of the second character with the first character. Your aim is to find the lexicographically smallest string that can be obtained by doing this operation at most once.

\n\n

Example 1:

\n\n
Input:\nA = \"ccad\"\nOutput: \"aacd\"\nExplanation:\nIn ccad, we choose a and c and after \ndoing the replacement operation once we get, \naacd and this is the lexicographically\nsmallest string possible.
\n\n

 

\n\n

Example 2:

\n\n
Input:\nA = \"abba\"\nOutput: \"abba\"\nExplanation:\nIn abba, we can get baab after doing the \nreplacement operation once for a and b \nbut that is not lexicographically smaller \nthan abba. So, the answer is abba.
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function chooseandswap() which takes the string A as input parameters and returns the lexicographically smallest string that is possible after doing the operation at most once.
\n
\nExpected Time Complexity: O(|A|) length of the string A
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n1<= |A| <=105

\n\n

 

\n

\n " }, { "path": "Choose and Swap - GFG/choose-and-swap.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n \n Solution obj = new Solution();\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String A = read.readLine().trim();\n \n String ans = obj.chooseandswap(A);\n System.out.println(ans);\n }\n }\n}\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\n\n\nclass Solution{\n String chooseandswap(String A){\n int hash[] = new int[26]; \n Arrays.fill(hash, -1);\n \n //get first occurence of every char\n for(int i=A.length()-1; i>=0; i--)\n hash[A.charAt(i)-97] = i;\n \n \n for(int i=0; ii){\n String temp1 = A.replaceAll(String.valueOf(ch), \"X\");\n String temp2 = temp1.replaceAll(String.valueOf(st), String.valueOf(ch));\n String temp3 = temp2.replaceAll(\"X\", String.valueOf(st));\n return temp3;\n }\n st+=1;\n }\n }\n return A;\n }\n}" }, { "path": "Climbing Stairs.java", "content": "public class Solution {\n public int solve(ArrayList A) {\n \n int n = A.size();\n int steps = A.get(0);\n int dp[] = new int[n];\n dp[0] = steps;\n dp[1] = steps + A.get(1);\n for(int i = 2; i < n; i++){\n dp[i] = Math.min(dp[i-1], dp[i-2]) + A.get(i);\n }\n \n return dp[n-1];\n }\n}\n" }, { "path": "Clone Graph.java", "content": "class Solution {\n Map map = new HashMap<>(); \n public Node cloneGraph(Node node) {\n if (node == null) return node;\n if(map.containsKey(node)) return map.get(node); \n Node clonedGraph = new Node(node.val, new ArrayList<>()); \n map.put(node, clonedGraph); \n for(Node oldNeb : node.neighbors) {\n Node clonedNeb = cloneGraph(oldNeb); \n clonedGraph.neighbors.add(clonedNeb);\n }\n return map.get(node); \n }\n}\n\n//================================================================================\n\nclass Solution {\n public Node cloneGraph(Node node) {\n if(node==null) return null;\n \n Map map = new HashMap();\n Queue queue = new LinkedList();\n \n queue.add(node);\n map.put(node,new Node(node.val));\n \n while(!queue.isEmpty()){\n \n Node curr = queue.poll();\n \n for(Node neighbor : curr.neighbors){\n if(!map.containsKey(neighbor)){\n map.put(neighbor,new Node(neighbor.val));\n queue.add(neighbor);\n }\n map.get(curr).neighbors.add(map.get(neighbor));\n }\n }\n \n return map.get(node);\n }\n}\n" }, { "path": "Clone a stack without using extra space", "content": "class Solution {\n void clonestack(Stack st, Stack cloned) {\n int n=st.size();\n int i=n;\n while(n>0){\n while(!st.isEmpty()){\n cloned.push(st.pop());\n }\n int x=cloned.pop();\n i=n-1;\n while(!cloned.isEmpty() && i>0){\n st.push(cloned.pop());\n i--;\n }\n cloned.push(x);\n n--;\n }\n return ;\n }\n\n}\n" }, { "path": "Closest Palindrome - GFG/README.md", "content": "# Closest Palindrome\n## Hard \n
\n

Given a number num, our task is to find the closest Palindrome number whose absolute difference with given number is minimum. If 2 Palindome numbers have same absolute difference from the given number, then find the smaller one.
\n 

\n\n

Example 1:

\n\n
Input: num = 9\nOutput: 9\nExplanation: 9 itself is a palindrome\nnumber.\n
\n\n

Example 2:

\n\n
Input: num = 489\nOutput: 494\nExpnataion: closest palindrome numbers from\n489 are 484 and 494. Absolute difference between\n489 and 494 is equal to the absolute difference\nbetween 484 and 489 but 484 is smaller than 494.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anyhting. Your task is to complete the function closestPalindrome() which takes num as input parameter and returns the closest palindrome.
\n 

\n\n

Expected Time Complexity: O(log10num)
\nExpected Space Complexity: O(1)
\n 

\n\n

Constraints:
\n1 <= num <= 1014

\n

\n
" }, { "path": "Closest Palindrome - GFG/closest-palindrome.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n long num = Long.parseLong(br.readLine().trim());\n Solution obj = new Solution();\n long ans = obj.closestPalindrome(num);\n System.out.println(ans);\n\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution\n{\n public long closestPalindrome(long num)\n {\n String number = String.valueOf(num);\n \n if(isPalindrome(number))\n {\n return num;\n }\n \n if(number.charAt(0)=='1' && Long.parseLong(number.substring(1))==0)\n {\n return num-1;\n }\n \n int n = number.length();\n \n boolean hasEvenDigits = n%2==0;\n \n \n String palRootStr = hasEvenDigits ? number.substring(0, n/2) : number.substring(0, n/2+1);\n \n long palRoot = Long.parseLong(palRootStr);\n \n //Equal\n \n long equal = toPal(\"\" + palRoot, hasEvenDigits);\n long diffEqual = Math.abs(num-equal);\n \n //Bigger\n \n long bigger = toPal(\"\" + (palRoot+1), hasEvenDigits);\n long diffBigger = Math.abs(num-bigger);\n \n //Smaller\n \n long smaller = toPal(\"\" + (palRoot-1), hasEvenDigits);\n long diffSmaller = Math.abs(num-smaller);\n \n \n long closest = diffBigger\n

There are N piles of coins each containing  Ai (1<=i<=N) coins. Find the minimum number of coins to be removed such that the absolute difference of coins in any two piles is at most K.
\nNote: You can also remove a pile by removing all the coins of that pile.

\n\n


\nExample 1:

\n\n
Input:\nN = 4, K = 0\narr[] = {2, 2, 2, 2}\nOutput:\n0\nExplanation:\nFor any two piles the difference in the\nnumber of coins is <=0. So no need to\nremove any coins. \n
\n\n
Example 2:
\n\n
Input:\nN = 6, K = 3\narr[] = {1, 5, 1, 2, 5, 1} \nOutput :\n2\nExplanation:\nIf we remove one coin each from both\nthe piles containing 5 coins , then\nfor any two piles the absolute difference\nin the number of coins is <=3. \n\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function minSteps() which takes 2 integers N, and K and an array A of size N as input and returns the minimum number of coins that need to be removed.

\n\n


\nExpected Time Complexity: O(N*logN)
\nExpected Auxiliary Space: O(N)

\n\n


\nConstraints:
\n1 ≤ N ≤ 105
\n0 ≤ K ≤ 104
\n1 ≤ A[i] ≤ 103

\n

\n " }, { "path": "Coin Piles - GFG/coin-piles.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n String S1[] = read.readLine().split(\" \");\n int N = Integer.parseInt(S1[0]);\n int K = Integer.parseInt(S1[1]);\n \n String S[] = read.readLine().split(\" \");\n int[] A = new int[N];\n \n for(int i=0; i= 0 ; i--){\n subset[i] = arr[i] + subset[i+1];\n }\n \n int min = Integer.MAX_VALUE;\n int sum = 0;\n \n for(int i =0; i< n; i++){\n int ind = findUpper(arr , arr[i] + k , i , n-1);\n if(ind == -1){\n min = Math.min(min , sum); \n continue;\n }\n \n int curr = subset[ind] - ((n - ind) *(arr[i]+k));\n curr += sum;\n min = Math.min(min , curr);\n sum += arr[i];\n }\n return min;\n }\n static int findUpper(int[] arr , int target, int s , int e){\n int ans = -1;\n while(s <= e){\n int mid = (s+e)/2;\n if(arr[mid] > target){\n ans = mid;\n e = mid - 1;\n }else{\n s = mid + 1;\n }\n }\n return ans;\n }\n};" }, { "path": "Coins of Geekland.java", "content": "class Solution\n{\n public int Maximum_Sum(int mat[][],int N,int K){\n // Your code goes here\n int max=Integer.MIN_VALUE;\n for(int i=0;i<=N-K;i++){\n for(int j=0;j<=N-K;j++){\n max=Math.max(max,sum(mat,i,j,K));\n }\n }\n return max;\n }\n public int sum(int[][]arr,int row, int col, int k){\n int sum=0;\n int i=row;\n while(i> ans;\n\tint n;\n\tSet> set;\n\tpublic ArrayList> combinationSum(ArrayList a, int b) {\n\t\tCollections.sort(a);\n\t\tn=b;\n\t\tset=new HashSet<>();\n\t\tans=new ArrayList<>();\n\t\tdfs(0,a,new ArrayList<>(),0);\n\t\treturn ans;\n\t}\n\tvoid dfs(int idx,ArrayList a,ArrayList curr,int sum){\n\t\tif(sum==n){\n\t\t\tif(!set.contains(curr)){\n\t\t\t\tset.add(curr);\n\t\t\t\tans.add(new ArrayList<>(curr));\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tif(idx==a.size())return;\n\t\tfor(int i=idx;i> ans;\n ArrayList arr;\n int target;\n public ArrayList> combinationSum(ArrayList A, int B){\n ans=new ArrayList<>();\n target=B;\n Collections.sort(A);\n arr=A;\n dfs(0,0,new ArrayList<>());\n return ans;\n }\n public void dfs(int sum,int index,ArrayList curr){\n if(sum>target)return;\n if(sum==target){\n if(!ans.contains(curr)){\n ans.add(new ArrayList<>(curr));\n }\n }\n for(int i=index;iindex && ele==arr.get(i-1))continue;\n curr.add(ele);\n sum+=ele;\n dfs(sum,i,curr);\n curr.remove(curr.size()-1);\n sum-=ele;\n }\n }\n}\n" }, { "path": "Combinations.java", "content": "public class Solution {\n ArrayList> ans;\n int n;\n int k;\n public ArrayList> combine(int n, int k) {\n ans=new ArrayList<>();\n this.n=n;\n this.k=k;\n dfs(1,new ArrayList<>());\n return ans;\n }\n public void dfs(int curr,ArrayList curList){\n if(curList.size()==k){\n ans.add(new ArrayList<>(curList));\n return;\n }\n for(int i=curr;i<=n;i++){\n curList.add(i);\n dfs(i+1,curList);\n curList.remove(curList.size()-1);\n }\n }\n}\n" }, { "path": "Compare Version Numbers.java", "content": "class Solution {\n public int compareVersion(String version1, String version2) {\n String[] str1 = version1.split(\"\\\\.\");\n String[] str2 = version2.split(\"\\\\.\");\n int max = Math.max(str1.length,str2.length);\n for(int i=0;i= str1.length ? 0 : Integer.parseInt(str1[i]);\n int num2 = i >= str2.length ? 0 : Integer.parseInt(str2[i]);\n if(num1 < num2) return -1;\n if(num1 > num2) return 1;\n }\n\n return 0;\n }\n}\n\n//==================================================================================\n//Two pointer (Faster)\npublic class Solution {\n public int compareVersion(String version1, String version2) {\n int i = 0, j = 0;\n int currentVersion1, currentVersion2;\n while(i < version1.length() || j < version2.length()) {\n currentVersion1 = 0;\n while(i < version1.length() && version1.charAt(i) != '.'){\n currentVersion1 = currentVersion1 * 10 + (version1.charAt(i) - '0');\n i++;\n }\n \n currentVersion2 = 0;\n while(j < version2.length() && version2.charAt(j) != '.'){\n currentVersion2 = currentVersion2 * 10 + (version2.charAt(j) - '0');\n j++;\n }\n \n if(currentVersion1 > currentVersion2)\n return 1;\n if(currentVersion2 > currentVersion1)\n return -1;\n i++;\n j++;\n }\n \n return 0;\n }\n}\n" }, { "path": "Complete Binary Tree.java", "content": "class GfG\n{\n\tboolean isCompleteBT(Node root)\n {\n //add code here.\n Queue q=new LinkedList<>();\n q.add(root);\n boolean foundNull=false;\n while(!q.isEmpty()){\n int sz=q.size();\n while(sz-->0){\n Node node=q.remove();\n if(node==null){\n foundNull=true;\n }else{\n if(foundNull){\n return false;\n }else{\n q.add(node.left);\n q.add(node.right);\n }\n }\n }\n }\n return true;\n\t} \n}\n" }, { "path": "Composite And Prime.java", "content": "Without using DP\n\n\n\nclass Solution\n\n\n{\n \n public boolean isPrime(int a){\n if(a==1){\n return false;\n }\n else if(a==2 || a==3){\n return true;\n }\n else if(a%2==0 || a%3==0){\n return false;\n }\n else{\n for(int i=5;i<=Math.sqrt(a);i+=6){\n if(a%i==0 || a%(i+2)==0){\n return false;\n }\n }\n return true;\n }\n }\n public int Count(int l, int r)\n {\n \n \n long countp=0;\n long countc=0;\n for(int i=l;i<=r;i++){\n if(isPrime(i)==true){\n countp++;\n }\n else{\n countc++;\n }\n }\n \n \n \n int a=(int)(countc-countp);\n if(l==1 || r==1){\n a=a-1;\n }\n \n return a;\n \n \n }\n}\n\n\n//long to avoid integer overflow exception(if exists)\n\n" }, { "path": "Composite and Prime gfg med s18.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\n\tpublic:\n\tvectorisprime;\n\tvector count;\n\tvoid isPrime(int n){\n\t bool prime[n+1];\n\t count.resize(n+1,0);\n\t memset(prime, true, sizeof(prime));\n\t \n\t for(int ip =2; ip*ip<=n; ip++){\n\t if(prime[ip]== true){\n\t for(int i=ip*2; i<=n; i+=ip) prime[i] = false;\n\t }\n\t }\n\t int c =0;\n\t for(int p=2; p<=n; p++){\n\t c+=(prime[p]== true);\n\t count[p] = c;\n\t }\n\t}\n\t\tint Count(int L, int R){\n\t\t // Code here\n\t\t isPrime(R);\n\t\t int ans = (R-L+1)-2*(count[R]-count[L-1]);\n\t\t // 1 is neither prime or comp\n\t\t if(L==1) ans--;\n\t\t return ans;\n\t\t}\n\n};\n\nint main(){\n\tint tc;\n\tcin >> tc;\n\twhile(tc--){\n\t\tint L, R;\n\t\tcin >> L >> R;\n\t\tSolution obj;\n\t\tint ans = obj.Count(L, R);\n\t\tcout << ans << \"\\n\";\n\t}\n\treturn 0;\n}" }, { "path": "Composite and Prime.cpp", "content": "//{ Driver Code Starts\n#include\nusing namespace std;\n\n// } Driver Code Ends\nclass Solution {\n\tpublic:\n\t\tint Count(int L, int R){\n\t\t // Code here\n\t\t//using the Sieve of Eratosthenes\n \n\t\tvectorv(R+1, true); //initially considering all number as prime\n\t\t\n\t\t\n\t\tfor(int i=2; i*i<=R; i++){\n\t\t for(int j=i*i; j<=R; j+=i){\n\t\t v[j] = false; //marking all composite numbers as false\n\t\t }\n\t\t}\n\t\t\n\t\tint composite=0, prime=0;\n\t\t\n\t\tfor(int i=L; i<=R; i++){\n\t\t if(i==1) //since 1 is neither prime nor composite\n\t\t continue;\n\t\t else if(v[i]==true)\n\t\t prime++;\n\t\t else\n\t\t composite++;\n\t\t}\n\t\treturn composite-prime;\n\t}\n};\n\n//{ Driver Code Starts.\nint main(){\n\tint tc;\n\tcin >> tc;\n\twhile(tc--){\n\t\tint L, R;\n\t\tcin >> L >> R;\n\t\tSolution obj;\n\t\tint ans = obj.Count(L, R);\n\t\tcout << ans << \"\\n\";\n\t}\n\treturn 0;\n}\n// } Driver Code Ends\n" }, { "path": "Composite and Prime.java", "content": "class Solution\n{\n public int Count(int L, int R)\n {\n // code here\n int primes=0;\n int comp=0;\n boolean[]prime=new boolean[R+1];\n Arrays.fill(prime,true);\n prime[0]=false;\n prime[1]=false;\n for(int i=2;i<=R;i++){\n if(prime[i]){\n for(int j=2*i;j<=R;j+=i){\n prime[j]=false;\n } \n }\n }\n \n for(int i=L;i<=R;i++){\n if(prime[i]){\n primes++;\n }else{\n comp++;\n }\n }\n if(L==1){\n comp--;\n }\n return comp-primes;\n }\n}\n" }, { "path": "Composite and Prime.py", "content": "#User function Template for python3\n\nclass Solution:\n\tdef Count(self, l, r):\n\t\tsize = r\n sieve = [i for i in range(size+1)]\n for i in range(2, size+1):\n if sieve[i] == i:\n j = i * 2\n while j < size+1:\n sieve[j] = i\n j += i\n \n comps = primes = 0\n for i in range(max(l, 2), r+1):\n if sieve[i] == i:\n primes += 1\n else:\n comps += 1\n return comps - primes\n\n\n#{ \n # Driver Code Starts\n#Initial Template for Python 3\n\nif __name__ == '__main__':\n\tT=int(input())\n\tfor i in range(T):\n\t\tL, R = input().split()\n\t\tL = int(L); R = int(R)\n\t\tob = Solution()\n\t\tans = ob.Count(L, R)\n\t\tprint(ans)\n\n# } Driver Code Ends\n" }, { "path": "Composite-and-prime.cpp", "content": "class Solution{\npublic:\n\t bool isPrime(int num){\n\t if(num <= 1) return false;\n\t int cnt = 0;\n\t for(int i = 2; i <= sqrt(num); i++){\n\t if(num % i == 0) return false;\n\t }\n\t return true;\n\t }\n\t\n\t\tint Count(int L, int R){\n\t\t int p = 0, c = 0;\n\t\t for(int i = L; i <= R; i++){\n\t\t if(i == 1) continue;\n\t\t if(isPrime(i)) p++;\n\t\t else\n\t\t c++;\n\t\t }\n\t\t return c - p;\n\t\t}\n};\n" }, { "path": "Compute Before Matrix.java", "content": "class Solution{\n public int[][] computeBeforeMatrix(int N, int M,int[][] after ){\n // Code here\n int[][]before=new int[N][M];\n for(int row=0;row0){\n before[row][col]=after[row][col]-after[row][col-1];\n }else if(col==0 && row>0){\n before[row][col]=after[row][col]-after[row-1][col];\n }else{\n before[row][col]=after[row][col]-(after[row-1][col]-after[row-1][col-1]+after[row][col-1] );\n }\n }\n }\n return before;\n }\n}\n" }, { "path": "Concatenate two numbers.java", "content": "class Solution \n{ \n long countPairs(int N, int X, int numbers[]) \n { \n // code here\n long c=0;\n Map a=new HashMap();\n for(int i=0;i A) {\n Queuepq=new PriorityQueue<>();\n for(int i:A)pq.add(i);\n int ans=0;\n while(pq.size()>1){\n int sum=pq.remove()+pq.remove();\n ans+=sum;\n pq.add(sum);\n }\n return ans;\n }\n}\n" }, { "path": "Consecutive Parent - Child.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n public int consecutiveNodes(TreeNode A) {\n if(A.left==null && A.right==null)return 0;\n int ans=0;\n if(A.left!=null){\n if(A.left.val==A.val-1 || A.left.val==A.val+1)ans++;\n ans+=consecutiveNodes(A.left);\n }\n if(A.right!=null){\n if(A.right.val==A.val-1 || A.right.val==A.val+1)ans++;\n ans+=consecutiveNodes(A.right);\n }\n return ans;\n }\n}\n" }, { "path": "Construct BST from Preorder.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n int i=0;\n public TreeNode constructBST(int[] A) {\n return bstFromPreOrder(A,Integer.MAX_VALUE);\n }\n \n public TreeNode bstFromPreOrder(int[] preorder ,int bound){\n if(i== preorder.length || preorder[i]>=bound) return null;\n TreeNode root = new TreeNode(preorder[i++]);\n root.left = bstFromPreOrder(preorder, root.val);\n root.right = bstFromPreOrder(preorder, bound);\n return root;\n }\n}\n\n \n\n\n\n" }, { "path": "Construct Binary Tree From Inorder And Preorder.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\npublic class Solution {\n \n ArrayList preorder, inorder;\n \n\tpublic TreeNode buildTree(ArrayList preorder, ArrayList inorder) {\n\t \n\t if (preorder == null || inorder == null || preorder.size() == 0 || inorder.size() == 0)\n\t return null;\n\t \n\t if (preorder.size() != inorder.size())\n\t return null;\n\t \n\t this.preorder = preorder;\n\t this.inorder = inorder;\n\t \n\t return rec(0, preorder.size() - 1, 0);\n\t \n\t}\n\t\n\t\n\tprivate TreeNode rec(int start, int end, int index) {\n\t \n\t if (start > end)\n\t return null;\n\t \n\t TreeNode root = new TreeNode(preorder.get(index));\n\t \n\t int i = start;\n\t \n\t for (; i <= end; i++) {\n\t if (inorder.get(i).intValue() == root.val)\n\t break;\n\t }\n\t \n\t root.left = rec(start, i - 1, index + 1);\n\t root.right = rec(i + 1, end, index + i - start + 1);\n\t \n\t return root;\n\t}\n\t\n}\n" }, { "path": "Construct String With Repeat Limit.java", "content": "class Solution {\n public String repeatLimitedString(String s, int repeatLimit) {\n int [] arr = new int [26];\n \n for (char c : s.toCharArray()){\n arr[c - 'a']++;\n }\n \n StringBuilder sb = new StringBuilder();\n int r;\n int nxt = 25;\n \n for (int i = 25, j = 25; i >= 0; --i){\n r = repeatLimit;\n \n while (arr[i] > 0 && r > 0 ){\n --r;\n --arr[i];\n sb.append((char)('a' + i));\n }\n \n if (arr[i] > 0){\n while(nxt >= i || (nxt >= 0 && arr[nxt] == 0) )\n --nxt;\n \n if (nxt < 0) break;\n --arr[nxt];\n sb.append((char)('a' + nxt));\n ++i;\n }\n \n \n }\n \n return sb.toString();\n }\n}\n" }, { "path": "Construct String from Binary Tree lc easy.cpp", "content": "#include\nusing namespace std;\n\n/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode() : val(0), left(nullptr), right(nullptr) {}\n * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n string res =\"\";\n void recur(TreeNode* root){\n if(!root) return;\n res+=to_string(root->val);\n if(!root->left && !root->right) return;\n res+=\"(\";\n recur(root->left);\n res+=\")\";\n if(root->right){\n res+=\"(\";\n recur(root->right);\n res+=\")\";\n }\n }\n string tree2str(TreeNode* root) {\n// recursion\n recur(root);\n return res;\n }\n// TC: O(N)\n};\n" }, { "path": "Construct String from Binary Tree.java", "content": "class Solution {\n StringBuilder sb=new StringBuilder();\n public String tree2str(TreeNode root) {\n str(root);\n return sb.toString();\n }\n public void str(TreeNode root) {\n if(root==null) {\n return ;\n } \n if(root.left==null && root.right==null) { //when there is no childs, adding just node value\n sb.append(\"\"+root.val);\n return ;\n }\n \n sb.append(\"\"+root.val+\"(\");\n str(root.left); //irrespective of left child present or not we should add ()-> so calling left child\n sb.append(\")\");\n if(root.right!=null) { //If right child not present no need to add any ()\n sb.append(\"(\");\n str(root.right);\n sb.append(\")\");\n }\n }\n}\n" }, { "path": "Container With Most Water.java", "content": "public class Solution {\n public int maxArea(int[] A) {\n if(A.length<=1)return 0;\n int ans=Integer.MIN_VALUE;\n int i=0;\n int j=A.length-1;\n while(i map = new HashMap<>();\n map.put(0, -1);\n int maxlen = 0, count = 0;\n for (int i = 0; i < nums.length; i++) {\n count = count + (nums[i] == 1 ? 1 : -1);\n if (map.containsKey(count)) {\n maxlen = Math.max(maxlen, i - map.get(count));\n } else {\n map.put(count, i);\n }\n }\n return maxlen;\n }\n}\n\n\n============================================================================================\n \n//Faster\n//using array\n \npublic class Solution {\n\n public int findMaxLength(int[] nums) {\n int[] arr = new int[2 * nums.length + 1];\n Arrays.fill(arr, -2);\n arr[nums.length] = -1;\n int maxlen = 0, count = 0;\n for (int i = 0; i < nums.length; i++) {\n count = count + (nums[i] == 0 ? -1 : 1);\n if (arr[count + nums.length] >= -1) {\n maxlen = Math.max(maxlen, i - arr[count + nums.length]);\n } else {\n arr[count + nums.length] = i;\n }\n\n }\n return maxlen;\n }\n}\n" }, { "path": "Convert Sorted List to Binary Search Tree.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) { val = x; }\n * }\n */\n/**\n * Definition for singly-linked list.\n * class ListNode {\n * public int val;\n * public ListNode next;\n * ListNode(int x) { val = x; next = null; }\n * }\n */\npublic class Solution {\n\tpublic TreeNode sortedListToBST(ListNode a) {\n return dfs(a);\n\t}\n public TreeNode dfs(ListNode a){\n if(a.next==null)return new TreeNode(a.val);\n ListNode prev=null;\n ListNode slow=a;\n ListNode fast=a;\n while(fast.next!=null && fast.next.next!=null){\n prev=slow;\n slow=slow.next;\n fast=fast.next.next;\n }\n if(prev!=null)prev.next=null;\n ListNode next=slow.next;\n slow.next=null;\n TreeNode root=new TreeNode(slow.val);\n if(!slow.equals(a))root.left=dfs(a);\n root.right=dfs(next);\n return root;\n }\n}\n" }, { "path": "Convert the amount in number to words.java", "content": "public class Solution {\n private static class Place {\n int unit;\n String name;\n\n public Place (int unit, String name) {\n this.unit = unit;\n this.name = name;\n }\n }\n\n private static final Place[] places = new Place[]{\n new Place(10000000, \"crore\"),\n new Place(100000, \"lakh\"),\n new Place(1000, \"thousand\"),\n new Place(100, \"hundred\")\n };\n\n private static final String[] tens = new String[]{\n \"\",\n \"\",\n \"twenty\",\n \"thirty\",\n \"forty\",\n \"fifty\",\n \"sixty\",\n \"seventy\",\n \"eighty\",\n \"ninety\"\n };\n\n private static final String[] units = new String[]{\n \"zero\",\n \"one\",\n \"two\",\n \"three\",\n \"four\",\n \"five\",\n \"six\",\n \"seven\",\n \"eight\",\n \"nine\",\n \"ten\",\n \"eleven\",\n \"twelve\",\n \"thirteen\",\n \"fourteen\",\n \"fifteen\",\n \"sixteen\",\n \"seventeen\",\n \"eighteen\",\n \"nineteen\"\n };\n\n private String f(long amount) {\n StringBuilder sb = new StringBuilder();\n\n for (int i = 0; i < places.length; i++) {\n Place place = places[i];\n int qty = (int)(amount / place.unit);\n if (qty > 0) {\n String toAdd = \"\";\n if (qty > 10) {\n toAdd = f (qty) + \"-\" + place.name;\n } else {\n toAdd = units[qty] + \"-\" + place.name;\n }\n if (sb.length() > 0) {\n sb.append(\"-\");\n }\n sb.append(toAdd);\n }\n amount -= (long) qty * place.unit;\n }\n\n if (sb.length() > 0 && amount > 0) {\n sb.append(\"-and-\");\n }\n\n int ten = (int)(amount / 10);\n boolean shouldAddAnd = false;\n if (ten > 1) {\n sb.append(tens[ten]);\n amount -= 10 * ten;\n shouldAddAnd = true;\n }\n\n if (amount > 0) {\n if (shouldAddAnd) {\n sb.append(\"-\");\n }\n sb.append(units[(int)amount]);\n }\n\n return sb.toString();\n }\n\n public int solve(String A, String B) {\n\n long amount = Long.parseLong(A);\n String b = f(amount);\n return b.equals(B) ? 1 : 0;\n\n }\n}\n" }, { "path": "Convert to Palindrome.java", "content": "public class Solution {\n public int solve(String A) {\n int n=A.length();\n int lo=0,hi=n-1,flag=0;\n while(lo\n

Given a Binary Search Tree (BST) and a range l-h(inclusive), count the number of nodes in the BST that lie in the given range.

\n\n
    \n\t
  • The values smaller than root go to the left side
    • \n\t
  • The values greater and equal to the root go to the right side
    • \n
\n\n

Example 1:

\n\n
Input:\n      10\n     /  \\\n    5    50\n   /    /  \\\n  1    40  100\nl = 5, h = 45\nOutput: 3\nExplanation: 5 10 40 are the node in the\nrange\n
\n\n

Example 2:

\n\n
Input:\n     5\n    /  \\\n   4    6\n  /      \\\n 3        7\nl = 2, h = 8\nOutput: 5\nExplanation: All the nodes are in the\ngiven range.\n
\n\n

Your Task:
\nThis is a function problem. You don't have to take input. You are required to complete the function getCountOfNode() that takes root, l ,h as parameters and returns the count.

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(Height of the BST).

\n\n

Constraints:
\n1 <= Number of nodes <= 100
\n1 <= l < h < 103

\n

\n " }, { "path": "Count BST nodes that lie in a given range - GFG/count-bst-nodes-that-lie-in-a-given-range.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.LinkedList; \nimport java.util.Queue; \nimport java.io.*;\nimport java.util.*;\n\nclass Node{\n int data;\n Node left;\n Node right;\n Node(int data){\n this.data = data;\n left=null;\n right=null;\n }\n}\n\nclass GfG {\n \n static Node buildTree(String str){\n \n if(str.length()==0 || str.charAt(0)=='N'){\n return null;\n }\n \n String ip[] = str.split(\" \");\n // Create the root of the tree\n Node root = new Node(Integer.parseInt(ip[0]));\n // Push the root to the queue\n \n Queue queue = new LinkedList<>(); \n \n queue.add(root);\n // Starting from the second element\n \n int i = 1;\n while(queue.size()>0 && i < ip.length) {\n \n // Get and remove the front of the queue\n Node currNode = queue.peek();\n queue.remove();\n \n // Get the current node's value from the string\n String currVal = ip[i];\n \n // If the left child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the left child for the current node\n currNode.left = new Node(Integer.parseInt(currVal));\n // Push it to the queue\n queue.add(currNode.left);\n }\n \n // For the right child\n i++;\n if(i >= ip.length)\n break;\n \n currVal = ip[i];\n \n // If the right child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the right child for the current node\n currNode.right = new Node(Integer.parseInt(currVal));\n \n // Push it to the queue\n queue.add(currNode.right);\n }\n i++;\n }\n \n return root;\n }\n static void printInorder(Node root)\n {\n if(root == null)\n return;\n \n printInorder(root.left);\n System.out.print(root.data+\" \");\n \n printInorder(root.right);\n }\n \n\tpublic static void main (String[] args) throws IOException{\n\t BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t \n\t int t=Integer.parseInt(br.readLine());\n \n\t while(t > 0){\n\t String s = br.readLine();\n\t String[] ab = br.readLine().trim().split(\" \");\n int a = Integer.parseInt(ab[0]);\n int b = Integer.parseInt(ab[1]);\n \t \tNode root = buildTree(s);\n \t Solution g = new Solution();\n\t\t\t System.out.println(g.getCount(root,a,b));\n t--;\n \n }\n }\n \n}\n\n// } Driver Code Ends\n\n\n// A Binary Search Tree node\n\n\nclass Solution\n{\n int ans;\n //Function to count number of nodes in BST that lie in the given range.\n int getCount(Node root,int l, int h)\n {\n //Your code here\n ans=0;\n dfs(root,l,h);\n return ans;\n }\n void dfs(Node root,int l,int h){\n if(root==null)return;\n if(root.data>=l && root.data<=h){\n ans++;\n dfs(root.left,l,h);\n dfs(root.right,l,h);\n }else if(root.data words1Set=new HashSet<>();\n HashSet words1Duplicates=new HashSet<>();\n HashSet words12Set=new HashSet<>();\n HashSet words12Duplicates=new HashSet<>();\n for(String s: words1) {\n if (words1Set.contains(s)) words1Duplicates.add(s);\n else words1Set.add(s);\n }\n for(String s: words1Duplicates) words1Set.remove(s);\n for(String s: words2) {\n if (words1Set.contains(s)) {\n if (words12Set.contains(s)) words12Duplicates.add(s);\n else words12Set.add(s);\n }\n }\n return words12Set.size()-words12Duplicates.size();\n }\n}\n" }, { "path": "Count Integers With Even Digit Sum.py", "content": "def getSum(n):\n sum = 0\n for digit in str(n): \n sum += int(digit) \n return sum\n \nclass Solution:\n def countEven(self, num: int) -> int:\n count=0\n val=2\n while val<=num:\n if getSum(val)%2==0:\n count+=1;\n val+=1\n return count\n" }, { "path": "Count Operations to Obtain Zero.java", "content": "class Solution {\n public int countOperations(int num1, int num2) {\n int ans=0;\n while(num1>0 && num2>0){\n if(num1>=num2){\n num1=num1-num2;\n }else{\n num2=num2-num1;\n }\n ans++;\n }\n return ans;\n }\n}\n" }, { "path": "Count Palindromic Subsequence.cpp", "content": "#include\nusing namespace std;\n\n// } Driver Code Ends\nclass Solution{\n #define ll long long int\n\n \n private:\n ll solve(string& s,int i,int j,vector> &dp){\n int mod =1e9+7;\n \n if(i==j){\n return 1;\n }\n \n if(i>j){\n return 0;\n }\n \n if(dp[i][j] != -1){\n return dp[i][j];\n }\n \n \n if(s[i] == s[j]){\n dp[i][j] = ( 1 + solve(s,i+1,j,dp) + solve(s,i,j-1,dp) )%mod;\n }else{\n dp[i][j] = ((solve(s,i+1,j,dp) + solve(s,i,j-1,dp) - solve(s,i+1,j-1,dp))%mod+mod)%mod ; \n }\n \n \n return dp[i][j];\n }\n public:\n /*You are required to complete below method */\n ll countPS(string str)\n {\n //Your code here\n int n = str.size();\n \n vector> dp(n,vector(n,-1));\n \n return solve(str,0,n-1,dp);\n \n }\n \n};\n\n//{ Driver Code Starts.\n// Driver program\nint main()\n{\n int t;\n cin>>t;\n while(t--)\n {\n string str;\n cin>>str;\n Solution ob;\n long long int ans = ob.countPS(str);\n cout< arr=new ArrayList<>();\n arr.add(a[n-1]);\n for(int i=n-2;i>=0;i--){\n int idx=dfs(arr,a[i],0,arr.size()-1);\n ans[ii]=idx;\n ii--;\n arr.add(idx,a[i]);\n }\n // for(int i:arr)System.out.print(i+\" \");\n return ans;\n }\n int dfs(List arr,int key,int l,int h){\n if(l<=h){\n int mid=l+(h-l)/2;\n if(arr.get(mid)>=key){\n return dfs(arr,key,l,mid-1);\n }\n return dfs(arr,key,mid+1,h);\n }\n return l;\n }\n}\n" }, { "path": "Count Words Obtained After Adding a Letter", "content": "class Solution {\n public int wordCount(String[] a, String[] b) {\n int m=a.length;\n int n=b.length;\n Set set=new HashSet<>();\n \n for(int i=0;i\n

Given a string str consisting of digits, one may group these digits into sub-groups while maintaining their original order.
\nThe task is to count number of groupings such that for every sub-group except the last one, sum of digits in a sub-group is less than or equal to sum of the digits in the sub-group immediately on its right.

\n\n

For example, a valid grouping of digits of number 1119 is (1-11-9). Sum of digits in first subgroup is 1, next subgroup is 2, and last subgroup is 9. Sum of every subgroup is less than or equal to its immediate right.
\n 

\n\n

Example 1: 

\n\n
Input: str = \"1119\"\nOutput: 7\nExplanation: [1-119], [1-1-19], [1-11-9], \n[1-1-1-9], [11-19], [111-9] and [1119] \nare seven sub-groups.\n
\n\n


\nExample 2:

\n\n
Input: str = \"12\"\nOutput: 2\nExplanation: [1-2] and [12] are two sub-groups.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function TotalCount() which takes the string str as input parameter and returns total possible groupings.
\n
\nExpected Time Complexity: O(N * N ) where N is length of string.
\nExpected Space Complexity: O(N * N)
\n 

\n\n

Constraints:
\n1 <= length of string <= 100

\n

\n " }, { "path": "Count digit groupings of a number - GFG/count-digit-groupings-of-a-number.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String str = br.readLine().trim();\n Solution ob = new Solution();\n int ans = ob.TotalCount(str);\n System.out.println(ans); \n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution{\n public int TotalCount(String str){\n int sum = 0;\n for(int i=0; i=0;i--){\n curr += str.charAt(i)-'0';\n if(curr<=currsum)ans += backtrack(str,curr,i-1, dp);\n }\n return dp[currsum][index] = ans;\n }\n}" }, { "path": "Count occurrences of a given word in a 2-d array(dynamic programming).cpp", "content": "class Solution{\n public:\n void solve(int i, int j, vector > &mat, string target,int index, int &ans){\n int row=mat.size();\n int col=mat[0].size();\n if(i<0 or i>=row or j<0 or j>=col or index==target.length() or mat[i][j]=='1' or target[index]!=mat[i][j])\n return;\n if(index==target.length()-1 && target[index]==mat[i][j])\n ans++;\n index++;\n char temp=mat[i][j];\n mat[i][j]='1';\n \n solve(i,j-1,mat,target,index,ans);\n solve(i,j+1,mat,target,index,ans);\n solve(i-1,j,mat,target,index,ans);\n solve(i+1,j,mat,target,index,ans);\n mat[i][j]=temp;\n }\n int findOccurrence(vector > &mat, string target){\n int row=mat.size();\n int col=mat[0].size();\n int ans=0;\n for(int i=0;i> &mat,string &target)\n {\n if(i < 0 || j < 0 || i==m || j==n || x >= target.size() || mat[i][j] != target[x])\n return false;\n \n return true;\n }\n \n void solve(int i,int j,int m,int n,int x,vector> &mat,string &target)\n {\n if(isSafe(i,j,m,n,x,mat,target))\n {\n if(x == target.size()-1)\n {\n ans++;\n return;\n }\n \n int dx[4] = {1,-1,0,0};\n int dy[4] = {0,0,1,-1};\n char temp = mat[i][j];\n mat[i][j] = '/';\n for(int k=0; k<4; k++)\n {\n int nx = i+dx[k];\n int ny = j+dy[k];\n \n solve(nx,ny,m,n,x+1,mat,target);\n \n }\n mat[i][j] = temp;\n \n }\n }\n \n int findOccurrence(vector > &mat, string target){\n int m = mat.size();\n int n = mat[0].size();\n int x = 0;\n for(int i=0; i=target.length()\n || target.charAt(idx)!=mat[i][j])return;\n if(idx==target.length()-1){\n ans++;\n return;\n }\n char ch=mat[i][j];\n mat[i][j]='0';\n dfs(mat,i+1,j,target,idx+1);\n dfs(mat,i-1,j,target,idx+1);\n dfs(mat,i,j+1,target,idx+1);\n dfs(mat,i,j-1,target,idx+1);\n mat[i][j]=ch;\n }\n}\n" }, { "path": "Count occurrences of a given word in a 2-d array.py", "content": "class Solution:\n def findOccurrence(self,mat,target):\n\n cnt = 0\n m, n = len(mat), len(mat[0])\n seen = set()\n \n def dfs(r, c, target):\n nonlocal cnt, m, n\n \n if not target:\n cnt += 1\n return \n if r < 0 or r >= m or c < 0 or c >= n or (r, c) in seen or mat[r][c] != target[0]:\n return\n seen.add((r, c))\n dfs(r+1, c, target[1:])\n dfs(r-1, c, target[1:])\n dfs(r, c+1, target[1:])\n dfs(r, c-1, target[1:])\n seen.remove((r, c))\n \n for r in range(len(mat)):\n for c in range(len(mat[0])):\n if mat[r][c] != target[0]:\n continue\n dfs(r, c, target)\n return cnt//4\n" }, { "path": "Count pairs in array divisible by K - GFG/README.md", "content": "# Count pairs in array divisible by K\n## Medium \n
\n

Given an array A[] and positive integer K, the task is to count total number of pairs in the array whose sum is divisible by K.

\n\n

Example 1:

\n\n
Input : \nA[] = {2, 2, 1, 7, 5, 3}, K = 4\nOutput : 5\nExplanation : \nThere are five pairs possible whose sum\nis divisible by '4' i.e., (2, 2), \n(1, 7), (7, 5), (1, 3) and (5, 3)
\n\n

Example 2:

\n\n
Input : \nA[] = {5, 9, 36, 74, 52, 31, 42}, K = 3\nOutput : 7 \nExplanation : \nThere are seven pairs whose sum is divisible by 3, \ni.e, (9, 36), (9,42), (74, 52), (36, 42), (74, 31), \n(31, 5) and (5, 52).\n
\n\n
Your task :
\n\n
You don't have to read input or print anything. Your task is to complete the function countKdivPairs() which takes the array, it's size and an integer K as input and returns the count of pairs whose sum is divisible by K.
\n\n
 
\n\n
Expected Time Complexity : O(n)
\n\n
Expected Auxiliary Space : O(k)
\n\n
 
\n\n
Constraints :
\n\n
1 <= N <=10^6
\n\n
1 <= A[i] <= 10^6
\n\n
1 <= K <= 100
\n

\n
" }, { "path": "Count pairs in array divisible by K - GFG/count-pairs-in-array-divisible-by-k.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass GFG\n{\n public static void main (String[] args) throws IOException {\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\tint t = Integer.parseInt(br.readLine().trim()); //Inputting the testcases\n\t\twhile(t-->0){\n\t\t \n\t\t int n = Integer.parseInt(br.readLine().trim());\n\t\t String inputLine[] = br.readLine().trim().split(\" \");\n\t\t int arr[] = new int[n];\n\t\t for(int i=0; i\n

Given N, the number of plots on either sides of the road. Find the total ways to construct buildings in the plots such that there is a space between any 2 buildings. All plots on one side of the road are continuous.
\nLets suppose * represents a plot, then for N=3, the plots can be represented as * * * | | * * *                               

\n\n

Where | | represents the road.                                                                                                                                                                  
\nNote: As the answer can be very large, print it mod 1000000007

\n\n

 

\n\n

Example 1:

\n\n
Input: N = 3\nOutput: 25\nExplanation: 3 plots, which means possible\nways for one side are BSS, BSB, SSS, SBS,\nSSB where B represents a building and S\nrepresents an empty space Total possible \nways are 25, because a way to place on one\nside can correspond to any of 5 ways on other\nside.
\n\n

Example 2:

\n\n
Input: N = 10\nOutput: 20736\nExplanation: There are 20736 ways for N = 10.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function ToralWays() which takes N as input parameter and returns the total possible ways modulo 109 + 7.
\n 

\n\n

Expected Time Complexity: O(N)
\nExpected Space Complexity: O(N)
\n 

\n\n

Constraints:
\n1 <= N <= 100000

\n

\n " }, { "path": "Count possible ways to construct buildings - GFG/count-possible-ways-to-construct-buildings.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int N = Integer.parseInt(br.readLine().trim());\n Solution ob = new Solution();\n int ans = ob.TotalWays(N);\n System.out.println(ans); \n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n public int TotalWays(int N)\n {\n // Code here\n long i,ans=0,inf = 1000000007;\n long s = 1,b=1;\n \n while(N-->1){\n i = s%inf;\n s = (s%inf+b%inf);\n b = i;\n }\n s = s%inf + b%inf;\n return (int)((s*s)%inf);\n }\n\n}" }, { "path": "Count subsequences of type a^i, b^j, c^k - GFG/README.md", "content": "# Count subsequences of type a^i, b^j, c^k\n## Medium \n
\n

Given a string S, the task is to count number of subsequences of the form aibjck, where i >= 1, j >=1 and k >= 1.

\n\n

Note: 
\n1. Two subsequences are considered different if the set of array indexes picked for the 2 subsequences are different.
\n2.  For large test cases, the output value will be too large, return the answer MODULO 10^9+7

\n\n

 

\n\n

Example 1:

\n\n
Input:\nS = \"abbc\"\nOutput: 3\nExplanation: Subsequences are abc, abc and abbc.
\n\n


\nExample 2:

\n\n
Input:\nS = \"abcabc\"\nOutput: 7\nExplanation: Subsequences are abc, abc,\nabbc, aabc abcc, abc and abc.
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function fun() which takes the string S as input parameter and returns the number of subsequences which follows given condition.

\n\n


\nExpected Time Complexity: O(Length of String).
\nExpected Auxiliary Space: O(1) .

\n\n


\nConstraints:
\n1 <= |S| <= 105

\n

\n
" }, { "path": "Count subsequences of type a^i, b^j, c^k - GFG/count-subsequences-of-type-ai-bj-ck.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n\tpublic static void main (String[] args) {\n\t\t\n\t\tScanner sc = new Scanner (System.in);\n\t\tint t = Integer.parseInt(sc.next());\n\t\t\n\t\twhile(t>0)\n\t\t{\n\t\t String s = sc.next();\n\t\t \n\t\t Solution T = new Solution();\n\t\t System.out.println(T.fun(s));\n\t\t \n\t\t t--;\n\t\t}\n\t}\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n public int fun(String s){\n HashMap mp = new HashMap <>();\n \n mp.put('a',0);\n mp.put('b',0);\n mp.put('c',0);\n for(int i = s.length()-1;i >= 0;i--)\n {\n if(s.charAt(i) == 'c')\n mp.put('c', (2*mp.get('c')+1) % 1000000007 );\n else if(s.charAt(i) == 'b')\n mp.put('b', ( (2*mp.get('b'))% 1000000007 + mp.get('c') ) % 1000000007 );\n else if(s.charAt(i) == 'a')\n mp.put('a', ( (2*mp.get('a'))% 1000000007 + mp.get('b') ) % 1000000007 );\n }\n \n return mp.get('a');\n }\n}" }, { "path": "Count the paths - GFG/README.md", "content": "# Count the paths\n## Easy \n
\n

Given a directed acyclic graph(DAG) with n nodes labeled from 0 to n-1. Given edges, s and d ,count the number of ways to reach from s to d.There is a directed Edge from vertex edges[i][0] to the vertex edges[i][1].

\n\n

 

\n\n

Example:

\n\n
Input: edges = {{0,1},{0,3},{1,2},{3,2}}, \nn = 4, s = 0, d = 2\nOutput: 2\nExplanation: There are two ways to reach at \n2 from 0. These are-\n1. 0->1->2\n2. 0->3->2\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function possible_paths() which takes edges, n, s and d as input parameter and returns the number of ways to reach from s to d.

\n\n

 

\n\n

Expected Time Compelxity: O(2n)
\nExpected Space Complexity: O(n+e)

\n\n

where e is the number of edges in the graph.
\n 

\n\n

Constraints:
\n1 <= n <= 15
\n0 <= s, d <= n-1

\n

\n
" }, { "path": "Count the paths - GFG/count-the-paths.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String[] S = br.readLine().trim().split(\" \");\n int n = Integer.parseInt(S[0]);\n int m = Integer.parseInt(S[1]);\n int s = Integer.parseInt(S[2]);\n int d = Integer.parseInt(S[3]);\n int[][] edges = new int[m][2];\n for(int i = 0; i < m; i++){\n String[] S1 = br.readLine().trim().split(\" \");\n edges[i][0] = Integer.parseInt(S1[0]);\n edges[i][1] = Integer.parseInt(S1[1]);\n }\n Solution obj = new Solution();\n int ans = obj.possible_paths(edges, n, s, d);\n System.out.println(ans);\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n Map> map;\n int ans;\n int des;\n public int possible_paths(int[][] edges, int n, int s, int d)\n {\n des=d;\n ans=0;\n map=new HashMap<>();\n for(int[]e:edges){\n int src=e[0];\n int des=e[1];\n map.putIfAbsent(src,new ArrayList<>());\n map.get(src).add(des);\n }\n \n dfs(s);\n return ans;\n }\n void dfs(int curr){\n if(curr==des){\n ans++;\n return;\n }\n if(!map.containsKey(curr))return;\n ArrayList arr=map.get(curr);\n for(int neb:arr){\n dfs(neb);\n }\n }\n}" }, { "path": "Count-occurrences-of-a-given-string-in-2d-array.cpp", "content": "\nclass Solution{\n public:\n \n int ans = 0;\n void dfs(int i, int j, vector> &mat, string target, int ind, string s){\n if(i < 0 || j < 0 || i >= mat.size() || j >= mat[0].size() || mat[i][j] != target[ind])\n return;\n if(ind == target.size()-1){\n ans++;\n return;\n }\n char ch = mat[i][j];\n mat[i][j] = '0';\n dfs(i+1,j,mat,target,ind+1,s+mat[i][j]);\n dfs(i,j+1,mat,target,ind+1,s+mat[i][j]);\n dfs(i-1,j,mat,target,ind+1,s+mat[i][j]);\n dfs(i,j-1,mat,target,ind+1,s+mat[i][j]);\n \n mat[i][j] = ch;\n \n }\n \n int findOccurrence(vector > &mat, string target){\n int n = mat.size();\n int m = mat[0].size();\n \n for(int i = 0; i < n; i++){\n for(int j = 0; j < m; j++){\n if(mat[i][j] == target[0]){\n dfs(i,j,mat,target,0,\"\");\n }\n }\n }\n return ans;\n }\n};\n" }, { "path": "Count_occurences_of_a_given_word_in_a_2-d_array/Solution.java", "content": "class Solution\n{\n // write your code here\n int result = 0;\n boolean isSafe(char mat[][],int r,int c)\n {\n int rLen = mat.length,cLen = mat[0].length;\n if((r >= 0 && r < rLen)&&(c >= 0 && c < cLen))\n return true;\n return false;\n }\n public void dfs(char mat[][],int i,int r, int c,String target)\n {\n if(!isSafe(mat,r,c)) return;\n if(i == target.length()) return;\n char ch = target.charAt(i);\n if(ch != mat[r][c]) return;\n \n if(i == target.length()-1)\n {\n result+=1;\n return;\n }\n mat[r][c] = '$';\n \n dfs(mat,i+1,r+1,c,target);\n dfs(mat,i+1,r-1,c,target);\n dfs(mat,i+1,r,c+1,target);\n dfs(mat,i+1,r,c-1,target);\n \n mat[r][c] = ch;\n \n }\n public int findOccurrence(char mat[][], String target)\n {\n for(int i = 0;i < mat.length;i++)\n for(int j = 0; j < mat[i].length;j++)\n if(mat[i][j] == target.charAt(0))\n dfs(mat,0,i,j,target);\n return result;\n }\n}" }, { "path": "Count_occurences_of_a_given_word_in_a_2-d_array/question.md", "content": "Find the number of occurrences of a given search word in a 2d-Array of characters where the word can go up, down, left, right and around 90 degree bends.\n\n**Example 1:**\n\n```\nInput: \nR = 4, C = 5\nmat = {{S,N,B,S,N},\n {B,A,K,E,A},\n  {B,K,B,B,K},\n {S,E,B,S,E}}\ntarget = SNAKES\nOutput:\n3\nExplanation: \nS N B S N\nB A K E A\nB K B B K\nS E B S E\nTotal occurrence of the word is 3\nand denoted by color.\n```\n\n**Example 2:**\n\n```\nInput:\nR = 3, C = 3 \nmat = {{c,a,t},\n  {a,t,c},\n  {c,t,a}}\ntarget = cat\nOutput:\n5\nExplanation: Same explanation\nas first example.\n```\n\n**Your task:**\nYou dont need to read input or print anything. Your task is to complete the function **findOccurrence()** which takes the mat contaning N*M 2-d array of character and target as input parameters and returns thethe number of occurrences of target.\n\n**Expected Time Complexity: **O(R*C*2 ^2*len^ ), Where len is length of target String.\n**Expected Auxiliary Space: **O(1)\n\n**Constraints:**\n1 ≤ len ≤ 15\n1 ≤ R, C ≤ 50\n" }, { "path": "Counting Bits.java", "content": "class Solution {\n public int[] countBits(int n) {\n int[]ans=new int[n+1];\n for(int i=1;i>1]+(i&1);\n return ans;\n }\n}\n" }, { "path": "Counts Zeros Xor Pairs - GFG/README.md", "content": "# Counts Zeros Xor Pairs\n## Easy \n
\n

Given an array A[] of size N. Find the number of pairs (i, j) such that
\nAi XOR Aj = 0, and 1 ≤ i < j ≤ N.

\n\n

Example 1:

\n\n
​Input : arr[ ] = {1, 3, 4, 1, 4}\nOutput : 2\nExplanation:\nIndex( 0, 3 ) and (2 , 4 ) are only pairs \nwhose xors is zero so count is 2.\n
\n\n


\n​Example 2:

\n\n
Input : arr[ ] = {2, 2, 2} \nOutput :  3\n\n
\n\n

 

\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function calculate() that takes an array (arr), sizeOfArray (n), and return the count of Zeros Xor's Pairs. The driver code takes care of the printing.

\n\n

Expected Time Complexity: O(N*Log(N)).
\nExpected Auxiliary Space: O(1).

\n\n


\n
\nOutput:
\nFor each test case, output a single integer i.e counts of Zeros Xors Pairs

\n\n

Constraints
\n2 ≤ N ≤ 10^5
\n1 ≤ A[i] ≤ 10^5

\n\n

 

\n

\n
" }, { "path": "Counts Zeros Xor Pairs - GFG/counts-zeros-xor-pairs.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n//Initial Template for Java\n\n//Initial Template for Java\n\n//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t String line = br.readLine();\n\t\t String[] element = line.trim().split(\"\\\\s+\");\n\t\t int sizeOfArray = Integer.parseInt(element[0]);\n\t\t \n\t\t int arr [] = new int[sizeOfArray];\n\t\t \n\t\t line = br.readLine();\n\t\t String[] elements = line.trim().split(\"\\\\s+\");\n\t\t for(int i = 0;i\n

There are a total of n tasks you have to pick, labeled from 0 to n-1. Some tasks may have prerequisites tasks, for example to pick task 0 you have to first finish tasks 1, which is expressed as a pair: [0, 1]
\nGiven the total number of n tasks and a list of prerequisite pairs of size m. Find a ordering of tasks you should pick to finish all tasks.
\nNote: There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all tasks, return an empty array. Returning any correct order will give the output as 1, whereas any invalid order will give the output 0.

\n\n


\nExample 1:

\n\n
Input:\nn = 2, m = 1\nprerequisites = {{1, 0}}\nOutput:\n1\nExplanation:\nThe output 1 denotes that the order is\nvalid. So, if you have, implemented\nyour function correctly, then output\nwould be 1 for all test cases.\nOne possible order is [0, 1].
\n\n

Example 2:

\n\n
Input:\nn = 4, m = 4\nprerequisites = {{1, 0},\n                 {2, 0},\n                 {3, 1},\n                 {3, 2}}\nOutput:\n1\nExplanation:\nThere are a total of 4 tasks to pick.\nTo pick task 3 you should have finished\nboth tasks 1 and 2. Both tasks 1 and 2\nshould be pick after you finished task 0.\nSo one correct task order is [0, 1, 2, 3].\nAnother correct ordering is [0, 2, 1, 3].\nReturning any of these order will result in\na Output of 1.\n
\n\n


\nYour Task:
\nThe task is to complete the function findOrder() which takes two integers n, and m and a list of lists of size m*2 denoting the prerequisite pairs as input and returns any correct order to finish all the tasks. Return an empty array if it's impossible to finish all tasks.

\n\n

\nConstraints:
\n1 ≤ n ≤ 104\n\n
0 ≤ m ≤ 105
\n0 ≤ prerequisites[0], prerequisites[1] ≤ 105
\nAll prerequisite pairs are unique
\n\n
prerequisites[0] ≠ prerequisites[1]
\n
\n\n


\nExpected Time Complexity: O(n+m).
\nExpected Auxiliary Space: O(n+m).

\n

\n " }, { "path": "Course Schedule - GFG/course-schedule.java", "content": "// { Driver Code Starts\n//Initial template for JAVA\n\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass Main {\n public static void main(String[] args) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n\n while (t-- > 0) {\n ArrayList> list = new ArrayList<>();\n String st[] = read.readLine().trim().split(\"\\\\s+\");\n int n = Integer.parseInt(st[0]);\n int m = Integer.parseInt(st[1]);\n\n for (int i = 0; i < n; i++)\n list.add(i, new ArrayList());\n\n ArrayList> prerequisites = new ArrayList<>();\n for (int i = 1; i <= m; i++) {\n String s[] = read.readLine().trim().split(\"\\\\s+\");\n int u = Integer.parseInt(s[0]);\n int v = Integer.parseInt(s[1]);\n list.get(v).add(u);\n ArrayList pair = new ArrayList<>();\n pair.add(u);\n pair.add(v);\n prerequisites.add(pair);\n }\n\n int[] res = new Solution().findOrder(n, m, prerequisites);\n \n if(res.length==0)\n System.out.println(\"No Ordering Possible\");\n else\n {\n if (check(list, n, res) == true)\n System.out.println(\"1\");\n else\n System.out.println(\"0\");\n }\n }\n }\n static boolean check(ArrayList> list, int V, int[] res) {\n int[] map = new int[V];\n for (int i = 0; i < V; i++) {\n map[res[i]] = i;\n }\n for (int i = 0; i < V; i++) {\n for (int v : list.get(i)) {\n if (map[i] > map[v]) return false;\n }\n }\n return true;\n }\n}\n// } Driver Code Ends\n\nclass Solution{\n static int[] findOrder(int n, int m, ArrayList> prereq){\n int indegree[] = new int[n];\n //Calculate the indegree of each node.\n for(int i=0; i> adj = new ArrayList<>();\n \n for(int i=0; i());\n }\n \n for(int i=0; i queue = new ArrayDeque<>();\n \n boolean visited[] = new boolean[n];\n \n for(int i=0; i printCousins(Node root, Node find)\n {\n //code here\n Queue q=new LinkedList<>();\n ArrayList ans=new ArrayList<>();\n q.offer(root);\n boolean flag=false;\n while(!q.isEmpty()){\n int sz=q.size();\n if(flag){\n while(!q.isEmpty()){\n ans.add(q.remove().data);\n }\n break;\n }\n for(int i=0;i q=new LinkedList<>();\n q.add(A);\n while(q.size()>0){\n int sz=q.size();\n for(int i=0;i (a[0] == b[0]) ? Integer.compare(b[1], a[1]) : Integer.compare(a[0], b[0]));\n\n int noOfWeakCharacters = 0;\n int len = properties.length;\n // improvization here - // we need to keep track of the max value\n int max = properties[len-1][1];\n\n for(int i = len-2; i>=0 ;i--) {\n\n if(properties[i][1] < max) {\n noOfWeakCharacters++;\n } else {\n max = properties[i][1];\n }\n }\n return noOfWeakCharacters;\n }\n}\n" }, { "path": "Delete and Earn.java", "content": "class Solution {\n private HashMap points = new HashMap<>();\n private HashMap cache = new HashMap<>();\n \n private int maxPoints(int num) {\n // Check for base cases\n if (num == 0) {\n return 0;\n }\n \n if (num == 1) {\n return points.getOrDefault(1, 0);\n }\n \n if (cache.containsKey(num)) {\n return cache.get(num);\n }\n \n // Apply recurrence relation\n int gain = points.getOrDefault(num, 0);\n cache.put(num, Math.max(maxPoints(num - 1), maxPoints(num - 2) + gain));\n return cache.get(num);\n }\n \n public int deleteAndEarn(int[] nums) {\n int maxNumber = 0;\n \n // Precompute how many points we gain from taking an element\n for (int num : nums) {\n points.put(num, points.getOrDefault(num, 0) + num);\n maxNumber = Math.max(maxNumber, num);\n }\n \n return maxPoints(maxNumber);\n }\n}\n\n//==================================================================================\nclass Solution {\n public int deleteAndEarn(int[] nums) {\n int[] count = new int[10001];\n for (int n : nums) {\n count[n]++;\n };\n \n int withPrev = 0;\n int withoutPrev = 0;\n int prev = -1;\n \n for (int i = 0; i < count.length; i++) {\n if (count[i] == 0) continue;\n \n int currentMax = Math.max(withPrev, withoutPrev);\n if (i - prev == 1) {\n withPrev = withoutPrev + count[i] * i;\n withoutPrev = currentMax;\n } else {\n withPrev = currentMax + count[i] * i;\n withoutPrev = currentMax;\n }\n \n prev = i;\n }\n \n return Math.max(withPrev, withoutPrev);\n }\n}\n" }, { "path": "Delete nodes greater than k.java", "content": "class Solution\n {\n public Node deleteNode(Node root,int k)\n {\n //add code here.\n if(root==null)return null;\n if(root.data>=k){\n root.left=deleteNode(root.left,k);\n return root.left;\n }else{\n root.right=deleteNode(root.right,k);\n \n }\n return root;\n }\n }\n" }, { "path": "Deserialize.java", "content": "public class Solution {\n public ArrayList deserialize(String A) {\n int i=0;\n ArrayList arr=new ArrayList<>();\n StringBuilder sb=new StringBuilder();\n while(i='0' && A.charAt(i)<='9'){\n arr.add(sb.toString());\n sb.setLength(0);\n while(A.charAt(i)<'a')i++;\n }else if(A.charAt(i)=='~'){\n i++;\n }else{\n sb.append(A.charAt(i));\n i++;\n }\n }\n return arr;\n }\n}\n" }, { "path": "Design Add and Search Words Data Structure.java", "content": "class WordDictionary {\n private WordDictionary[] children;\n boolean isEndOfWord;\n // Initialize your data structure here. \n public WordDictionary() {\n children = new WordDictionary[26];\n isEndOfWord = false;\n }\n \n // Adds a word into the data structure. \n public void addWord(String word) {\n WordDictionary curr = this;\n for(char c: word.toCharArray()){\n if(curr.children[c - 'a'] == null)\n curr.children[c - 'a'] = new WordDictionary();\n curr = curr.children[c - 'a'];\n }\n curr.isEndOfWord = true;\n }\n \n // Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter. \n public boolean search(String word) {\n WordDictionary curr = this;\n for(int i = 0; i < word.length(); ++i){\n char c = word.charAt(i);\n if(c == '.'){\n for(WordDictionary ch: curr.children)\n if(ch != null && ch.search(word.substring(i+1))) return true;\n return false;\n }\n if(curr.children[c - 'a'] == null) return false;\n curr = curr.children[c - 'a'];\n }\n return curr != null && curr.isEndOfWord;\n }\n}\n" }, { "path": "Design Bitset.java", "content": "class Bitset {\n int size;\n Set one = new HashSet<>();\n Set zero = new HashSet<>();\n public Bitset(int size) {\n this.size = size;\n for(int i=0;i s = one;\n one = zero;\n zero = s;\n }\n \n public boolean all() {\n return one.size() == size;\n }\n \n public boolean one() {\n return one.size()>=1;\n }\n \n public int count() {\n return one.size();\n }\n \n public String toString() {\n StringBuilder sb= new StringBuilder();\n for(int i=0;i\nclass BrowserHistory {\npublic: \n // // 1. using 2 stacks\n// stack ur, fb;\n// BrowserHistory(string homepage) {\n// ur.push(homepage);\n// fb = stack();\n// }\n \n// void visit(string url) { \n// ur.push(url);\n// fb = stack();\n// }\n \n// string back(int steps) {\n// while(steps>0 and ur.size() > 1){\n// fb.push(ur.top());\n// ur.pop();\n// steps--;\n// }\n// return ur.top();\n// }\n \n// string forward(int steps) {\n// while(steps>0 and fb.size()>0){\n// ur.push(fb.top());\n// fb.pop();\n// steps--;\n// }\n// return ur.top();\n// }\n \n \n // 2. using array of strings more efficient than 1. \n string ur[5000];\n int cur=0, end=0;\n \n BrowserHistory(string homepage) {\n ur[0] = homepage;\n }\n \n void visit(string url) { \n cur++;\n ur[cur] = url;\n end = cur;\n }\n \n string back(int steps) {\n if(steps>cur) cur=0;\n else cur-=steps;\n return ur[cur];\n }\n \n string forward(int steps) {\n if(cur+steps>end) cur=end;\n else cur+=steps;\n return ur[cur];\n }\n \n \n};\n" }, { "path": "Diagonal Traversal of Binary Tree - GFG/README.md", "content": "# Diagonal Traversal of Binary Tree\n## Medium \n
\n

Given a Binary Tree, print the diagonal traversal of the binary tree.

\n\n

Consider lines of slope -1 passing between nodes. Given a Binary Tree, print all diagonal elements in a binary tree belonging to same line.

\n\n

Example 1:

\n\n
Input :\n            8\n         /     \\\n        3      10\n      /   \\      \\\n     1     6     14\n         /   \\   /\n        4     7 13\nOutput : 8 10 14 3 6 7 13 1 4\nExplanation:\n\"unnamed\"\nDiagonal Traversal of binary tree : \n 8 10 14 3 6 7 13 1 4\n
\n\n

Your Task:
\nYou don't need to read input or print anything. The task is to complete the function diagonal() that takes the root node as input argumets and returns the diagonal traversal of the given tree.

\n\n

Expected Time Complexity: O(N).
\nExpected Auxiliary Space: O(N).
\nHere N is number of nodes.

\n\n

Constraints:
\n1 <= Number of nodes<= 105
\n1 <= Data of a node<= 105
\n 

\n

\n
" }, { "path": "Diagonal Traversal of Binary Tree - GFG/diagonal-traversal-of-binary-tree.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Contributed by Sudarshan Sharma\nimport java.util.LinkedList; \nimport java.util.Queue; \nimport java.io.*;\nimport java.util.*;\n\nclass Node{\n int data;\n Node left;\n Node right;\n Node(int data){\n this.data = data;\n left=null;\n right=null;\n }\n}\nclass GfG {\n \n static Node buildTree(String str){\n \n if(str.length()==0 || str.charAt(0)=='N'){\n return null;\n }\n \n String ip[] = str.split(\" \");\n // Create the root of the tree\n Node root = new Node(Integer.parseInt(ip[0]));\n // Push the root to the queue\n \n Queue queue = new LinkedList<>(); \n \n queue.add(root);\n // Starting from the second element\n \n int i = 1;\n while(queue.size()>0 && i < ip.length) {\n \n // Get and remove the front of the queue\n Node currNode = queue.peek();\n queue.remove();\n \n // Get the current node's value from the string\n String currVal = ip[i];\n \n // If the left child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the left child for the current node\n currNode.left = new Node(Integer.parseInt(currVal));\n // Push it to the queue\n queue.add(currNode.left);\n }\n \n // For the right child\n i++;\n if(i >= ip.length)\n break;\n \n currVal = ip[i];\n \n // If the right child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the right child for the current node\n currNode.right = new Node(Integer.parseInt(currVal));\n \n // Push it to the queue\n queue.add(currNode.right);\n }\n i++;\n }\n \n return root;\n }\n static void printInorder(Node root)\n {\n if(root == null)\n return;\n \n printInorder(root.left);\n System.out.print(root.data+\" \");\n \n printInorder(root.right);\n }\n \n\tpublic static void main (String[] args) throws IOException{\n\t BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t \n\t int t=Integer.parseInt(br.readLine());\n \n\t while(t-- > 0){\n\t String s = br.readLine();\n \t \tNode root = buildTree(s);\n \t Tree g = new Tree();\n\t\t\t ArrayList diagonalNode = g.diagonal(root);\n\t\t\t for(int i = 0 ;i diagonal(Node root)\n {\n //add your code here.\n Queue q=new LinkedList<>();\n ArrayList ans=new ArrayList<>();\n q.add(root);\n while(!q.isEmpty()){\n Node temp=q.remove();\n while(temp!=null){\n if(temp.left!=null){\n q.add(temp.left);\n }\n ans.add(temp.data);\n temp=temp.right;\n }\n }\n return ans;\n }\n}\n" }, { "path": "Different Bits Sum Pairwise.java", "content": "public class Solution {\n public int cntBits(ArrayList A) {\n long total = 0, n = A.size();\n \n for (int j=0;j<32;j++) {\n long bitCount = 0;\n for (int i=0;i> j) & 1;\n total += (bitCount % (1000000007) *(n - bitCount) % (1000000007)) % (1000000007) ;\n }\n total = (total*2) % (1000000007);\n return (int)total;\n}\n \n}\n" }, { "path": "Diffk II.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public int diffPossible(final int[] A, int B) {\n Set set=new HashSet<>();\n for(int i:A){\n if(set.contains(i-B) || set.contains(B+i))return 1;\n set.add(i);\n }\n return 0;\n }\n}\n" }, { "path": "Diffk.java", "content": "public class Solution {\n public int diffPossible(int[] a, int k) {\n int i=0;\n int j=1;\n while(ik){\n if(i==j-1){\n j++;\n }\n i++;\n }\n }\n return 0;\n }\n}\n" }, { "path": "Digital Root.java", "content": "public class Solution {\n public int solve(int A) {\n while(A>9){\n int temp=0;\n while(A!=0){\n temp+=(A%10);\n A/=10;\n }\n A=temp;\n }\n return A;\n }\n}\n" }, { "path": "Dijkstra’s_Algorithm_Shortest_distance.cpp", "content": "#include\nusing namespace std;\nvoid dij(vector> adj[], int n, int src)\n{\n vector vis(n, 0);\n priority_queue, vector>, greater>> pq;\n vector dis(n, INT_MAX);\n\n pq.push({0, src});\n dis[src] = 0;\n while (!pq.empty())\n {\n int dist = pq.top().first;\n int prev = pq.top().second;\n pq.pop();\n vector>::iterator it;\n for (it = adj[prev].begin(); it != adj[prev].end(); it++)\n {\n int next = it->first;\n int nextdist=it->second;\n if (dis[next] > dis[prev] + nextdist)\n {\n dis[next] = dis[prev] + nextdist;\n pq.push({dis[next],next});\n }\n }\n }\n for (int i = 0; i < dis.size(); i++)\n {\n dis[i]==INT_MAX?cout<<\"INF\"<<\" \":cout<> m >> n;\n vector> adj[m];\n for (int i = 0; i < n; i++)\n {\n int x, y, w;\n cin >> x >> y >> w;\n adj[x].push_back({y, w});\n }\n int src;\n cin >> src;\n dij(adj, m, src);\n}\n" }, { "path": "Distance from the Source (Bellman-Ford Algorithm).java", "content": "\n\nclass Solution\n{\n static int[] bellman_ford(int V, ArrayList> adj, int S)\n {\n // Write your code here\n int[]distance=new int[V];\n Arrays.fill(distance,100000000);\n distance[S]=0;\n \n for(int i=1;i a:adj){\n int src=a.get(0);\n int des=a.get(1);\n int weight=a.get(2);\n if(distance[src] + weight < distance[des]){\n distance[des]=distance[src] + weight;\n }\n }\n }\n return distance;\n }\n}\n" }, { "path": "Distinct Numbers in Window.java", "content": "public class Solution {\n public ArrayList dNums(ArrayList a, int B) {\n ArrayList ans=new ArrayList<>();\n int n=a.size();\n if(B>n)return ans;\n \n Map map=new HashMap<>();\n for(int i=0;i set=new HashSet<>();\n int n=s.length();\n for(int i=0;i=0 && right=0 && right A) {\n int sum=0;\n if(A.size()==1 && A.get(0)==0) return 1;\n boolean zero=false;\n boolean even=false;\n for(int i:A){\n if(i==0)zero=true;\n if(i%2==0 && i!=0)even=true;\n sum+=i;\n }\n if(sum%3==0 && zero && even)return 1;\n return 0;\n }\n}\n" }, { "path": "Dungeon Princess.java", "content": "public class Solution {\n public int calculateMinimumHP(int[][] A) {\n \n int m=A.length;\n int n=A[0].length;\n \n A[m-1][n-1]=Math.max(1,-1*A[m-1][n-1]+1);\n \n for(int i=m-1;i>=0;i--){\n for(int j=n-1;j>=0;j--){\n \n if(i==m-1 && j==n-1){\n continue;\n }else if(i==m-1){\n A[i][j]=Math.max(1,A[i][j+1]-A[i][j]);\n }else if(j==n-1){\n A[i][j]=Math.max(1,A[i+1][j]-A[i][j]);\n }else{\n A[i][j]=Math.max(1,Math.min(A[i+1][j],A[i][j+1])-A[i][j]);\n }\n \n }\n }\n \n return A[0][0];\n }\n}\n\n" }, { "path": "Earthquake and the Paint Shop - GFG/README.md", "content": "# Earthquake and the Paint Shop\n## Easy\n

Geek's Paint Shop is one of the famous shop in Geekland, but 2014 Earthquake caused disarrangement of the items in his shop. Each item in his shop is a 40-digit alpha numeric code .
\nNow Chunky wants to retain the reputation of his shop, for that he has to arrange all the distinct items in lexicographical order.
\nYour task is to arrange the all the distinct items in lexicographical ascending order and print them along with their count.

\n\n

Example 1:

\n\n
Input:\nN = 3\nA[] =\n[\"2234597891 zmxvvxbcij 8800654113 jihgfedcba\",\n\"1234567891 abcdefghij 9876543219 jihgfedcba\",\n\"2234597891 zmxvvxbcij 8800654113 jihgfedcba\"]\nOutput:\n1234567891 abcdefghij 9876543219 jihgfedcba 1\n2234597891 zmxvvxbcij 8800654113 jihgfedcba 2\nExplanation:\nWe have 3 items (40 digit alphanumeric codes) \nhere. We arrange the items based on the \nlexicographical order of their alpha-numeric \ncode. Distinct items are printed only once. \nThe count of the items describes how many \nsuch items are there, so items that appear \nmore than once have their count greater than 1.
\n\n

Example 2:

\n\n
Input:\nN = 2\nA[] =\n[\"3122049353 onafrnbhtr 9822827304 yzfhdgzcvx\", \n\"2992299540 lpvkgykmlk 6946169466 vdqwvywwgg\", \nOutput:\n2992299540 lpvkgykmlk 6946169466 vdqwvywwgg  1\n3122049353 onafrnbhtr 9822827304 yzfhdgzcvx  1\nExplanation:\nOut of the 2 items here no one is repeated.
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function sortedStrings() which takes an integer N and an array of strings A[ ] and returns the array in sorted order along with the frequency of each distinct string.

\n\n

Expected Time Complexity:O(NlogN)
\nExpected Auxillary Space:O(N)

\n\n

Constraints:
\n1 ≤ N ≤ 10000

\n
" }, { "path": "Earthquake and the Paint Shop - GFG/earthquake-and-the-paint-shop.java", "content": "//{ Driver Code Starts\n// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n String s[] = new String[N];\n for (int i = 0; i < N; i++) s[i] = read.readLine();\n Solution ob = new Solution();\n alphanumeric ans[] = ob.sortedStrings(N, s);\n for (int i = 0; i < ans.length; i++)\n System.out.println(ans[i].name + \" \" + ans[i].count);\n }\n }\n}\n// } Driver Code Ends\n\n\n// User function Template for Java\n\nclass alphanumeric {\n public String name;\n public int count;\n alphanumeric(String name, int count) {\n this.name = name;\n this.count = count;\n }\n};\nclass Solution {\n alphanumeric[] sortedStrings(int N, String A[]) {\n TreeMap mp = new TreeMap<>();\n for(String s: A){\n mp.put(s,mp.getOrDefault(s,0)+1);\n }\n int k = mp.size();\n alphanumeric[] ans = new alphanumeric[k];\n int t = 0;\n for(String s:mp.keySet()){\n ans[t++] = new alphanumeric(s,mp.get(s));\n }\n return ans;\n }\n};" }, { "path": "Egg Dropping Puzzle.java", "content": "class Solution \n{\n //Function to find minimum number of attempts needed in \n //order to find the critical floor.\n static int eggDrop(int n, int k) \n\t{\n\t // Your code here\n\t int[][]dp=new int[n+1][k+1];\n\t \n\t //eggs are 1\n\t for(int j=1;j<=k;j++){\n\t dp[1][j]=j;\n\t }\n\t \n\t //f;oors are 1\n\t for(int i=0;i<=n;i++){\n\t dp[i][1]=1;\n\t }\n\t \n\t for(int i=2;i<=n;i++){\n\t for(int j=2;j<=k;j++){\n\t int res=j;\n\t \n\t for(int t=1;t<=j;t++){\n\t //break\n\t int temp1=1+ dp[i-1][t-1];\n\t //not break\n\t int temp2=1+ dp[i][j-t];\n\t //worst case \n\t int ans=Math.max(temp1,temp2);\n\t res=Math.min(res,ans);\n\t }\n\t dp[i][j]=res;\n\t }\n\t }\n\t \n\t return dp[n][k];\n\t \n\t}\n}\n" }, { "path": "Elements in the Range.java", "content": "class Solution\n{\n boolean check_elements(int arr[], int n, int A, int B)\n {\n if(B-A>=n)return false;\n for(int i=0;i=A && Math.abs(arr[i])<=B){\n int ind=Math.abs(arr[i])-A;\n if(arr[ind]>0)arr[ind]*=-1;\n }\n }\n \n for(int i=0;i<=B-A;i++){\n if(arr[i]>0)return false;\n }\n return true;\n \n }\n}\n" }, { "path": "Equivalent Sub-Arrays - GFG/README.md", "content": "# Equivalent Sub-Arrays\n## Medium \n
\n

Given an array arr[] of n integers. Count the total number of sub-array having total distinct elements same as that of total distinct elements of the original array.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN=5\narr[] = {2, 1, 3, 2, 3} \nOutput: 5\nExplanation:\nTotal distinct elements in array is 3\nTotal sub-arrays that satisfy the condition\nare:\nSubarray from index 0 to 2\nSubarray from index 0 to 3\nSubarray from index 0 to 4\nSubarray from index 1 to 3\nSubarray from index 1 to 4
\n\n


\nExample 2:

\n\n
Input:\nN=5\narr[] = {2, 4, 4, 2, 4} \nOutput: 9\n
\n\n


\nYour Task:
\nSince, this is a function problem. You don't need to take any input, as it is already accomplished by the driver code. You just need to complete the function countDistinctSubarray() that takes array arr and integer n  as parameters and returns the desired result.

\n\n

 

\n\n

Expected Time Complexity: O(N).
\nExpected Auxiliary Space: O(N).

\n\n

 

\n\n

Constraints:
\n1 ≤ N ≤ 104

\n\n

 

\n

\n
" }, { "path": "Equivalent Sub-Arrays - GFG/equivalent-sub-arrays.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n\n//Initial Template for Java\n\n\nimport java.io.*;\nimport java.util.*;\n\n\n // } Driver Code Ends\n//User function Template for Java\n\n\nclass Solution\n{ \n // Method to calculate distinct sub-array \n static int countDistinctSubarray(int arr[], int n) \n { \n int res = 0;\n HashSet set = new HashSet<>();\n HashMap map = new HashMap<>();\n \n for(int i : arr)set.add(i);\n \n for(int j = 0,i = 0;i < arr.length;i++){\n map.put(arr[i],map.getOrDefault(arr[i],0) + 1);\n \n if(map.size() == set.size())\n res = res + (arr.length - i);\n \n while(map.size() >= set.size() && j <= i){\n map.put(arr[j],map.get(arr[j]) - 1);\n \n if(map.get(arr[j]) <= 0)\n map.remove(arr[j]);\n \n if(map.size() == set.size())\n res = res + (arr.length - i);\n \n j++;\n }\n }\n \n return res;\n }\n}\n\n// { Driver Code Starts.\n\n// Driver class\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t int n=Integer.parseInt(br.readLine());\n\t\t String line1 = br.readLine();\n\t\t String[] a1 = line1.trim().split(\"\\\\s+\");\n\t\t int a[]=new int[n];\n\t\t for(int i=0;i\n

Given an adjacency matrix representation of an unweighted undirected graph named graph, which has N vertices. You have to find out if there is an eulerian path present in the graph or not.
\nNote: The graph consists of a single component

\n\n

Example 1:

\n\n
Input: N = 5\ngraph = {{0, 1, 0, 0, 1}, \n         {1, 0, 1, 1, 0}, \n         {0, 1, 0, 1, 0}, \n         {0, 1, 1, 0, 0}, \n         {1, 0, 0, 0, 0}}\nOutput: 1\nExplaination: There is an eulerian path. \nThe path is 5->1->2->4->3->2.
\n\n

Example 2:

\n\n
Input: N = 5\ngraph = {{0, 1, 0, 1, 1}, \n         {1, 0, 1, 0, 1}, \n         {0, 1, 0, 1, 1}, \n         {1, 1, 1, 0, 0}, \n         {1, 0, 1, 0, 0}}\nOutput: 0\nExplaination: There is no eulerian path in \nthe graph.
\n\n

Your Task:
\nYou do not need to read input or print anything. Your task is to complete the function eulerPath() which takes N and graph as input parameters and returns 1 if there is an eulerian path. Otherwise returns 0.

\n\n

Expected Time Complexity: O(N2)
\nExpected Auxiliary Space: O(N2)

\n\n

Constraints:
\n1 ≤ N ≤ 50 

\n

\n " }, { "path": "Eulerian Path in an Undirected Graph - GFG/eulerian-path-in-an-undirected-graph.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n int N = Integer.parseInt(in.readLine());\n int graph[][] = new int[N][N];\n for(int i = 0;i < N;i++){\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n for(int j = 0;j < N;j++)\n graph[i][j] = Integer.parseInt(a[j]);\n }\n \n Solution ob = new Solution();\n System.out.println(ob.eulerPath(N, graph));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static int eulerPath(int n, int arr[][]){\n // code here\n int count = 0;\n for(int ar[]: arr){\n int sum = 0;\n for(int i: ar){\n sum+=i;\n }\n if(sum%2==0)count++;\n if(count==(n-2))return 1;\n }\n return 0;\n }\n}" }, { "path": "Evaluate Expression To True.java", "content": "public class Solution {\n\n int [][] DT = new int[151][151];\n int [][] DF = new int[151][151];\n int mod = 1003;\n\n public int cnttrue(String A) {\n for (int[] row: DT) Arrays.fill(row, -1);\n for (int[] row: DF) Arrays.fill(row, -1);\n return solveTrue(A, 0, A.length()-1)%1003;\n }\n\n int solveTrue(String A, int i, int j){\n if(i>j) return 0;\n if(i==j){\n return A.charAt(i)=='T' ? 1 : 0;\n } \n if(DT[i][j] != -1){\n return DT[i][j];\n }\n int count = 0;\n for(int k=i; kj) return 0;\n if(i==j){\n return A.charAt(i)=='F' ? 1 : 0;\n } \n if(DF[i][j] != -1){\n return DF[i][j];\n }\n int count = 0;\n\n for(int k=i; k stack=new ArrayDeque<>();\n int i=0;\n while(i\n

Given an array arr[] of size N containing equal number of odd and even numbers. Arrange the numbers in such a way that all the even numbers get the even index and odd numbers get the odd index.
\nNote: There are multiple possible solutions, Print any one of them. Also, 0-based indexing is considered.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 6\narr[] = {3, 6, 12, 1, 5, 8}\nOutput:\n1\nExplanation:\n6 3 12 1 8 5 is a possible solution.\nThe output will always be 1 if your\nrearrangement is correct.\n
\n\n
Example 2:
\n\n
Input:\nN = 4\narr[] = {1, 2, 3, 4}\nOutput :\n1\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function reArrange() which takes an integer N and an array arr of size N as input and reArranges the array in Place without any extra space.

\n\n


\nExpected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 ≤ N ≤ 105
\n1 ≤ arr[i] ≤ 105

\n

\n " }, { "path": "Even and Odd - GFG/even-and-odd.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n \n String S[] = read.readLine().split(\" \");\n int[] arr = new int[N];\n \n for(int i=0; i=2){\n ans++;\n break;\n }\n }\n return ans;\n }\n}\n" }, { "path": "Excel Column Title.java", "content": "public class Solution {\n public String convertToTitle(int n) {\n String ans=\"\";\n while(n!=0){\n n--;\n int rem=n%26;\n ans=(char)(rem+65)+ans;\n n=n/26;\n }\n return ans;\n }\n}\n" }, { "path": "Excel Sheet Column Number.java", "content": "class Solution {\n public int titleToNumber(String columnTitle) {\n int ans = 0;\n for(char c : columnTitle.toCharArray()){\n ans = ans * 26 + (int)(c-'A')+ 1;\n }\n return ans;\n }\n}\n\n//===========================================================\n\nclass Solution {\n public int titleToNumber(String columnTitle) {\n if(columnTitle == null || columnTitle.length() == 0){\n return 0;\n }\n int multipier = 0, result = 0;\n for(int i = columnTitle.length() -1 ; i >= 0 ; i-- ){\n int val = columnTitle.charAt(i) - 'A'+1;\n result = (int) (val * Math.pow(26,multipier)) + result;\n multipier += 1;\n //System.out.println(val+\" result : \"+result+\" multipier :\"+multipier);\n }\n return result;\n }\n}\n" }, { "path": "Exceptionally odd.java", "content": "\nclass Solution {\n int getOddOccurrence(int[] arr, int n) {\n // code here\n int ans=0;\n for(int i:arr)ans=ans^i;\n return ans;\n }\n}\n" }, { "path": "Fact Digit Sum/Fact-Digit-Sum.cpp", "content": "class Solution{\n\tpublic:\n\tlong factorial(long n){\n\t if(n==0) return 1;\n\t return n*factorial(n-1);\n\t}\n\tvector FactDigit(int N)\n\t{\n\t // Code here\n\t vector ans;\n\t while(N != 0){\n\t for(int i=9;i>=0;i--){\n\t if(N >= factorial(i)){\n\t ans.push_back(i);\n\t N -= factorial(i);\n\t break;\n\t }\n\t }\n\t }\n\t sort(ans.begin(), ans.end());\n\t return ans;\n\t}\n};\n" }, { "path": "Fact Digit Sum.cpp", "content": "class Solution{\n\tpublic:\n\tvector FactDigit(int N)\n\t{\n\t // Code here\n\t vector fact(10,1);\n\t \n\t for(int i=1; i<10; i++)\n\t fact[i] = (fact[i-1]*i);\n\t \n\t vector ans;\n\t \n\t int f = 9;\n\t \n\t while(N)\n\t {\n\t if(fact[f] <= N)\n\t {\n\t N -= fact[f];\n\t ans.push_back(f);\n\t }\n\t else\n\t f--;\n\t }\n\t \n\t sort(ans.begin(), ans.end());\n\t \n\t return ans;\n\t}\n};\n" }, { "path": "Fact Digit Sum.java", "content": "class Solution\n{\n ArrayList FactDigit(int N)\n {\n // code here\n ArrayList ans=new ArrayList<>();\n int[]fact=new int[10];\n fact[0]=1;\n for(int i=1;i<10;i++){\n fact[i]=i*fact[i-1];\n }\n \n for(int i=9;i>=1;i--){\n while(N>=fact[i]){\n N-=fact[i];\n ans.add(i);\n }\n }\n Collections.reverse(ans);\n return ans;\n }\n}\n" }, { "path": "Farthest number - GFG/README.md", "content": "# Farthest number\n## Medium \n
\n

Given an array Arr[] of size N. For every element in the array, the task is to find the index of the farthest element in the array to the right which is smaller than the current element. If no such number exists then print -1.
\nNote: 0 based indexing.

\n\n


\nExample 1:

\n\n
Input: \nN=5\nArr[] = {3, 1, 5, 2, 4}\nOutput: \n3 -1 4 -1 -1\nExplanation:\nArr[3] is the farthest smallest element\nto the right of Arr[0].\nArr[4] is the farthest smallest element\nto the right of Arr[2].\nAnd for the rest of the elements, there is\nno smaller element to their right.\n
\n\n

Example 2:

\n\n
Input: \nN=5\nArr[] = {1, 2, 3, 4, 0}\nOutput: \n4 4 4 4 -1
\n\n


\nYour Task: 
\nYou don't need to read input or print anything. Your task is to complete the function farNumber() which takes the N (number of elements in Array Arr) ,Arr[], and returns the array of farthest element to the right for every element of the array.

\n\n


\nExpected Time Complexity: O(N*logN)
\nExpected Auxiliary Space: O(N)

\n\n


\nConstraints:
\n1 ≤ N ≤ 1e5
\n0 ≤ Arr[i] ≤ 1e9 

\n

\n
" }, { "path": "Farthest number - GFG/farthest-number.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*; \n\nclass GFG{\n public static void main(String args[]) throws IOException { \n BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); \n PrintWriter out = new PrintWriter(System.out);\n \n int t = Integer.parseInt(br.readLine()); \n\n while(t > 0){\n \tint N = Integer.parseInt(br.readLine()); \n \tint[] Arr = new int[N];\n \tString line = br.readLine(); \n String[] strs = line.trim().split(\"\\\\s+\"); \n \tfor(int i=0; ii){\n\t if(a[j] rank[rootY])\n root[rootY] = rootX;\n else if (rank[rootX] < rank[rootY])\n root[rootX] = rootY;\n else {\n root[rootY] = rootX;\n rank[rootY]++;\n }\n size--;\n }\n }\n \n public int getSets() {\n return size;\n }\n}\n" }, { "path": "Fill the Tank - GFG/README.md", "content": "# Fill the Tank\n## Medium \n
\n

In a city, N water tanks are connected by pipeline(As a tree) where the ith tank has a capacity cap[i]. The ith element of the given Edge array of length N-1 represents that there is a pipeline between Edge[i][0] and Edge[i][1] tank. Since people working at the city corporation are lazy they usually select one of the tank and pour complete amount of water into it, when the tank is filled, the excess water evenly flows to the connected tanks. The head of city corporation has instructed to pour minimum amount of water into the selected tank so that all other tank is filled. As the labours of the corporation are not intelligent enough to figure out the minimum amount of water required to fill all the tanks they have asked your help. Also Maximum amount of water available with city corporation is 1018.

\n\n

NOTE: If the tank if full, the water flows to all of its connected tanks except the tank from which the water had come to it. i.e, to all tanks except the source for that particular tank. If it has no option to flow the water is considered to be wasted. S is the source tank.

\n\n

Example 1:

\n\n
Input:\nN = 4 and S = 1\nEdges = [[1, 2], [1, 3], [2, 4]]\nCap = [1, 1, 1, 1]\nOutput: 5\nExplanation:\nInitially 5 unit of water is poured into \ntank 1. 2 unit of it flows to tank 2 and \n2 unit of it flows into tank 3. From 2 \nunit of water in tank 2, 1 unit flows into \ntank 4 and 1 unit from tank 3 is wasted.\n\"\"\n\n\n
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 3 and S = 2\nEdges = [[1, 2], [2, 3]]\nCap = [1, 1, 1]\nOutput: 3\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function minimum_amount() which takes an integer N, an integer S, 2-d array Edges, and an array Cap of length N as input parameters and returns the minimum amount of water required to fill all the tanks. If it is not possible to fill all the tanks print -1.
\n
\nExpected Time Complexity: O(N*log(S))
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n1 ≤ n ≤ 100000
\n1 ≤ s,u,v ≤ n
\n1 ≤ capacity of each tank ≤ 1000000007

\n

\n
" }, { "path": "Fill the Tank - GFG/fill-the-tank.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n int S = Integer.parseInt(input_line[1]);\n String input_line1[] = read.readLine().trim().split(\"\\\\s+\");\n int cap[] = new int[N];\n for(int i=0;i> adj = new ArrayList<>();\n for(int i=0; i<=N; i++){\n adj.add(new ArrayList<>());\n }\n for(int i=0; i> adj, int s, int[] cap, boolean[] visited){\n long res = -1;\n visited[s] = true;\n int sz = 0;\n for(int x: adj.get(s)){\n if(visited[x])continue;\n sz++;\n long cur = ans(adj,x,cap,visited);\n if(cur>10E17) visited[0] = true;\n res = Math.max(res,cur);\n }\n long curAns = res*sz + cap[s-1];\n if(curAns>10E17) visited[0] = true;\n return curAns;\n }\n}\n" }, { "path": "Filling Bucket - GFG/README.md", "content": "# Filling Bucket\n## Medium\n

Given a Bucket having a capacity of N litres and the task is to determine that by how many ways you can fill it using two bottles of capacity of 1 Litre and 2 Litre only. Find the answer modulo 108.

\n\n

Example 1:

\n\n
Input:\n3\nOutput:\n3 \nExplanation:\nLet O denote filling by 1 litre bottle and\nT denote filling by 2 litre bottle.\nSo for N = 3, we have :\n{OOO,TO,OT}. Thus there are 3 total ways.
\n\n

Example 2:

\n\n
Input:\n4\nOutput:\n5 \nExplanation:\nLet O denote filling by 1 litre bottle and\nT denote filling by 2 litre bottle.\nSo for N = 4, we have :\n{TT,OOOO,TOO,OTO,OOT} thus there are 5 total ways.\n
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function fillingBucket() which takes an Integer N as input and returns the number of total ways possible.

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(N)

\n\n

Constraints:
\n1 <= N <= 105

\n
" }, { "path": "Filling Bucket - GFG/filling-bucket.java", "content": "//{ Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n\n Solution ob = new Solution();\n System.out.println(ob.fillingBucket(N));\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution {\n static int fillingBucket(int N) {\n // code here\n if(N==1)return 1;\n int prev=2;\n int secPrev=1;\n int mod=100000000;\n for(int i=0;i findAnagrams(String s, String p) {\n int ns = s.length(), np = p.length();\n List results = new ArrayList<>();\n int[] charMap = new int[26];\n \n for (char c:p.toCharArray()) {\n charMap[c - 'a']++;\n }\n \n for (int i = 0; i < ns; i++) {\n char c = s.charAt(i);\n charMap[c - 'a']--;\n if (i >= np) {\n char last = s.charAt(i - np);\n charMap[last - 'a']++;\n }\n \n if (i >= np - 1) {\n boolean valid = true;\n for (int j = 0; j < 26; j++) {\n if (charMap[j] != 0) {\n valid = false;\n break;\n }\n }\n if (valid) {\n results.add(i - np + 1);\n }\n }\n }\n \n return results;\n }\n}\n" }, { "path": "Find Last Digit.java", "content": "import java.math.BigInteger;\npublic class Solution {\n public int solve(String A, String B) {\n int n=A.length();\n if(A.charAt(n-1)=='1'){\n return 1;\n }else if(A.charAt(n-1)=='0'){\n return 0;\n }else if(A.charAt(n-1)=='5'){\n return 5;\n }else if(A.charAt(n-1)=='6'){\n return 6;\n }else if(A.charAt(n-1)=='2'){\n int pattern[]=new int[]{2,4,8,6};\n BigInteger in=new BigInteger(B);\n BigInteger sz=BigInteger.valueOf(4);\n int x=in.mod(sz).intValue();\n if(x==0)return pattern[3];\n return pattern[x-1];\n }else if(A.charAt(n-1)=='3'){\n int pattern[]=new int[]{3,9,7,1};\n BigInteger in=new BigInteger(B);\n BigInteger sz=BigInteger.valueOf(4);\n int x=in.mod(sz).intValue();\n if(x==0)return pattern[3];\n return pattern[x-1];\n }else if(A.charAt(n-1)=='4'){\n int pattern[]=new int[]{4,6};\n BigInteger in=new BigInteger(B);\n BigInteger sz=BigInteger.valueOf(2);\n int x=in.mod(sz).intValue();\n if(x==0)return pattern[1];\n return pattern[x-1];\n }else if(A.charAt(n-1)=='7'){\n int pattern[]=new int[]{7,9,3,1};\n BigInteger in=new BigInteger(B);\n BigInteger sz=BigInteger.valueOf(4);\n int x=in.mod(sz).intValue();\n if(x==0)return pattern[3];\n return pattern[x-1];\n }else if(A.charAt(n-1)=='8'){\n int pattern[]=new int[]{8,4,2,6};\n BigInteger in=new BigInteger(B);\n BigInteger sz=BigInteger.valueOf(4);\n int x=in.mod(sz).intValue();\n if(x==0)return pattern[3];\n return pattern[x-1];\n }else if(A.charAt(n-1)=='9'){\n int pattern[]=new int[]{9,1};\n BigInteger in=new BigInteger(B);\n BigInteger sz=BigInteger.valueOf(2);\n int x=in.mod(sz).intValue();\n if(x==0)return pattern[1];\n return pattern[0];\n }\n return 1;\n }\n}\n" }, { "path": "Find Missing And Repeating.java", "content": "class Solve {\n int[] findTwoElement(int arr[], int n) {\n // code here\n int[]ans=new int[2];\n for(int i=0;i0){\n ans[1]=i+1;\n break;\n }\n }\n return ans;\n }\n}\n" }, { "path": "Find Original Array From Doubled Array.java", "content": "class Solution {\n public int[] findOriginalArray(int[] changed) {\n int f[]=new int[100001];\n if(changed.length%2==1) return new int[0]; // if Array Length is odd cant find\n for(int i=0;i0) {\n if(k*2>100000 || f[k*2]==0) return new int[0]; //As Array values always <=100000 and cant be greater values cannot find k*2>1000000 which is false and id the frequency of k*2==0 means return false\n else {\n f[k*2]-=1;\n f[k]-=1;\n res[ind++]=i;\n }\n } \n }\n return res;\n }\n}\n" }, { "path": "Find Prime numbers in a range.java", "content": "class Solution {\n ArrayList primeRange(int M, int N) {\n // code here\n ArrayList list=new ArrayList<>();\n for(int i=M;i<=N;i++){\n if(isPrime(i))list.add(i);\n }\n return list;\n }\n boolean isPrime(int n){\n // Corner cases\n if (n <= 1)\n return false;\n if (n <= 3)\n return true;\n \n // This is checked so that we can skip\n // middle five numbers in below loop\n if (n % 2 == 0 || n % 3 == 0)\n return false;\n \n for (int i = 5; i * i <= n; i = i + 6)\n if (n % i == 0 || n % (i + 2) == 0)\n return false;\n \n return true;\n }\n}\n" }, { "path": "Find Second Smallest and Second Largest Element in an array without sorting/Find-Second-Smallest-and-Second-Largest-Element-in-an-array-with-out-sorting.cpp", "content": "// Find Second Smallest and Second Largest Element in an array without sorting\n\n#include \nusing namespace std;\nint main()\n{\n int arr[6] = {1, 2, 4, 7, 7, 5};\n int n = sizeof(arr) / sizeof(arr[0]);\n int small = INT_MAX, second_small = INT_MAX, large = INT_MIN, second_large = INT_MIN;\n for (int i = 0; i < n; i++)\n {\n if (arr[i] < small) // if any number is still smaller than the current smaller then update second smaller and small number\n {\n second_small = small;\n small = arr[i]; \n }\n else if (arr[i] < second_small and arr[i] != small)\n second_small = arr[i];\n if (arr[i] > large)\n {\n second_large = large; // if any number is still larger thab the current largest then update the second largest and large number\n large = arr[i]; \n }\n else if (arr[i] > second_large and arr[i] != large)\n second_large = arr[i];\n }\n cout << small << \" \" << large << '\\n';\n cout << second_small << \" \" << second_large << '\\n';\n}\n" }, { "path": "Find Three Consecutive Integers That Sum to a Given Number.py", "content": "class Solution:\n def sumOfThree(self, num: int) -> List[int]:\n x=num//3\n a=[x-1,x,x+1]\n if 3*x !=num:\n return []\n return a\n \n" }, { "path": "Find Transition Point - GFG/README.md", "content": "# Find Transition Point\n## Easy \n
\n

Given a sorted array containing only 0s and 1s, find the transition point. 

\n\n


\nExample 1:

\n\n
Input:\nN = 5\narr[] = {0,0,0,1,1}\nOutput: 3\nExplanation: index 3 is the transition \npoint where 1 begins.
\n\n


\nExample 2:

\n\n
Input:\nN = 4\narr[] = {0,0,0,0}\nOutput: -1\nExplanation: Since, there is no \"1\",\nthe answer is -1.
\n\n


\nYour Task:
\nYou don't need to read input or print anything. The task is to complete the function transitionPoint() that takes array and N as input parameters and returns the 0 based index of the position where \"0\" ends and \"1\" begins. If array does not have any 1s, return -1. If array does not have any 0s, return 0.

\n\n


\nExpected Time Complexity: O(LogN)
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 ≤ N ≤ 500000
\n0 ≤ arr[i] ≤ 1

\n

\n
" }, { "path": "Find Transition Point - GFG/find-transition-point.java", "content": "// { Driver Code Starts\nimport java.util.*;\n\nclass Sorted_Array {\n public static void main(String args[]) {\n Scanner sc = new Scanner(System.in);\n int T = sc.nextInt();\n while (T > 0) {\n int n = sc.nextInt();\n int arr[] = new int[n];\n for (int i = 0; i < n; i++) {\n arr[i] = sc.nextInt();\n }\n GfG obj = new GfG();\n System.out.println(obj.transitionPoint(arr, n));\n T--;\n }\n }\n}// } Driver Code Ends\n\n\nclass GfG {\n int transitionPoint(int arr[], int n){\n int i=0;\n int j=n;\n int mid;\n while(i A) {\n if(A.size()==1)return A.get(0);\n for(int i=0;iA.get(i+1))return A.get(i);\n }else if(i==A.size()-1){\n if(A.get(A.size()-1)>A.get(i-2))return A.get(A.size()-1);\n }else{\n if(A.get(i)>A.get(i+1) && A.get(i)>A.get(i-1))return A.get(i);\n }\n }\n return -1;\n }\n}\n" }, { "path": "Find all distinct subset (or subsequence) sums - GFG/Find all distinct subset (or subsequence) sums.cpp", "content": "// two solutions:\r\n\r\n\r\n// 1.\r\nclass Solution {\r\npublic:\r\n set s;\r\n int dp[101][10001];\r\n\tvector DistinctSum(vectornums){\r\n\t int n = nums.size();\r\n\t memset(dp, -1, sizeof(dp));\r\n\t solve(0, nums, n);\r\n\t vector ans;\r\n\t for(auto& val: s) {\r\n\t ans.push_back(val);\r\n\t }\r\n\t return ans;\r\n\t}\r\n\tvoid solve(int sum, vector& nums, int n) {\r\n\t if(n==0) {\r\n\t s.insert(sum);\r\n\t return;\r\n\t }\r\n\t if(dp[n][sum]==1) return;\r\n\t solve(sum+nums[n-1], nums, n-1);\r\n\t solve(sum, nums, n-1);\r\n\t dp[n][sum] = 1;\r\n\t}\r\n};\r\n\r\n\r\n// 2. \r\nclass Solution {\r\npublic:\r\n\tvector DistinctSum(vector nums){\r\n\t // Code here\r\n\t set st;\r\n\t st.insert(0);\r\n\t for(auto num : nums){\r\n\t vector v;\r\n\t for(auto i : st) v.push_back(i + num);\r\n\t for(auto vv : v) st.insert(vv);\r\n\t }\r\n\t nums.clear();\r\n\t for(auto it : st) nums.push_back(it);\r\n\t return nums;\r\n\t}\r\n};\r\n" }, { "path": "Find all distinct subset (or subsequence) sums.java", "content": "class Solution\n{\n public int[] DistinctSum(int[] nums)\n {\n // Code here\n boolean[][]dp=new boolean[101][10001];\n Set set=new HashSet<>();\n dfs(nums,0,0,set,dp);\n int[] ans=new int[set.size()];\n int i=0;\n for(int ele:set){\n ans[i]=ele;\n i++;\n }\n Arrays.sort(ans);\n return ans;\n }\n void dfs(int[]nums,int i,int sum,Set set,boolean[][]dp){\n if(i==nums.length){\n set.add(sum);\n return;\n }\n if(dp[i][sum])return;\n dp[i][sum]=true;\n dfs(nums,i+1,sum,set,dp);\n dfs(nums,i+1,sum+nums[i],set,dp);\n }\n}\n" }, { "path": "Find all possible paths from top to bottom - GFG/README.md", "content": "# Find all possible paths from top to bottom\n## Easy \n
\n

Given a N x M grid. Find All possible paths from top left to bottom right.From each cell you can either move only to right or down.

\n\n

Example 1:

\n\n
Input: 1 2 3\n       4 5 6\nOutput: 1 4 5 6\n        1 2 5 6 \n        1 2 3 6\nExplanation: We can see that there are 3 \npaths from the cell (0,0) to (1,2).
\n\n

Example 2:

\n\n
Input: 1 2\n       3 4\nOutput: 1 2 4\n        1 3 4
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function findAllPossiblePaths() which takes two integers n,m and grid[][]  as input parameters and returns all possible paths from the top left cell to bottom right cell in a 2d array.

\n\n

Expected Time Complexity: O(2^N*M)
\nExpected Auxiliary Space: O(N)

\n\n


\nConstraints:
\n1 <= n,m <= 10 
\n1 <= grid[i][j] <= n*m
\nn * m < 20
\n 

\n

\n
" }, { "path": "Find all possible paths from top to bottom - GFG/find-all-possible-paths-from-top-to-bottom.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\n\nclass IntArray\n{\n public static int[] input(BufferedReader br, int n) throws IOException\n {\n String[] s = br.readLine().trim().split(\" \");\n int[] a = new int[n];\n for(int i = 0; i < n; i++)\n a[i] = Integer.parseInt(s[i]);\n \n return a;\n }\n \n public static void print(int[] a)\n {\n for(int e : a)\n System.out.print(e + \" \");\n System.out.println();\n }\n \n public static void print(ArrayList a)\n {\n for(int e : a)\n System.out.print(e + \" \");\n System.out.println();\n }\n}\n\n\nclass IntMatrix\n{\n public static int[][] input(BufferedReader br, int n, int m) throws IOException\n {\n int[][] mat = new int[n][];\n \n for(int i = 0; i < n; i++)\n {\n String[] s = br.readLine().trim().split(\" \");\n mat[i] = new int[s.length];\n for(int j = 0; j < s.length; j++)\n mat[i][j] = Integer.parseInt(s[j]);\n }\n \n return mat;\n }\n \n public static void print(int[][] m)\n {\n for(var a : m)\n {\n for(int e : a)\n System.out.print(e + \" \");\n System.out.println();\n }\n }\n \n public static void print(ArrayList> m)\n {\n for(var a : m)\n {\n for(int e : a)\n System.out.print(e + \" \");\n System.out.println();\n }\n }\n}\n\nclass GFG {\n public static void main(String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t;\n t = Integer.parseInt(br.readLine());\n while(t-- > 0){\n \n int[] a = IntArray.input(br, 2);\n \n \n int[][] grid = IntMatrix.input(br, a[0], a[1]);\n \n Solution obj = new Solution();\n ArrayList> res = obj.findAllPossiblePaths(a[0],a[1], grid);\n \n IntMatrix.print(res);\n \n }\n }\n}\n// } Driver Code Ends\n\n\nclass Solution {\n public static ArrayList> findAllPossiblePaths(int n,int m, int[][] grid) {\n // code here\n ArrayList> ans=new ArrayList<>();\n ArrayList curr=new ArrayList<>();\n int i=0;\n int j=0;\n curr.add(grid[0][0]);\n dfs(ans,curr,i,j,grid);\n return ans;\n }\n static void dfs(ArrayList> ans,ArrayListcurr,int i,int j,int[][]grid){\n if(i==grid.length-1 && j==grid[0].length-1){\n ans.add(new ArrayList<>(curr));\n return;\n }\n \n \n if(valid(i+1,j,grid)){\n curr.add(grid[i+1][j]);\n dfs(ans,curr,i+1,j,grid);\n curr.remove(curr.size()-1);\n }\n if(valid(i,j+1,grid)){\n curr.add(grid[i][j+1]);\n dfs(ans,curr,i,j+1,grid);\n curr.remove(curr.size()-1);\n }\n }\n static boolean valid(int i,int j,int[][]grid){\n if(i==grid.length || j==grid[0].length)return false;\n return true;\n }\n}\n \n" }, { "path": "Find an Replace in String - GFG/README.md", "content": "# Find an Replace in String\n## Medium \n
\n

Given a string S on which you need to perform Q replace operations.
\nEach replacement operation has 3 parameters: a starting index i, a source word x and a target word y. The rule is that if x starts at position i in the original string S, then we will replace that occurrence of x with y. If not, we do nothing.
\nNote: All these operations occur simultaneously. It's guaranteed that there won't be any overlap in replacement: for example, S = \"abc\", indexes = [0,1], sources = [\"ab\", \"bc\"] is not a valid test case.

\n\n


\nExample 1:

\n\n
Input: \nS = \"gforks\"\nQ = 2\nindex[] = {0, 4}\nsources[] = {\"g\", \"ks\"}\ntargets[] = {\"geeks\", \"geeks\"}\nOutput: \ngeeksforgeeks\nExplanation:\n\"g\" starts at index 0, so, it's reaplaced by\n\"geeks\". Similarly, \"ks\" starts at index 4,\nand is replaced by \"geeks\".\n
\n\n

Example 2:

\n\n
Input: \nS = \"gforks\"\nQ = 2\nindex[] = {0, 3}\nsources[] = {\"g\", \"ss\"}\ntargets[] = {\"geeks\", \"geeks\"}\nOutput: \ngeeksforks\nExplanation:\n\"g\" starts at index 0, so, it's reaplaced by\n\"geeks\". \"ss\" doesn't start at index 3 in\noriginal S, so it's not replaced.
\n\n


\nYour Task:
\nYou don't need to read input or print anything. You only need to complete the function findAndReplace() that takes a string S, an integer Q, and 3 arrays index, sources, and targets of size Q, as input and returns the new string after all the operations. index[i], sources[i], and targets[i] denotes the index, sources, and targets for ith query.

\n\n


\nExpected Time Complexity:  O(|S| * Q)
\nExpected Auxilliary Space: O(Q)
\n 

\n\n

Constraints:
\n1 ≤ |S| ≤ 104
\n1 ≤ Q ≤ 100
\n1 ≤ length of sourcesi, targetsi ≤ 100

\n

\n
" }, { "path": "Find an Replace in String - GFG/find-an-replace-in-string.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n String S = read.readLine();\n \n int Q = Integer.parseInt(read.readLine());\n \n int[] index = new int[Q];\n String[] sources = new String[Q];\n String[] targets = new String[Q];\n \n String S1[] = read.readLine().split(\" \");\n String S2[] = read.readLine().split(\" \");\n String S3[] = read.readLine().split(\" \");\n \n for(int i=0 ; i\n

Given a linked list of size N. The task is to complete the function countNodesinLoop() that checks whether a given Linked List contains a loop or not and if the loop is present then return the count of nodes in a loop or else return 0. C is the position of the node to which the last node is connected. If it is 0 then no loop.

\n\n

\"\"

\n\n

Example 1:

\n\n
Input:\nN = 10\nvalue[]={25,14,19,33,10,21,39,90,58,45}\nC = 4\nOutput: 7\nExplanation: The loop is 45->33. So\nlength of loop is 33->10->21->39->\n90->58->45 = 7. The number 33 is\nconnected to the last node to form the\nloop because according to the input the\n4th node from the beginning(1 based\nindex) will be connected to the last\nnode for the loop.\n
\n\n

Example 2:

\n\n
Input:\nN = 2\nvalue[] = {1,0}\nC = 1\nOutput: 2\nExplanation: The length of the loop\nis 2.
\n\n

Your Task:
\nThe task is to complete the function countNodesinLoop() which contains the only argument as reference to head of linked list and return the lenght of the loop ( 0 if there is no loop).

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)

\n\n

Constraints:
\n1 <= N <= 500
\n0 <= C <= N-1

\n

\n " }, { "path": "Find length of Loop - GFG/find-length-of-loop.java", "content": "// { Driver Code Starts\n// driver code\n\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass Node\n{\n int data;\n Node next;\n \n Node(int x)\n {\n data = x;\n next = null;\n }\n}\n\nclass GFG\n{\n public static void makeLoop(Node head, Node tail, int x){\n if (x == 0) return;\n \n Node curr = head;\n for(int i=1; i 0)\n {\n int n = sc.nextInt();\n \n int num = sc.nextInt();\n Node head = new Node(num);\n Node tail = head;\n \n for(int i=0; i> findPairsWithGivenSum(Node *head, int target)\n {\n // code here\n vector> ans;\n \n Node* front = head;\n Node* rear = head;\n \n while(rear->next)\n rear = rear->next;\n \n while(front->data < rear->data)\n {\n int num1 = front->data, num2 = rear->data;\n \n if(num1 + num2 == target)\n {\n ans.push_back({num1, num2});\n front = front->next;\n }\n \n else if(num1 + num2 > target)\n rear = rear->prev;\n \n else\n front = front->next;\n }\n \n return ans;\n }\n};\n" }, { "path": "Find pairs with given sum in doubly linked list.java", "content": "\nclass Solution {\n public static ArrayList> findPairsWithGivenSum(int target, Node head) {\n // code here\n Node tail=head;\n while(tail.next!=null)tail=tail.next;\n ArrayList> ans=new ArrayList<>();\n while(head!=tail){\n if(head.data+tail.data==target){\n ArrayList pair=new ArrayList<>();\n pair.add(head.data);\n pair.add(tail.data);\n ans.add(pair);\n tail=tail.prev;\n }else if(head.data+tail.data>target){\n tail=tail.prev;\n }else{\n head=head.next;\n }\n }\n return ans;\n }\n" }, { "path": "Find rectangle with corners as 1.java", "content": "public class Solution { \n static boolean ValidCorner(int mat[][]) { \n int n=mat.length;\n int m=mat[0].length;\n for(int i=0;i=2){\n return true;\n }\n }\n }\n return false;\n \n }\n}\n" }, { "path": "Find the Difference.java", "content": "class Solution {\n public char findTheDifference(String s, String t) {\n int diff = 0;\n int i = 0;\n for( i = 0; i < s.length(); i++) {\n diff = diff ^ s.charAt(i) ^ t.charAt(i);\n }\n diff = diff ^ t.charAt(i);\n return (char) diff;\n }\n}\n" }, { "path": "Find the Maximum Flow - GFG/README.md", "content": "# Find the Maximum Flow\n## Hard \n
\n

Given a graph with N vertices numbered 1 to N and M edges, The task is to find the max flow from vertex 1 to vertex N.

\n\n

In a flow network, the maximum flow of a path can't exceed the flow-capacity of an edge in the path.
\n
\nExample 1:

\n\n
Input:\nN = 5, M =  4\nEdges[]= { {1, 2, 1} , {3, 2, 2}, {4, 2, 3}, {2, 5, 5} }\nOutput:\n1 \nExplanation: \n1 - 2 - 3\n   / \\\n  4   5 \n1 unit can flow from 1 -> 2 - >5 \n
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 4 , M = 4\nEdges[] = { {1, 2, 8}, {1, 3, 10}, {4, 2, 2}, {3, 4, 3} }\nOutput:\n5 \nExplanation:\n  1 - 2 \n  |   |\n  3 - 4\n3 unit can flow from 1 -> 3 -> 4\n2 unit can flow from 1 -> 2 -> 4\nTotal max flow from 1 to N = 3+2=5
\n\n

Your Task: 
\nYou don't need to read input or print anything. Your task is to complete the function solve() which takes the N (the number of vertices) ,M (the number of Edges) and the array Edges[] (Where Edges[i] denoting an undirected edge between Edges[i][0] and Edges[i][1] with a flow capacity of Edges[i][2] ), and returns the integer denoting the maximum flow from 1 to N.

\n\n

Expected Time Complexity: O( max_flow* M)
\nExpected Auxiliary Space: O(N+M)

\n\n

Where max_flow is the maximum flow from 1 to N

\n\n

Constraints:
\n1 <= N,M,Edges[i][2] <= 1000
\n1 <= Edges[i][0],Edges[i][1] <= N

\n

\n
" }, { "path": "Find the Maximum Flow - GFG/find-the-maximum-flow.java", "content": "// { Driver Code Starts\n//Initial Template for Java\nimport java.io.*;\nimport java.util.*; \nclass GFG{\n public static void main(String args[]) throws IOException { \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n \n while(t-- > 0){\n \n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n int M = Integer.parseInt(input_line[1]);\n \n ArrayList> Edges = new ArrayList>();\n input_line = read.readLine().trim().split(\"\\\\s+\");\n for(int i=0;i e = new ArrayList();\n e.add(Integer.parseInt(input_line[3*i]));\n e.add(Integer.parseInt(input_line[3*i+1]));\n e.add(Integer.parseInt(input_line[3*i+2]));\n Edges.add(e);\n }\n Solution ob = new Solution();\n int ans = ob.solve(N, M, Edges); \n System.out.println(ans);\n }\n } \n} // } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution \n{ \n int bfs(int[][] g,int[] p,int source,int sink,int n){\n int mn=Integer.MAX_VALUE;\n Arrays.fill(p,-1);\n boolean[] vis=new boolean[n];\n Queue q=new LinkedList<>();\n q.add(source);\n vis[source]=true;\n p[source]=-1;\n while(!q.isEmpty()){\n int u = q.remove();\n for(int v=0;v> Edges) \n { \n // code here\n int g[][] = new int[N][N];\n for(int i=0;i leftSmaller(int n, int a[]){\n // code here\n \n vector ans(n);\n stack s;\n s.push(-1);\n \n \n for(int i=0;i=a[i]){\n s.pop();\n }\n ans[i] = s.top();\n \n }\n s.push(a[i]);\n \n \n }\n \n return ans;\n }\n};\n" }, { "path": "Find the number of islands.java", "content": "class axis{\n int x;\n int y;\n public axis(int x,int y){\n this.x=x;\n this.y=y;\n }\n @Override\n public boolean equals(Object o){\n if (o == this)\n return true;\n if (!(o instanceof axis))\n return false;\n axis a = (axis) o;\n return x==a.x && y==a.y;\n }\n}\nclass Solution {\n // Function to find the number of islands.\n public int numIslands(char[][] grid) {\n // Code here\n int count=0;\n for(int i=0;i stack=new ArrayDeque<>();\n stack.push(ax);\n while(!stack.isEmpty()){\n axis a=stack.pop();\n int i=a.x;\n int j=a.y;\n grid[i][j]='0';\n if((i-1)>=0){\n if(grid[i-1][j]=='1'){\n stack.push(new axis(i-1,j));\n }\n }\n if((i-1)>=0 && j+1=0){\n if(grid[i+1][j-1]=='1'){\n stack.push(new axis(i+1,j-1));\n }\n }\n if(j-1>=0){\n if(grid[i][j-1]=='1'){\n stack.push(new axis(i,j-1));\n }\n }\n if(j-1>=0 && i-1>=0){\n if(grid[i-1][j-1]=='1'){\n stack.push(new axis(i-1,j-1));\n }\n }\n }\n }\n}\n" }, { "path": "Find whether path exist - GFG/README.md", "content": "# Find whether path exist\n## Medium \n
\n

Given a grid of size n*n filled with 0, 1, 2, 3. Check whether there is a path possible from the source to destination. You can traverse up, down, right and left.
\nThe description of cells is as follows:

\n\n
    \n\t
  • A value of cell 1 means Source.
    • \n\t
  • A value of cell 2 means Destination.
    • \n\t
  • A value of cell 3 means Blank cell.
    • \n\t
  • A value of cell 0 means Wall.
    • \n
\n\n

Note: There are only a single source and a single destination.
\n 

\n\n

Example 1:

\n\n
Input: grid = {{3,0,3,0,0},{3,0,0,0,3}\n,{3,3,3,3,3},{0,2,3,0,0},{3,0,0,1,3}}\nOutput: 0\nExplanation: The grid is-\n3 0 3 0 0 \n3 0 0 0 3 \n3 3 3 3 3 \n0 2 3 0 0 \n3 0 0 1 3 \nThere is no path to reach at (3,1) i,e at \ndestination from (4,3) i,e source.\n
\n\n

Example 2:

\n\n
Input: grid = {{1,3},{3,2}}\nOutput: 1\nExplanation: The grid is-\n1 3\n3 2\nThere is a path from (0,0) i,e source to (1,1) \ni,e destination.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function is_Possible() which takes the grid as input parameter and returns boolean value true if there is a path otherwise returns false.
\n 

\n\n

Expected Time Complexity: O(n2)
\nExpected Auxiliary Space: O(n2)
\n 

\n\n

Constraints:
\n1 ≤ n ≤ 500

\n

\n
" }, { "path": "Find whether path exist - GFG/find-whether-path-exist.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n int[][] grid = new int[n][n];\n for(int i = 0; i < n; i++){\n String[] S = br.readLine().trim().split(\" \");\n for(int j = 0; j < n; j++){\n grid[i][j] = Integer.parseInt(S[j]);\n }\n }\n Solution obj = new Solution();\n boolean ans = obj.is_Possible(grid);\n if(ans)\n System.out.println(\"1\");\n else \n System.out.println(\"0\");\n }\n }\n}// } Driver Code Ends\n\n\n\n\nclass Solution\n{\n boolean res=false;\n //Function to find whether a path exists from the source to destination.\n public boolean is_Possible(int[][] grid){\n int n=grid.length;\n int m=grid[0].length;\n boolean vis[][]=new boolean[n][m];\n for(int i=0;i\n

Consider a special family of Engineers and Doctors with following rules :

\n\n
    \n\t
  1. Everybody has two children.
    2. \n\t
  2. First child of an Engineer is an Engineer and second child is a Doctor.
    3. \n\t
  3. First child of an Doctor is Doctor and second child is an Engineer.
    4. \n\t
  4. All generations of Doctors and Engineers start with Engineer.
    5. \n
\n\n

We can represent the situation using below diagram:

\n\n
                E\n           /        \\\n          E          D\n        /   \\       /  \\\n       E     D     D    E\n      / \\   / \\   / \\   / \\\n     E   D D   E  D  E  E  D\n
\n\n

Given level and position(pos) of a person in above ancestor tree, find profession of the person.

\n\n

Example 1:

\n\n
Input: level = 4, pos = 2\nOutput: Doctor\nExplaination: It is shown in the tree given \nin question.
\n\n

Example 2:

\n\n
Input: level = 3, pos = 4\nOutput: Engineer\nExplaination: Already given in the tree in \nquestion.
\n\n

Your Task:
\nYou do not need to read input or print anything. Your task is to complete the function profession() which takes level and pos as input parameters and returns 'd' if it is a doctor. Otherwise return 'e'. The driver code will output Doctor for 'd' and Engineer for 'e' itself.

\n\n

Expected Time Complexity: O(log(pos))
\nExpected Auxiliary Space: O(1)

\n\n

Constraints:
\n1 ≤ level ≤ 109
\n1 ≤ pos ≤ min(109, 2level-1)

\n

\n " }, { "path": "Finding Profession - GFG/finding-profession.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n int level = Integer.parseInt(a[0]);\n int pos = Integer.parseInt(a[1]);\n \n Solution ob = new Solution();\n if(ob.profession(level, pos) == 'd')\n System.out.println(\"Doctor\");\n else\n System.out.println(\"Engineer\");\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution{\n static int countSetBits(int n)\n {\n int count = 0;\n while (n != 0)\n {\n n &= (n-1) ;\n count++;\n }\n return count;\n }\n static char profession(int level, int pos){\n // Count set bits in 'pos-1'\n int c = countSetBits(pos-1);\n \n // If set bit count is odd, then doctor, else engineer\n return (c%2 == 1)? 'd' : 'e';\n }\n}" }, { "path": "Firing employees.java", "content": "class Solution {\n static int firingEmployees(int arr[], int n) { \n // code here\n int ans=0;\n int[]dp=new int[n];\n for(int i=0;i A) {\n A.removeIf(val -> val <=0);\n Collections.sort(A);\n for(int j = 0;j A) {\n Set set=new HashSet<>();\n int ans=-1;\n for(int i=A.size()-1;i>=0;i--){\n int num=A.get(i);\n if(set.contains(num)){\n ans=num;\n }else{\n set.add(num);\n }\n }\n return ans;\n }\n}\n" }, { "path": "Flip.java", "content": "public class Solution {\n public ArrayList flip(String A) {\n ArrayList al = new ArrayList<>();\n int max = 0;\n int diff = 0;\n int start = 0;\n boolean solFound = false;\n int[] ans = new int[2];\n for(int i = 0; i < A.length(); i++) {\n char c = A.charAt(i);\n diff += (c == '0') ? 1 : -1;\n if(diff < 0) {\n diff = 0;\n start = (c == '0') ? i : i + 1;\n } else {\n if(max < diff) {\n max = diff;\n if(al.isEmpty()){\n al.add(start);\n al.add(i);\n } else {\n al.set(0, start);\n al.set(1, i);\n }\n solFound = true;\n }\n }\n }\n\n if(!solFound) {\n return new ArrayList<>();\n }\n \n al.set(0, al.get(0)+1);\n al.set(1, al.get(1)+1);\n return al;\n \n }\n}\n" }, { "path": "Foldable Binary Tree.cpp", "content": "<<<<<<< HEAD\n// function that checks it tree with roots are mirror of each other\nbool isFoldableUtil(Node *n1, Node *n2){\n // if both left and right subtrees are null\n if(!n1 && !n2) return true;\n // if one tree is null and not other return false\n if(!n1 || !n2) return false;\n \n // check whether left and right subtrees are mirror \n return isFoldableUtil(n1->left, n2->right) && isFoldableUtil(n1->right, n2->left);\n}\n=======\n>>>>>>> upstream/main\n//Function to check whether a binary tree is foldable or not.\nbool IsFoldable(Node* root)\n{\n // Your code goes here\n<<<<<<< HEAD\n if(!root) return true;\n return isFoldableUtil(root->left, root->right); \n}\n\n// TC: O(n) -> where n is the number of nodes in binary tree\n=======\n if(!root)\n return true;\n \n return checkMirror(root->left, root->right);\n}\n\nbool checkMirror(Node* root1, Node* root2)\n{\n if(!root1 and !root2)\n return true;\n \n if(!root1 or !root2)\n return false;\n \n return checkMirror(root1->left, root2->right) and checkMirror(root1->right, root2->left);\n}\n\n////Another approach but takes more space than above solution\n\n/*\n bool IsFoldable(Node* root)\n {\n // Your code goes here\n queue Q;\n Q.push(root);\n\n while(!Q.empty())\n {\n int sz = Q.size();\n vector arr;\n\n while(sz--)\n {\n Node* cur = Q.front();\n Q.pop();\n\n if(cur)\n {\n arr.push_back(true);\n Q.push(cur->left);\n Q.push(cur->right);\n }\n else\n arr.push_back(false);\n }\n\n int n = arr.size();\n\n for(int i=0; i>>>>>> upstream/main\n" }, { "path": "Foldable Binary Tree.java", "content": "class Tree\n{\n //Function to check whether a binary tree is foldable or not.\n boolean IsFoldable(Node node) \n\t{ \n\t\t// your code\n\t\tif(node==null)return true;\n\t\treturn dfs(node.left,node.right);\n\t} \n\tboolean dfs(Node a,Node b){\n\t if(a==null && b==null)return true;\n\t if(a==null || b==null)return false;\n\t return dfs(a.left,b.right) && dfs(a.right,b.left);\n\t}\n}\n" }, { "path": "Form a palindrome - GFG/README.md", "content": "# Form a palindrome\n## Medium \n
\n

Given a string, find the minimum number of characters to be inserted to convert it to palindrome.
\nFor Example:
\nab: Number of insertions required is 1. bab or aba
\naa: Number of insertions required is 0. aa
\nabcd: Number of insertions required is 3. dcbabcd

\n\n

Example 1:

\n\n
Input:\nabcd\nOutput:\n3\nExplanation:\nHere we can append 3 characters in the \nbeginning,and the resultant string will \nbe a palindrome (\"dcbabcd\").
\n\n

Example 2:

\n\n
Input:\naba\nOutput:\n0\nExplanation:\nGiven string is already a pallindrome hence\nno insertions are required.
\n\n

Your Task:  
\nYou don't need to read input or print anything. Your task is to complete the function findMinInsertions() which takes string S as input parameters and returns minimimum numser of insertions required.

\n\n

Expected Time Complexity: O(|S|2)
\nExpected Auxiliary Space: O(|S|2)

\n\n

Constraints:
\n1 ≤ |S| ≤ 500

\n

\n
" }, { "path": "Form a palindrome - GFG/form-a-palindrome.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n \n String S = read.readLine().trim();\n Solution ob = new Solution();\n System.out.println(ob.findMinInsertions(S));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n private static Integer[][] dp;\n private static int find(int l, int r, String s){\n if(l > r){\n return 0;\n }\n if(dp[l][r] != null){\n return dp[l][r];\n }\n \n if(s.charAt(l) == s.charAt(r)){\n return dp[l][r] = find(l+1, r-1, s);\n }else{\n return dp[l][r] = 1 + Math.min(find(l+1, r, s), find(l, r-1, s));\n }\n }\n \n int findMinInsertions(String S){\n dp = new Integer[S.length()][S.length()]; \n return find(0, S.length()-1, S); \n }\n}" }, { "path": "Form coils in a matrix - GFG/README.md", "content": "# Form coils in a matrix\n## Medium \n
\n

Given a positive integer n that represents dimensions of a 4n x 4n matrix with values from 1 to 4*n*4*n filled from left to right and top to bottom. Your task is to form two coils from matrix and print the coils.

\n\n

Follow the given examples for better understanding.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nn = 1\nOutput:\n10 6 2 3 4 8 12 16\n7 11 15 14 13 9 5 1 \nExplanation:\nThe matrix is \n1  2  3  4\n5  6  7  8\n9  10 11 12\n13 14 15 16\nSo, the two coils are as given in the Ouput.
\n\n

Example 2:

\n\n
Input:\nn = 2\nOutput:\n36 28 20 21 22 30 38 46\n54 53 52 51 50 42 34 26\n18 10 2 3 4 5 6 7 8\n16 24 32 40 48 56 64\n\n29 37 45 44 43 35 27 19\n11 12 13 14 15 23 31 39\n47 55 63 62 61 60 59 58\n57 49 41 33 25 17 9 1  \nExplanation:\n\"\"\n\n
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function formCoils() which takes an Integer n as input and returns a vector of two vectors representing coil1 and coil2.

\n\n

 

\n\n

Expected Time Complexity: O(n2)
\nExpected Auxiliary Space: O(n2)

\n\n

 

\n\n

Constraints:
\n1 <= n <= 20

\n

\n
" }, { "path": "Form coils in a matrix - GFG/form-coils-in-a-matrix.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int n = Integer.parseInt(read.readLine());\n\n Solution ob = new Solution();\n int[][] ptr = ob.formCoils(n);\n \n for(int i=0; i<2; i++)\n {\n for(int j=0; j= left){\n if(dir == 0){\n for(int i = down ; i >= top ; i --){\n ans[idx] = arr[i][right];\n idx++;\n }\n right--;\n down--;\n }\n else if(dir == 1){\n for(int i = right ; i >= left ; i --){\n ans[idx] = arr[top][i];\n idx++;\n }\n right--;\n top++;\n }\n else if(dir == 2){\n for(int i = top ; i <= down ; i ++){\n ans[idx] = arr[i][left];\n idx++;\n }\n top++;\n left++;\n }\n else if(dir == 3){\n for(int i = left ; i <= right ; i ++){\n ans[idx] = arr[down][i];\n idx++;\n }\n down--;\n left++;\n }\n dir = (dir+1)%4;\n }\n int [][]res = new int[2][8*n*n];\n int x = ans.length-1;\n \n for(int j = 0 ; j < res[0].length ; j ++) {\n res[0][j] = ans[x];\n x--;\n }\n\n top = 0; down = 4*n-1; left = 0; right = 4*n-2; dir = 0; idx = 0;\n while (top <= down && right >= left){\n if(dir == 0){\n for(int i = top ; i <= down ; i ++){\n ans[idx] = arr[i][left];\n idx++;\n }\n top++;\n left++;\n }\n else if(dir == 1){\n for(int i = left ; i <= right ; i ++){\n ans[idx] = arr[down][i];\n idx++;\n }\n down--;\n left++;\n }\n else if(dir == 2){\n for(int i = down ; i >= top ; i --){\n ans[idx] = arr[i][right];\n idx++;\n }\n right--;\n down--;\n }\n else if(dir == 3){\n for(int i = right ; i >= left ; i --){\n ans[idx] = arr[top][i];\n idx++;\n }\n right--;\n top++;\n }\n dir = (dir+1)%4;\n }\n x = ans.length-1;\n for(int j = 0 ; j < res[0].length ; j ++) {\n res[1][j] = ans[x];\n x--;\n }\n return res;\n }\n }" }, { "path": "Fraction Trouble - GFG/README.md", "content": "# Fraction Trouble\n## Easy \n
\n

Consider the set of irreducible fractions A = {n/d | n≤d and d ≤ 10000 and gcd(n,d) = 1}.You are given a member of this set and your task is to find the largest fraction in this set less than the given fraction.
\nNote : this is a set and all the members are unique.
\n
\nExample 1:

\n\n
Input: n = 1, d = 4\nOutput: {2499, 9997}  \nExplanation: 2499/9997 is the largest fraction.\n
\n\n


\nExample 2:

\n\n
Input: n = 2, d = 4\nOutput: {4999, 9999}\nExplanation: 4999/9999 is the largest fraction. \n
\n\n


\nYour Task:  
\nYou dont need to read input or print anything. Complete the function numAndDen() which takes n and d as input parameter and returns the numerator and the denominator of the required irreducible fraction.
\n
\nExpected Time Complexity: O(n)
\nExpected Auxiliary Space: O(1)
\n
\nConstraints:
\n1 <= n <= d <=1000

\n

\n
" }, { "path": "Fraction Trouble - GFG/fraction-trouble.java", "content": "// { Driver Code Starts\n//Initial Template for Java\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String[] input = new String[2]; \n input = br.readLine().split(\" \"); \n int n = Integer.parseInt(input[0]); \n int d = Integer.parseInt(input[1]); \n Solution ob = new Solution();\n int[] ans = ob.numAndDen(n,d);\n for(int i = 0; i < ans.length; i++)\n {\n System.out.print(ans[i] + \" \");\n }\n System.out.println();\n }\n }\n}\n// } Driver Code Ends\n\n\nclass Solution\n{\n public int[] numAndDen(int n, int d)\n {\n int num = 0;\n int den = 1;\n for (int q = 10000; q >= 2; q--){\n int p = (n * q - 1) / d;\n if (p * den >= num * q){\n den = q;\n num = p;\n }\n }\n int tot = gcdnumber(num,den);\n int [] ans = new int[2];\n ans[0] = num/tot;\n ans[1] = den/tot;\n return ans;\n }\n \n static int gcdnumber(int a, int b)\n {\n if (b == 0)\n return a;\n return gcdnumber(b, a % b);\n }\n}" }, { "path": "Fraction.java", "content": "public class Solution {\n\tpublic String fractionToDecimal(int numerator, int denominator) {\n long a=numerator,b=denominator;\n if(a%b==0) return String.valueOf(a/b);\n Map map=new HashMap<>();\n StringBuilder res=new StringBuilder();\n if((a>0&&b<0)||(a<0&&b>0)) res.append(\"-\");\n a=Math.abs(a);\n b=Math.abs(b);\n res.append(a/b+\".\");\n a=(a%b)*10;\n while(!map.containsKey(a)){\n map.put(a,res.length());\n res.append(String.valueOf(a/b));\n a=(a%b)*10;\n if(a==0) return res.toString();\n }\n return res.insert(map.get(a),\"(\").append(\")\").toString();\n\t}\n}\n\n" }, { "path": "Friends Pairing Problem DP.java", "content": " class Solution\n{\n public long countFriendsPairings(int n) \n {\n long mod = 1000000007;\n long[] dp = new long[n+1];\n return helper(n,dp,mod);\n }\n long helper(int n,long[] dp,long mod){\n if(n<=2) return n;\n if(dp[n]!=0) return dp[n];\n return dp[n] = (helper(n-1,dp,mod) + ((n-1)*helper(n-2,dp,mod)))%mod;\n }\n \n} \n" }, { "path": "Friends Pairing Problem.cpp", "content": "class Solution\n{\npublic:\n\n //defining mod\n long long MOD = 1000000007;\n \n int countFriendsPairings(int n) \n { \n //numbers less than 3 will have the same answer\n if(n < 3) return n;\n \n //defining and storing base conditions\n long long prev1 = 1;\n long long prev2 = 2;\n \n //using tabulation based on the pattern observed\n for(long long i = 3; i <= n; i++)\n {\n long long temp = prev2 % MOD;\n \n prev2 = (((((i-1) % MOD)*(prev1 % MOD))%MOD) + (prev2 % MOD))%MOD;\n prev1 = temp;\n }\n \n return prev2;\n }\n};\n" }, { "path": "Friends Pairing Problem.java", "content": "class Solution\n{\n public long countFriendsPairings(int n) \n { \n //code here\n if(n<=2)return n;\n long mod=(int)Math.pow(10,9)+7;\n long secPrev=1;\n long prev=2;\n long curr=0;\n for(int i=3;i<=n;i++){\n curr=(prev+(((i-1)%mod)*(secPrev%mod))%mod)%mod;\n secPrev=prev;\n prev=curr;\n }\n return curr;\n }\n} \n" }, { "path": "GFG/0 -1 Knapsack Problem/0 - 1 Knapsack Problem.java", "content": "class Solution \n{ \n //Function to return max value that can be put in knapsack of capacity W.\n \n \n // below function is recursion+dp version of the problem, problem can be solved using only this function also\n static int myfunc(int w, int wt[], int val[], int n, int[][] ans){\n if(w==0 || n==0) return 0;\n if(ans[w][n]!=-1) return ans[w][n];\n if(wt[n-1]>w){\n return ans[w][n]=myfunc(w,wt,val,n-1,ans);\n }\n \n return ans[w][n] = Math.max(val[n-1] + myfunc(w-wt[n-1],wt,val,n-1,ans), myfunc(w,wt,val,n-1,ans));\n }\n static int knapSack(int W, int wt[], int val[], int n) \n { \n // your code here\n int[][] ans = new int[W+1][n+1];\n \n // below is the memoization version (iterative approach) of the problem \n for(int i=1;ii){\n ans[i][j] = ans[i][j-1];\n }else{\n ans[i][j] = Math.max(val[j-1]+ans[i-wt[j-1]][j-1],ans[i][j-1]);\n }\n }\n }\n \n // return myfunc(W, wt, val, n, ans); // call for using recursion + dp approach\n return ans[W][n];\n } \n}\n" }, { "path": "GFG/2D Hopscotch/2D Hopscotch.java", "content": "class Solution{\n static int hopscotch(int n, int m, int mat[][], int ty, int i, int j) \n {\n // code here\n int ans=0;\n if(ty==0) {\n if(isValid(i+1,j,n,m)) ans+=mat[i+1][j]; //down\n if(isValid(i-1,j,n,m)) ans+=mat[i-1][j]; //up\n if(isValid(i,j+1,n,m)) ans+=mat[i][j+1]; //right\n if(isValid(i,j-1,n,m)) ans+=mat[i][j-1]; //left\n if(j%2==0) {\n if(isValid(i-1,j+1,n,m)) ans+=mat[i-1][j+1]; // right-up\n if(isValid(i-1,j-1,n,m)) ans+=mat[i-1][j-1]; // left-up\n } else {\n if(isValid(i+1,j+1,n,m)) ans+=mat[i+1][j+1]; // right-down\n if(isValid(i+1,j-1,n,m)) ans+=mat[i+1][j-1]; // left-down\n }\n } else {\n if(isValid(i+2,j,n,m)) ans+=mat[i+2][j]; // down\n if(isValid(i-2,j,n,m)) ans+=mat[i-2][j]; // up\n if(isValid(i,j+2,n,m)) ans+=mat[i][j+2]; // front\n if(isValid(i,j-2,n,m)) ans+=mat[i][j-2]; // back\n if(j%2==0) {\n if(isValid(i+1,j+1,n,m)) ans+=mat[i+1][j+1]; // right-down\n if(isValid(i-2,j+1,n,m)) ans+=mat[i-2][j+1]; // right-up\n if(isValid(i+1,j-1,n,m)) ans+=mat[i+1][j-1]; // left-down\n if(isValid(i-2,j-1,n,m)) ans+=mat[i-2][j-1]; // left-up\n \n if(isValid(i+1,j+2,n,m)) ans+=mat[i+1][j+2]; // right-down-right-down\n if(isValid(i+1,j-2,n,m)) ans+=mat[i+1][j-2]; // left-down-left-down\n if(isValid(i-1,j+2,n,m)) ans+=mat[i-1][j+2]; // right-up-right-up\n if(isValid(i-1,j-2,n,m)) ans+=mat[i-1][j-2]; // left-up-left-up\n } else {\n if(isValid(i-1,j+1,n,m)) ans+=mat[i-1][j+1]; // right-up\n if(isValid(i+2,j+1,n,m)) ans+=mat[i+2][j+1]; // right-down\n if(isValid(i-1,j-1,n,m)) ans+=mat[i-1][j-1]; // left-up\n if(isValid(i+2,j-1,n,m)) ans+=mat[i+2][j-1]; // left-down\n \n if(isValid(i-1,j+2,n,m)) ans+=mat[i-1][j+2]; // right-up-right-up\n if(isValid(i-1,j-2,n,m)) ans+=mat[i-1][j-2]; // left-up-left-up\n if(isValid(i+1,j+2,n,m)) ans+=mat[i+1][j+2]; // right-down-right-down\n if(isValid(i+1,j-2,n,m)) ans+=mat[i+1][j-2]; // left-down-left-down\n }\n }\n return ans;\n }\n static boolean isValid(int i,int j,int n,int m){\n return i>=0 && j>=0 && i threeDivisors(ArrayList query, int qn){\n // code here\n int n=0;\n for(Long q:query){\n n=Math.max(n,(int)Math.sqrt(q));\n }\n boolean[] prime=new boolean[n+1];\n Arrays.fill(prime,true);\n for(int i=2;i<=n;i++){\n if(prime[i]){\n for(int j=i+i;j<=n;j+=i){\n prime[j]=false;\n }\n }\n }\n \n int[]dp=new int[n+1];\n for(int i=2;i<=n;i++){\n dp[i]=dp[i-1];\n if(prime[i]){\n dp[i]++;\n }\n }\n ArrayList ans=new ArrayList<>();\n for(Long q:query){\n int root=(int)Math.sqrt(q);\n ans.add(dp[root]);\n }\n return ans;\n }\n}\n" }, { "path": "GFG/A Game of LCM/A Game of LCM.java", "content": "\nclass Solution {\n long maxGcd(int N) {\n // code here\n return Math.max(solve(N),solve(N-1));\n }\n long solve(int n){\n long ans=n;\n int added=0;\n for(int i=n-1;i>=1;i--){\n if(gcd(ans,i)==1L){\n ans*=i;\n added++;\n }\n if(added==3)return ans;\n }\n return ans;\n }\n long gcd(long a,long b){\n if(a==0)return b;\n return gcd(b%a,a);\n }\n \n}\n" }, { "path": "GFG/A difference of values and indexes/A difference of values and indexes.java", "content": "class Solution{\n \n \n // Function for finding maximum and value pair\n public static int maxDistance (int arr[], int n) {\n //Complete the function\n int max=Integer.MIN_VALUE;\n int min=Integer.MAX_VALUE;\n int max2=Integer.MIN_VALUE;\n int min2=Integer.MAX_VALUE;\n \n for(int i=0;i=0 || j>=0){\n int a= i>=0?A.charAt(i)-'0':0;\n int b= j>=0?B.charAt(j)-'0':0;\n int total=a+b+carry;\n if(total==0){\n carry=0;\n sb.append('0');\n }else if(total==1){\n carry=0;\n sb.append('1');\n }else if(total==2){\n carry=1;\n sb.append('0');\n }else{\n carry=1;\n sb.append('1');\n }\n i--;\n j--;\n }\n \n if(carry==1)sb.append('1');\n \n while(sb.charAt(sb.length()-1)=='0')sb.setLength(sb.length()-1);\n \n return sb.reverse().toString();\n }\n}\n" }, { "path": "GFG/Aggressive Cows/Aggressive Cows.java", "content": "class Solution {\n public static int solve(int n, int k, int[] stalls) {\n Arrays.sort(stalls);\n int l=1;\n int h=stalls[n-1]-stalls[0];\n while(l<=h){//log (10^9)== 9*log(10) = 30\n int mid=(l+h)/2;\n if(isPossible(k,stalls,mid)){\n l=mid+1;\n }else{\n h=mid-1;\n }\n }\n return h;// (n)\n }\n static boolean isPossible(int k,int[]arr,int minDis){\n int cnt=1;\n int prevCow=arr[0];\n for(int i=1;i=minDis){\n prevCow=arr[i];\n cnt++;\n }\n }\n return cnt>=k;\n }\n}\n" }, { "path": "GFG/Akku and Binary Numbers/Akku and Binary Numbers.java", "content": "class Solution{\n \n void precompute(){\n // Code Here\n }\n long solve(long L, long R){\n // Code here\n long ans=0;\n \n for(int i=0;i<63;i++){\n for(int j=i+1;j<63;j++){\n for(int k=j+1;k<63;k++){\n long curr=0;\n curr|=(1L<=L && curr<=R){\n ans++;\n }\n }\n }\n }\n return ans;\n }\n \n}\n" }, { "path": "GFG/Alex Travelling/Alex Travelling.cpp", "content": "class Solution {\n \n public:\n int minimumCost(vector>& flights, int n, int k) {\n // code here\n \n unordered_map> > adj;\n for(int i = 0; i < flights.size(); i++)\n {\n int u = flights[i][0];\n int v = flights[i][1];\n int w = flights[i][2];\n \n adj[u].push_back({v,w});\n \n }\n \n vector dist(n+1, INT_MAX);\n \n set> s; //distNode, node\n \n dist[k] = 0;\n s.insert({0, k});\n \n while(!s.empty())\n {\n auto top = *(s.begin());\n s.erase(s.begin());\n \n int distNode = top.first;\n int node = top.second;\n \n for(auto neigh : adj[node])\n {\n if(distNode + neigh.second < dist[neigh.first])\n {\n dist[neigh.first] = distNode + neigh.second;\n \n s.insert({dist[neigh.first], neigh.first});\n }\n }\n }\n \n int ans = 0;\n \n for(int i = 1; i <= n; i++)\n {\n if(dist[i] == INT_MAX) return -1;\n \n ans = max(ans, dist[i]);\n \n // cout<> map=new HashMap<>();\n for(int[]i:flights){\n int u=i[0];\n int v=i[1];\n int w=i[2];\n map.putIfAbsent(u,new ArrayList<>());\n map.get(u).add(new Pair(v,w));\n } \n \n int[]dis=new int[n+1];\n int ans=0;\n Queue q=new LinkedList<>();\n q.add(new Pair(k,dis[k]));\n \n while(!q.isEmpty()){\n Pair curr=q.remove();\n int node=curr.node;\n int cost=curr.weight;\n if(!map.containsKey(node))continue;\n for(Pair p:map.get(node)){\n int neb=p.node;\n int nebCost=p.weight;\n if((dis[neb]==0 || dis[neb]>cost+nebCost) && neb!=k){\n dis[neb]=cost+nebCost;\n q.add(new Pair(neb,dis[neb]));\n }\n }\n }\n \n for(int i=1;i1)return \"-1\";\n \n boolean isVowel=false;\n \n if(noOfVowels>noOfCons){\n isVowel=true;\n }else if(noOfCons>noOfVowels){\n isVowel=false;\n }else{\n if(smallestVowel S.charAt(i)) {\n firstVowel = S.charAt(i);\n }\n }\n else {\n if(firstConsonant > S.charAt(i)) {\n firstConsonant = S.charAt(i);\n }\n }\n }\n \n int j=firstConsonant -'a';\n int i=firstVowel -'a';\n \n StringBuilder sb = new StringBuilder();\n \n if(S.length()%2==0) {\n if(vowels!=consonants) return \"-1\";\n if(firstVowel < firstConsonant) {\n sb.append(firstVowel);\n f[firstVowel - 'a']-=1;\n }\n return getRes(f, i, j, sb);\n }\n else {\n \n if(Math.abs(vowels-consonants) > 1) {\n return \"-1\";\n }\n \n if(vowels-consonants==1) {\n sb.append(firstVowel);\n f[firstVowel - 'a']-=1;\n }\n \n return getRes(f, i, j, sb);\n }\n }\n \n public String getRes(int []f, int i, int j, StringBuilder sb) {\n while(j<26) {\n if(f[j]==0) {\n j+=1;\n continue;\n }\n else {\n if(j==0 || j==4 || j==8 || j==14 || j==20) {\n j+=1;\n continue;\n }\n else {\n sb.append((char)('a'+j));\n f[j]-=1;\n }\n }\n \n \n \n if(f[i]==0) {\n i=getNextVowel(f);\n }\n if(i!=-1) {\n sb.append((char)('a'+i));\n f[i]-=1;\n }\n else {\n break;\n }\n \n }\n return sb.toString();\n }\n \n public int getNextVowel(int f[]) {\n if(f[0]!=0) return 0;\n if(f[4]!=0) return 4;\n if(f[8]!=0) return 8;\n if(f[14]!=0) return 14;\n if(f[20]!=0) return 20;\n return -1;\n }\n public int countVowels(String s, boolean isVowel) {\n int count = 0;\n for(int i=0;i& arr, int k){\n sort(arr.begin(), arr.end());\n \n int l = 0, r = 0, len = 0;\n \n while(r articulationPoints(int V,ArrayList> adj)\n {\n // Code here\n time=0;\n ArrayList ans=new ArrayList<>();\n boolean[]ap=new boolean[V];\n int[]parent=new int[V];\n boolean[]vis=new boolean[V];\n int[]minDis=new int[V];\n int[]dis=new int[V];\n Arrays.fill(parent,-1);\n for(int i=0;i> adj,int[]parent,boolean[]vis,\n int[]minDis,int[]dis){\n vis[u]=true;\n int children=0;\n dis[u]=minDis[u]=time;\n time++;\n for(int v:adj.get(u)){\n if(!vis[v]){\n children++;\n parent[v]=u;\n dfs(v,ap,adj,parent,vis,minDis,dis);\n minDis[u]=Math.min(minDis[u],minDis[v]);\n if(parent[u]==-1 && children>1){\n ap[u]=true;\n }else if(parent[u]!=-1 && minDis[v]>=dis[u]){\n ap[u]=true;\n }\n }else{\n minDis[u]=Math.min(minDis[u],dis[v]);\n }\n }\n }\n}\n" }, { "path": "GFG/Asteroid Collision/Asteroid Collision.cpp", "content": "class Solution {\n public:\n vector asteroidCollision(int N, vector &asteroids) {\n stack s;\n int i = 0;\n while(i < N){\n if(s.empty()){\n s.push(asteroids[i]);\n ++i;\n }\n else{\n if((asteroids[i] > 0 && s.top() > 0) || \n (asteroids[i] < 0 && s.top() < 0) ||\n (asteroids[i] > 0 && s.top() < 0)){\n s.push(asteroids[i]);\n ++i;\n }\n else if(asteroids[i] < 0 && s.top() > 0){\n int a = s.top();\n s.pop();\n \n if(a == abs(asteroids[i]))\n ++i;\n else if(a > abs(asteroids[i])){\n s.push(a);\n ++i;\n }\n else if(a < abs(asteroids[i])){\n continue;\n }\n }\n }\n }\n vector ans;\n while(!s.empty()){\n int a = s.top();\n s.pop();\n ans.push_back(a);\n }\n \n reverse(ans.begin(), ans.end());\n \n return ans;\n }\n};\n" }, { "path": "GFG/Asteroid Collision/Asteroid Collision.java", "content": "\nclass Solution {\n public static int[] asteroidCollision(int N, int[] arr) {\n // code here\n Stack st=new Stack<>();\n for(int num:arr){\n if(num<0){\n while(!st.isEmpty() && st.peek()>0 && st.peek()0)ans[i--]=st.pop();\n return ans;\n }\n}\n" }, { "path": "GFG/Balanced string/Balanced string.java", "content": "class Solution {\n static String BalancedString(int N) {\n // code here\n StringBuilder ans=new StringBuilder();\n String full=\"abcdefghijklmnopqrstuvwxyz\";\n int n=N;\n while(N>26){\n ans.append(full);\n N-=26;\n }\n \n if(N%2==0){//even\n for(int i=0;i0){\n sum+=(n%10);\n n/=10;\n }\n if(sum%2==0){//even\n for(int i=0;i<(N+1)/2;i++)ans.append((char)('a'+i));\n for(int i=26-N/2;i<26;i++)ans.append((char)('a'+i));\n }else{//odd\n for(int i=0;im) start=mid+1;\n else return \"Yes\";\n }\n return \"No\";\n }\n public int calculateDigits(int n, int m) {\n int dig=0;\n while(n>0) {\n dig+=1;\n n=n/m;\n }\n return dig;\n }\n}\n" }, { "path": "GFG/Base Equivalence/Base Equivalence.java", "content": "//User function Template for Java\nclass Solution\n{\n String baseEquiv(int n, int m)\n {\n // code here\n int i=2;\n while(i<=32){\n int digit=(int)(Math.log(n)/Math.log(i))+1;\n if(digit==m)return \"Yes\";\n i++;\n }\n return \"No\";\n }\n}\n" }, { "path": "GFG/Binary Tree to DLL/Binary Tree to DLL.cpp", "content": "/* This code is contributed by -\n Aman Bhatt (https://github.com/bhattaman0001)\n Anish Mandal (https://github.com/AnishMandal939)\n*/\n\n// there are 2 approaches another one is below\n\nNode * bToDLL(Node *root)\n {\n // your code here\n // TC: O(1) using morris inorder traversal\n\n Node* curr = root, *head = NULL;\n\n while(curr != NULL){\n if(curr->left != NULL){\n Node* traversal = curr->left;\n while(traversal->right != NULL && traversal->right != curr)\n traversal = traversal->right;\n\n if(traversal->right == NULL){\n traversal->right = curr;\n\n Node *tmp = curr->left;\n curr->left = traversal;\n curr=tmp;\n continue;\n }\n } \n if(head == NULL) head = curr;\n //cout<right->data<right;\n if(traversal != NULL && traversal->left != curr){\n while(traversal->left != NULL)\n traversal = traversal->left;\n\n Node* tmp = curr->right;\n traversal->left = curr;\n curr->right = traversal;\n curr = tmp;\n }\n else curr = curr->right;\n\n\n }\n return head;\n }\n\n\n\n\n// 2. another approach\n// it is not complex just added comments that's why it is looking big\nstruct Node\n{\n int data;\n struct Node* left;\n struct Node* right;\n\n Node(int x){\n data = x;\n left = right = NULL;\n }\n};\n\n// This function should return head to the DLL\nclass Solution\n{\n public: \n Node *p = NULL, *h = NULL;\n void inorder(Node* root){\n if(!root) return;\n inorder(root->left);\n root->left = p;\n p = root;\n inorder(root->right);\n }\n //Function to convert binary tree to doubly linked list and return it.\n Node * bToDLL(Node *root)\n {\n // your code here\n inorder(root); // making one traversal from left to right of doubly linkedList\n\n // making another traversal from right to left of DLL\n // if you are heading from right to left then for DLL your next is right and prev is left\n // if you are heading from left to right then for DLL your next is left and prev is right\n Node* t = p, *p1 = NULL;\n t->right = p1;\n while(t->left != NULL){\n p1 = t;\n t = t->left;\n t->right = p1;\n }\n h = t;\n return h;\n }\n};\n" }, { "path": "GFG/Binary Tree to DLL/Binary Tree to DLL.java", "content": "class Solution\n{\n //Function to convert binary tree to doubly linked list and return it.\n Node bToDLL(Node root)\n {\n\t// Your code here\t\n\t Node[] arr=dfs(root);\n\t return arr[0];\n }\n Node[] dfs(Node root){\n if(root.left==null && root.right==null){\n return new Node[]{root,root};\n }\n \n if(root.left==null){\n Node[] righty=dfs(root.right);\n root.right=righty[0];// 10 -> 36\n righty[0].left=root;// 10 <- 36\n return new Node[]{root,righty[1]};//10,15\n }\n \n Node[] lefty=dfs(root.left);\n lefty[1].right=root;//30 -> 10\n root.left=lefty[1];// 30 <-10\n \n if(root.right==null){\n return new Node[]{lefty[0],root};//25,10\n }\n Node[] righty=dfs(root.right);\n root.right=righty[0];// 10 -> 36\n righty[0].left=root;// 10 <- 36\n \n return new Node[]{lefty[0],righty[1]};//25,15\n }\n}\n\n\n\nApproach 2: \n\nSolution Explain:\n\n 1. make an arraylist\n 2. put all the elements of the tree in inorder fashion\n 3. now traverse that arraylist and construct left as prev and right as arraylist next element\n 4. Time complexity= o(N)(inorder and traversal of arraylist) and space = O(N) bez of arraylist\n\n\n class Solution\n{\n Node bToDLL(Node root)\n {\n if(root==null || root.left==null && root.right==null){\n return root;\n }\n\n\n\t //make ArrayList\n\t ArrayList al=new ArrayList<>();\n\n\t //put all the element's in inorder to al\n\t inorder(root,al);\n\n\t Node dummy=al.get(0);\n\n\n\t //take two nodes prev and curr for doubly linked list\n\t Node prev=null;\n\t Node curr=null;\n\n\t //counter for traversing arraylist\n\t int i=0;\n\n\n\t //create doubly linked list\n\t while(i al){\n\n if(root==null)\n return;\n\n inorder(root.left,al);\n al.add(root);\n inorder(root.right,al);\n }\n}\n\nContributed by @Jay-Thesia\n" }, { "path": "GFG/Black and White/Black and White.java", "content": "class BlackAndWhite\n{\n //Function to find out the number of ways we can place a black and a \n //white Knight on this chessboard such that they cannot attack each other.\n static long numOfWays(int N, int M)\n {\n // add your code here\n long ans=0L;\n long mod=1000000007;\n int[][]dirs=new int[][]{{1,2},{-1,2},{1,-2},{-1,-2},{2,1},{-2,1},{2,-1},{-2,-1}};\n for(int i=0;i=0 && j>=0 && i st=new Stack<>();\n for(char c:str.toCharArray()){\n while(!st.isEmpty() && st.peek()>c && k>0){\n st.pop();\n k--;\n }\n st.push(c);\n }\n \n while(!st.isEmpty() && k>0){\n st.pop();\n k--;\n }\n \n StringBuilder sb=new StringBuilder();\n while(!st.isEmpty()){\n sb.append(st.pop());\n }\n \n while(sb.length()>0 && sb.charAt(sb.length()-1)=='0'){\n sb.setLength(sb.length()-1);\n }\n if(sb.length()==0)return \"0\";\n return sb.reverse().toString();\n }\n}\n" }, { "path": "GFG/Burst Balloons/Burst Balloons.java", "content": "class Solution {\n static Integer[][]dp;\n public static int maxCoins(int N, int[] arr) {\n // code here\n dp=new Integer[N+3][N+3];\n int[]newArr=new int[N+2];\n newArr[0]=1;\n newArr[N+1]=1;\n for(int i=0;i=maxValue) return false;\n return isBST(root.left,minValue,root.data)&&isBST(root.right,root.data,maxValue);\n }\n boolean isBST(Node root)\n {\n // code here.\n return isBST(root,Integer.MIN_VALUE,Integer.MAX_VALUE);\n }\n}\n" }, { "path": "GFG/Check if all levels of two trees are anagrams or not/Check if all levels of two trees are anagrams or not.java", "content": "class Solution {\n public static boolean areAnagrams(Node node1, Node node2) {\n // code here\n Queue q1=new LinkedList<>();\n Queue q2=new LinkedList<>();\n q1.add(node1);\n q2.add(node2);\n while(!q1.isEmpty() && !q1.isEmpty()){\n int sz1=q1.size();\n int sz2=q2.size();\n if(sz1!=sz2)return false;\n Map map=new HashMap<>();\n for(int i=0;ii)return 0;\n else{\n i++;\n j++;\n }\n }else{\n return 0;\n }\n }else{\n if(T.charAt(j)=='B'){\n if(j6){\n total-=dp[i-6];\n }\n dp[i]=total*2;\n total+=(total*2);\n }\n return total;\n }\n}\n" }, { "path": "GFG/Complement/Complement.java", "content": "\n//GFG dsa self-paced Coupon code: SAGARGFGPOTD\n\nclass Solve {\n\n Vector findRange(String str, int n) {\n // code here\n int count=0;\n int l=-1;\n int max=0;\n int ansL=-1;\n int ansR=-1;\n for(int i=0;imax){\n max=count;\n ansL=l;\n ansR=i;\n }\n }\n Vector ans=new Vector<>();\n if(ansL==-1){\n ans.add(-1);\n }else{\n ans.add(ansL+1);\n ans.add(ansR+1);\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Construct Binary Tree from String with bracket representation/Construct Binary Tree from String with bracket representation.cpp", "content": "class Solution{\n \n int ind = 0;\n Node* solve(string str)\n {\n if(str.length() == 0 || ind >= str.length())\n return NULL;\n \n //calculate num\n int num = 0;\n while(ind < str.length() && str[ind] != '(' && str[ind] != ')')\n {\n int val = (int)(str[ind]-'0');\n num = num*10 + val;\n ind++;\n }\n \n //create new root\n Node* root = NULL;\n if(num > 0)\n root = new Node(num);\n \n //for left child\n if(ind < str.length() && str[ind] == '(')\n {\n ind++;\n root->left = solve(str);\n }\n \n if(ind < str.length() && str[ind] == ')')\n {\n ind++;\n return root;\n }\n \n //for right child\n if(ind < str.length() && str[ind] == '(')\n {\n ind++;\n root->right = solve(str);\n }\n \n if(ind < str.length() && str[ind] == ')')\n {\n ind++;\n \n }\n return root; \n \n }\n \npublic:\n // function to construct tree from string\n Node *treeFromString(string str){\n \n if(str.length() == 0) return NULL;\n \n return solve(str);\n \n }\n};\n" }, { "path": "GFG/Construct Binary Tree from String with bracket representation/Construct Binary Tree from String with bracket representation.java", "content": "class Solution {\n public static Node treeFromString(String s) {\n // code here\n int[] idx=new int[]{0};\n return dfs(idx,s);\n }\n static Node dfs(int[] idx,String s){\n if(idx[0]>=s.length() || s.charAt(idx[0])==')'){\n idx[0]++;\n return null;\n }\n \n int num=0;\n while(idx[0]>j))>0){\n dp[i][bitmask]+=dp[j][bitmask ^ (1<\nusing namespace std;\nclass Solution {\n public:\n int mod = 1e9+7;\n long long int mem(int i, int j, int m, int n, vector> &dp){\n if(i== m-1 and j == n-1) return 1;\n if(i >=m or j >=n) return 0;\n if(dp[i][j]!=-1) return dp[i][j];\n return dp[i][j] = (mem(i+1,j,m,n, dp)+ mem(i,j+1,m,n,dp))%mod;\n \n };\n long long int numberOfPaths(int m, int n){\n // code here\n vector> dp(m, vector(n,-1));\n return mem(0,0,m,n,dp)%mod;\n\n }\n};\nint main() {\n int t;\n cin >> t;\n while (t--) {\n int n, m;\n cin >> m >> n;\n Solution ob;\n cout< > dp(m+1,vector (n+1,1));\n \n \n \n for(int i=1; ik){\n ans++;\n int left=i-(recent+1);\n int right=n-1-i;\n ans+=left;\n ans+=right;\n ans+=(left*right);\n recent=i;\n }\n }\n return ans;\n }\n}\n\n\n\n// Method 2\n\nclass Solution {\n\n long countSubarray(int arr[], int n, int k) {\n\n // code here\n int dy[]=new int[n];\n int zero=-1;\n for(int i=0;ik) dy[i]=n-i;\n else {\n dy[i]=zero;\n zero-=1;\n }\n }\n \n long ans=0;\n long curZero=0;\n long zeros=0;\n for(int i=0;i0) {\n curZero=zeros;\n ans+=dy[i]+curZero;\n }\n else {\n ans+=curZero;\n zeros=Math.abs(dy[i]);\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Count of Subarrays/README.md", "content": "# Count of Subarrays\n\n\nGiven an array of N positive integers Arr1, Arr2 ............ Arrn. The value of each contiguous subarray of given array is the maximum element present in that subarray. The task is to return the number of subarrays having value strictly greater than K.\n\n**Example 1:**\n\n ```\nInput:\nN = 3, K = 2\nArr[] = {3, 2, 1}\nOutput: 3\nExplanation: The subarrays having value\nstrictly greater than K are: [3], [3, 2]\nand [3, 2, 1]. Thus there are 3 such\nsubarrays.\n```\n\n**Example 2:**\n\n```\n\nInput:\nN = 4, K = 1\nArr[] = {1, 2, 3, 4}\nOutput: 9\nExplanation: There are 9 subarrays having\nvalue strictly greater than K.\n```\n***\n\n\n**Your Task:**\nComplete the function **countSubarray()** which takes an array arr, two integers n, k, as input parameters and returns an integer denoting the answer. You don't to print answer or take inputs.\n\n*Expected Time Complexity:* O(N)\n*Expected Auxiliary Space:* O(1)\n\nConstraints:\n1 <= N <= 105\n1 <= Arr[i] <= 105\n" }, { "path": "GFG/Count the Substring/Count the Substring.cpp", "content": "class Solution{\npublic:\n long long countSubstring(string s){\n // start writing from here\n long long ans=0;\n unordered_map help; // start unodering \n vector dp(s.size(),0); // define the vector size\n long long sum=-1;\n if(s[0]=='1'){\n dp[0]=1;\n ans=1;\n sum=1;\n }\n help[sum]=0;\n help[0]=-1;\n for(int i=1;i= zeroes\n int cnt=n;\n int minus=0;\n for(int i=0;i countEleLessThanOrEqual(int arr1[], int arr2[], int m, int n)\n {\n //Your code goes here\n vector ans;\n \n sort(arr2, arr2+n);\n \n for(int i=0; i countEleLessThanOrEqual(int arr1[], int arr2[], int m, int n)\n {\n // add your code here\n Arrays.sort(arr2);//O(nlogn)\n ArrayList ans=new ArrayList<>();\n for(int i=0;i> B) {\n ArrayList[] graph=new ArrayList[vtces];\n int edge=B.size();\n for(int i=0;i();\n }\n //make 0 base vertex\n for(int i=0;i [] graph,int src,boolean[] visited){\n\n visited[src]=true;\n for(Edge e:graph[src]){\n if(visited[e.nbr]==false){\n isCycle(graph,e.nbr,visited);\n }else{\n return true;\n }\n }\n visited[src]=false;\n\n return false;\n }\n}\nclass Edge{\n int src;\n int nbr;\n Edge(int src,int nbr){\n this.src=src;\n this.nbr=nbr;\n }\n}\n" }, { "path": "GFG/Cycle in Undirected Graph/Cycle in Undirected Graph.java", "content": "public class Solution {\n public int solve(int A, ArrayList> B) {\n ArrayList> adj = new ArrayList<>();\n boolean vis[] = new boolean[A+1];\n for(int i=0;i<=A;i++){\n adj.add(new ArrayList());\n }\n for(ArrayList edge:B){\n adj.get(edge.get(0)).add(edge.get(1));\n adj.get(edge.get(1)).add(edge.get(0));\n }\n for(int i=1;i<=A;i++){\n if(vis[i]==false){\n if(dfs(adj,vis,i,-1))return 1;\n }\n }\n return 0;\n }\n public boolean dfs(ArrayList> adj, boolean vis[],int node,int parent){\n vis[node] = true;\n for(int it:adj.get(node)){\n if(!vis[it]){\n if(dfs(adj,vis,it,node))return true;\n }else{\n if(it!=parent)return true;\n }\n }\n return false;\n }\n}\n" }, { "path": "GFG/Decode the string/Decode the string.cpp", "content": "class Solution{\npublic:\n string decodedString(string s){\n\n string res=\"\";\n\n stack st;\n\n st.push(s[0]);\n\n for(int i=1;i='0'&&st.top()<='9'){\n\n rnum=st.top()+rnum;\n\n st.pop();\n\n }\n\n string sr=res;\n\n for(int j=0;j nums=new Stack<>();\n Stack st=new Stack<>();\n int i=0;\n while(i='0' && s.charAt(i)<='9'){\n int n=0;\n while(s.charAt(i)>='0' && s.charAt(i)<='9'){\n n=n*10+(s.charAt(i)-'0');\n i++;\n }\n nums.push(n);\n }else{\n if(s.charAt(i)==']'){\n int n=nums.pop();\n StringBuilder inner=new StringBuilder();\n while(!st.peek().equals(\"[\")){\n inner.append(st.pop());\n }\n st.pop();\n StringBuilder newStr=new StringBuilder();\n while(n>0){\n newStr.append(inner);\n n--;\n }\n st.push(newStr.toString());\n }else{\n st.push(\"\"+s.charAt(i));\n }\n i++;\n }\n }\n \n StringBuilder sb=new StringBuilder();\n while(st.size()>0){\n sb.append(st.pop());\n }\n return sb.reverse().toString();\n }\n}\n\n\n//Method 2 Using single stack\n\n\nclass Solution{\n static String decodedString(String s){\n // code here\n Stack st=new Stack<>();\n \n for(int i=0;i1 || (st.peek().length()==1 && st.peek().charAt(0)!='['))) { //popping all and adding to sb until we come across '['\n sb.append(st.pop());\n }\n st.pop();\n while(!st.isEmpty() && \n (st.peek().length()==1 && st.peek().charAt(0)>='0' && st.peek().charAt(0)<='9')) { \n num.append(\"\"+st.pop());\n }\n \n int times=1;\n if(num.length()>0)\n times=Integer.valueOf(num.reverse().toString());\n \n StringBuilder toAppend=new StringBuilder();\n for(int j=0;j q=new LinkedList<>();\n for(int i=0;i0){\n int[]idx=q.remove();\n int x=idx[0];\n int y=idx[1];\n ans[x][y]=dis;\n for(int[]dir:dirs){\n int i=x+dir[0];\n int j=y+dir[1];\n if(i>=0 && j>=0 && i sortedStrings(int N, vector A) {\n \n // code here\n \n vectorans;\n mapmp;\n for(int i=0;i> &enemy)\n {\n if(k==0) return n*m;\n vector r(n+1,false), c(m+1, false);\n \n \n for(int i=0;i rows=new ArrayList<>();\n \n rows.add(-1);\n for(int[]i:enemy){\n rows.add(i[0]-1);\n }\n rows.add(n);\n Collections.sort(rows);\n \n int maxRow=0;\n for(int i=1;i cols=new ArrayList<>();\n cols.add(-1);\n for(int[]i:enemy){\n cols.add(i[1]-1);\n }\n cols.add(m);\n Collections.sort(cols);\n \n \n int maxCol=0;\n for(int i=1;icapacity) {\n long mod=1e9+7;\n sort(capacity.begin(),capacity.end());\n \n long ans=1;\n \n for(int i=0;i dp(N+1);\n dp[0]=0;\n dp[1]=1;\n dp[2]=2;\n for(int i=3;i<=N;i++)\n dp[i]=(dp[i-1]+dp[i-2])%mod;\n return dp[N];\n }\n};\n" }, { "path": "GFG/Filling Bucket/Filling Bucket.java", "content": "class Solution {\n static int fillingBucket(int N) {\n // code here\n if(N==1)return 1;\n int prev=2;\n int secPrev=1;\n int mod=100000000;\n for(int i=0;i\nusing namespace std;\nclass Solution {\n public:\n int safePos(int n, int k) {\n // code here\n if(n==1) return 1;\n int p = safePos(n-1, k);\n return (p+k-1)%n +1;\n }\n};\nint main() {\n int t;\n cin >> t;\n while (t--) {\n int n,k;\n \n cin>>n>>k;\n\n Solution ob;\n cout << ob.safePos(n,k) << endl;\n }\n return 0;\n}" }, { "path": "GFG/Find The Safe Position/Find the Safe Position.java", "content": "class Solution {\n static int safePos(int n, int k) {\n ArrayListaa=new ArrayList();\n for(int i=0;i m;\n \n for(int i = 0; i < N; i++)\n m[start[i]]++;\n \n for(int i = 0; i < N; i++)\n m[end[i]]--;\n \n int cnt = 0;\n int sum = 0;\n for(auto i : m)\n {\n sum += i.second;\n cnt = max(cnt , sum);\n \n }\n return cnt;\n }\n};\n" }, { "path": "GFG/Find minimum number of Laptops required/Find minimum number of Laptops required.java", "content": "//1. sort according to our starting time\n//2. use priorityq to check minimum end time of previous laptop to be free\n//3. compare that with start time of our new job\n\nclass Solution {\n public int minLaptops(int n, int[] start, int[] end) {\n // code here\n int[][] arr=new int[n][2];\n for(int i=0;i{\n if(a[0]!=b[0])return a[0]-b[0];\n return a[1]-b[1];\n });\n \n int ans=1;\n PriorityQueue pq=new PriorityQueue<>();\n pq.add(arr[0][1]);\n int i=1;\n while(i>= 1;\n }\n \n return S[N] ^ flip;\n }\n};\n" }, { "path": "GFG/Find the first node of loop in linked list/Find the first node of loop in linked list.java", "content": "class Solution {\n //Function to find first node if the linked list has a loop.\n public static int findFirstNode(Node head){\n //code here\n Node slow=head;\n Node fast=head;\n while(fast!=null && fast.next!=null){\n slow=slow.next;\n fast=fast.next.next;\n if(slow==fast)break;\n }\n if(fast==null || fast.next==null)return -1;\n Node temp=head;\n while(temp!=slow){\n temp=temp.next;\n slow=slow.next;\n }\n return slow.data;\n }\n}\n" }, { "path": "GFG/Find the longest string/Find the longest string.java", "content": "class TrieNode{\n boolean isEnd;\n TrieNode[] arr;\n TrieNode(){\n isEnd=false;\n arr = new TrieNode[26];\n }\n}\n\n\nclass Solution {\n static TrieNode root;\n public static String longestString(int n, String[] arr) {\n // code here\n root=new TrieNode();\n for(String s:arr){\n insert(s);\n }\n String ans=\"\";\n for(String s:arr){\n if(s.length()ans.length()){\n ans=s;\n }else if(s.length()==ans.length()){\n if(s.compareTo(ans)<0){\n ans=s;\n }\n }\n }\n }\n }\n return ans;\n \n }\n \n static boolean isPresent(String s){\n TrieNode curr=root;\n for(char c:s.toCharArray()){\n int index=c-'a';\n curr=curr.arr[index];\n if(curr.isEnd==false)return false;\n }\n return true;\n }\n \n static void insert(String s){\n TrieNode curr=root;\n for(char c:s.toCharArray()){\n int index=c-'a';\n if(curr.arr[index]==null){\n curr.arr[index]=new TrieNode();\n }\n curr=curr.arr[index];\n }\n curr.isEnd=true;\n }\n}\n" }, { "path": "GFG/Find the maximum GCD of the siblings of a Binary Tree/Find the maximum GCD of the siblings of a Binary Tree.java", "content": "class Solution {\n int max_gcd;\n int ans;\n int maxGCD(Node root) {\n // code here \n ans=0;\n max_gcd=0;\n dfs(root);\n return ans;\n }\n int dfs(Node root){\n if(root==null)return 0;\n int left=dfs(root.left);\n int right=dfs(root.right);\n if(left!=0 && right!=0){\n int gcd=gcd(left,right);\n if(gcd>max_gcd){\n max_gcd=gcd;\n ans=root.data;\n }else if(gcd==max_gcd && root.data>ans){\n ans=root.data;\n }\n }\n return root.data;\n }\n int gcd(int a,int b){\n if(a==0)return b;\n return gcd(b%a,a);\n }\n}\n" }, { "path": "GFG/Fitting The Array/Fitting The Array s28.cpp", "content": "#include\nusing namespace std;\nclass Solution{\npublic:\n \n bool isFit(int arr[], int brr[], int n){\n // code here\n sort(arr, arr+n);\n sort(brr, brr+n);\n \n for(int i=0; i>t;\n for(z=0;z>n;\n int arr[n+1], brr[n+1];\n \n for(i=0;i>arr[i];\n for(i=0;i>brr[i];\n \n Solution ob;\n \n if(ob.isFit(arr, brr, n)) cout<<\"YES\\n\";\n else\n cout << \"NO\\n\";\n \n \n }\n return 0;\n}" }, { "path": "GFG/Fitting The Array/Fitting The Array.cpp", "content": "class Solution{\npublic:\n \n bool isFit(int arr[], int brr[], int n){\n // code here\n sort(arr, arr+n);\n sort(brr, brr+n);\n \n for(int i=0; i brr[i])\n return false;\n \n return true;\n }\n};\n" }, { "path": "GFG/Fitting The Array/Fitting The Array.java", "content": "class Solution{\n \n \n // Function for finding maximum and value pair\n public static boolean isFit (int arr[], int brr[], int n) {\n //Complete the function\n Arrays.sort(arr);\n Arrays.sort(brr);\n for(int i=0;ibrr[i]){\n return false;\n }\n }\n return true;\n }\n \n}\n" }, { "path": "GFG/Flatten binary tree to linked list/Flatten binary tree to linked list.java", "content": "class Solution\n{\n static Node curr;\n public static void flatten(Node root)\n {\n //code here\n curr=new Node(-1);\n dfs(root);\n }\n static void dfs(Node root){\n if(root==null)return;\n Node leftSubtree=root.left;\n root.left=null;\n Node rightSubtree=root.right;\n root.right=null;\n \n curr.right=root;\n curr=curr.right;\n \n dfs(leftSubtree);\n dfs(rightSubtree);\n \n }\n}\n" }, { "path": "GFG/Flatten binary tree to linked list/Readme.md", "content": "Given the root of a binary tree, flatten the tree into a \"linked list\":\n\nThe \"linked list\" should use the same Node class where the right child pointer points to the next node in the list and the left child pointer is always null.\nThe \"linked list\" should be in the same order as a pre-order traversal of the binary tree.\nExample 1:\n\nInput : \n 1\n / \\\n 2 5\n / \\ \\\n 3 4 6\nOutput :\n1 2 3 4 5 6 \nExplanation: \nAfter flattening, the tree looks \nlike this\n 1\n \\\n 2\n \\\n 3\n \\\n 4\n \\\n 5\n \\\n 6 \nHere, left of each node points \nto NULL and right contains the \nnext node in preorder.The inorder \ntraversal of this flattened tree \nis 1 2 3 4 5 6.\nExample 2:\n\nInput :\n 1\n / \\\n 3 4\n /\n 2\n \\\n 5 \nOutput : \n1 3 4 2 5 \nExplanation : \nAfter flattening, the tree looks \nlike this \n 1\n \\\n 3\n \\\n 4\n \\\n 2\n \\ \n 5 \nHere, left of each node points \nto NULL and right contains the \nnext node in preorder.The inorder \ntraversal of this flattened tree \nis 1 3 4 2 5.\nYour task:\nYou don't have to read input or print anything. Your task is to complete the function flatten() which takes the root of the tree and flattens the tree into a linkes list without using any auxiliary space.\nNote : The driver code prints the inorder traversal of the flattened binary tree.\n \nExpected Time Complexity: O(n)\nExpected Auxiliary Space: O(1)\n \nConstraints :\n1<=n<=10^5\n" }, { "path": "GFG/Flattening a Linked List/Flattening a Linked List.java", "content": "class GfG\n{\n Node flatten(Node root)\n {\n\t// Your code here\n\t Node nexty=root.next;\n\t while(nexty!=null){\n\t Node second=nexty;\n\t nexty=nexty.next;\n\t second.next=null;\n\t root=merge(root,second);\n\t }\n\t return root;\n }\n Node merge(Node l1,Node l2){\n Node head=new Node(0);\n Node curr=head;\n while(l1!=null && l2!=null){\n if(l1.data<=l2.data){\n curr.bottom=l1;\n l1=l1.bottom;\n }else{\n curr.bottom=l2;\n l2=l2.bottom;\n }\n curr=curr.bottom;\n }\n \n if(l1!=null)curr.bottom=l1;\n if(l2!=null)curr.bottom=l2;\n \n return head.bottom;\n }\n}\n" }, { "path": "GFG/Floyd Warshall/Floyd Warshall.java", "content": "class Solution\n{\n public void shortest_distance(int[][] mat)\n {\n // Code here \n int n=mat.length;\n for(int k=0;k>&mat)\n int n = mat.size();\n for(int i = 0;i1->2\nand the cost will be 1+6=7 which is less than \n43.\n\n```\n***\n\n**Your Task:**\nYou don't need to read, return or print anything. Your task is to complete the function **shortest_distance()** which takes the matrix as input parameter and modifies the distances for every pair in-place.\n\n**Expected Time Complexity:** O(n3)\n**Expected Space Complexity:** O(1)\n\n**Constraints:**\n1 <= n <= 100\n-1 <= matrix[ i ][ j ] <= 1000\n" }, { "path": "GFG/Form a palindrome/Form a palindrome.py", "content": "#User function Template for python3\n\nclass Solution:\n def countMin(self, Str):\n arr = Str\n brr = arr[::-1]\n \n m = len(arr)\n n = len(brr)\n lcs = [[0]*(n+1) for _ in range(m+1)]\n \n for i in range(1,m+1):\n for j in range(1,n+1):\n if arr[i-1] == brr[j-1]:\n lcs[i][j] = 1 + lcs[i-1][j-1]\n else:\n lcs[i][j] = max(lcs[i-1][j], lcs[i][j-1])\n return n - lcs[m][n]\n\n#{ \n # Driver Code Starts\n#Initial Template for Python 3\n\nif __name__ == '__main__':\n\n t = int(input())\n\n for _ in range(t):\n Str = input()\n \n\n solObj = Solution()\n\n print(solObj.countMin(Str))\n# } Driver Code Ends\n" }, { "path": "GFG/GCD Array/GCD Array.java", "content": "class Solution {\n public static int solve(int N, int K, int[] arr) {\n // code here\n for(int i=1;i factor = new ArrayList<>();\n for(int i=1;i*i<=arr[N-1];i++) {\n if(arr[N-1]%i==0) {\n factor.add(i);\n factor.add(arr[N-1]/i);\n }\n }\n \n int ans=1;\n for(int fact : factor) {\n int count=0;\n for(int a : arr) {\n if(a%fact==0) {\n count++;\n }\n }\n if(count>=K) ans=Math.max(ans,fact);\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Geek and Number String/Geek and Number Str.cpp", "content": "int minLength(string s, int n) {\n string temp=\"12 21 34 43 56 65 78 87 09 90\";\n stackst;\n st.push(s[0]);\n for(int i=1;i0){\n string str;\n str+=st.top();\n str+=s[i];\n if(temp.find(str)!=string::npos){\n st.pop();\n }else{\n st.push(s[i]);\n }\n }else\n st.push(s[i]);\n }\n return st.size();\n } " }, { "path": "GFG/Geek and Strings/Geek and Strings.java", "content": "class Solution{\n static class Trie {\n Trie child[]=new Trie[26];\n int count[]=new int[26];\n }\n static List prefixCount(int N, int Q, String li[], String query[])\n {\n // code here\n List res=new ArrayList<>();\n Trie head=null;\n head=new Trie();\n Trie cur=head;\n for(int i=0;i=n || y<0 || y>=m || visited[x][y]==true || mat[x][y]=='#') return false;\n else return true;\n }\n \n\n\tpublic static int numberOfCells(int n, int m, int r, int c, int u, int d, char mat[][])\n\t{\n\t Queue queue = new ArrayDeque<>();\n\t \n\t boolean visited[][] = new boolean[n][m];\n\t \n\t queue.offer(new Pair(r, c, u, d));\n\t \n\t visited[r][c] = true;\n\t \n\t if(mat[r][c]=='#') return 0;\n\t \n\t int total_count = 1;\n\t \n\t while(!queue.isEmpty())\n\t {\n\t Pair p = queue.poll();\n\t \n\t \n\t if(isValid(p.x, p.y+1, visited, mat, n, m))\n\t {\n\t total_count++;\n\t visited[p.x][p.y+1] = true;\n\t queue.offer(new Pair(p.x, p.y+1, p.u_left, p.d_left));\n\t }\n\t \n\t if(isValid(p.x, p.y-1, visited, mat, n, m))\n\t {\n\t total_count++;\n\t visited[p.x][p.y-1] = true;\n\t queue.offer(new Pair(p.x, p.y-1, p.u_left, p.d_left));\n\t }\n\t \n\t if(p.d_left>0 && isValid(p.x+1, p.y, visited, mat, n, m))\n\t {\n\t total_count++;\n\t visited[p.x+1][p.y] = true;\n\t queue.offer(new Pair(p.x+1, p.y, p.u_left, p.d_left-1));\n\t }\n\t \n\t if(p.u_left>0 && isValid(p.x-1, p.y, visited, mat, n, m))\n\t {\n\t total_count++;\n\t visited[p.x-1][p.y] = true;\n\t queue.offer(new Pair(p.x-1, p.y, p.u_left-1, p.d_left));\n\t }\n\t \n\t }\n\t \n\t return total_count;\n\t\t\n\t}\n\n}\n\n\n// { Driver Code Starts.\n\npublic class GFG {\n\tpublic static void main (String[] args) {\n\t Scanner sc = new Scanner(System.in);\n\t\tint t = sc.nextInt();\n\t\twhile (t-- > 0)\n\t\t{\n\t\t int n = sc.nextInt();\n\t\t int m = sc.nextInt();\n\t\t int r = sc.nextInt();\n\t\t int c = sc.nextInt();\n\t\t int u = sc.nextInt();\n\t\t int d = sc.nextInt();\n\t\t \n\t\t char mat[][] = new char[n][m];\n\n for(int i = 0; i < n; i++)\n {\n String s = sc.next();\n for(int j = 0; j < m; j++)\n {\n mat[i][j] = s.charAt(j);\n }\n }\n \n Solution obj = new Solution();\n System.out.println(obj.numberOfCells(n, m, r, c, u, d, mat));\n\t\t \n\t\t}\n\t}\n}\n\n // } Driver Code Ends" }, { "path": "GFG/Geek in a Maze/README.md", "content": "# Geek in a Maze\n## Hard \n
\n

Geek is in a maze of size N * M. Each cell in the maze is made of either '.' or '#'. An empty cell is represented by '.' and an obstacle is represented by '#'. If Geek starts at cell (R, C), find how many different empty cells he can pass through while avoiding the obstacles. He can move in any of the four directions but he can move up at most U times and he can move down atmost D times.

\n\n

 

\n\n

Example 1:

\n\n
Input: \nN = 3, M = 3\nR = 1, C = 0\nU = 1, D = 1\nmat = {{'.', '.', '.'},\n       {'.', '#', '.'},\n       {'#', '.', '.'}}\nOutput: 5\nExplanation: Geek can reach \n(1, 0), (0, 0), (0, 1), (0, 2), (1, 2) \n\n
\n\n


\nExample 2:

\n\n
Input: \nN = 3, M = 4\nR = 1, C = 0\nU = 1, D = 2 \nmat = {{'.', '.', '.'}, \n       {'.', '#', '.'}, \n       {'.', '.', '.'},\n       {'#', '.', '.'}} \nOutput: 10\nExplanation: Geek can reach all the \ncells except for the obstacles.\n
\n\n

 

\n\n

Your Task:  
\nYou don't need to read input or print anything. Complete the function numberOfCells() which takes N, M, R, C, U, D and the two dimensional character array mat[][] as input parameters and returns the number of cells geek can visit( If he is standing on obstacle he can not move).

\n\n


\nConstraints:
\n1 ≤ N*M ≤ 106
\nmat[i][j] = '#\" or '.'
\n0 ≤ R ≤ N-1
\n0 ≤ C ≤ M-1

\n

\n
" }, { "path": "GFG/Grouping Of Numbers/Grouping Of Numbers.java", "content": "class Solution {\n static int maxGroupSize(int[] a, int N, int k) {\n // code here\n int[]dp=new int[k];\n for(int i:a){\n dp[i%k]++;\n }\n \n int maxSize=0;\n int i=1;\n int j=k-1;\n while(i0){\n maxSize++;\n }\n if(i==j && dp[i]>0){\n maxSize++;\n }\n return maxSize;\n }\n};\n\n\n// Method 2:\n\nclass Solution {\n static int maxGroupSize(int[] arr, int N, int K) {\n // code here\n int freq[]=new int[K];\n for(int i=0;ifreq[end]) {\n freq[end]=0;\n }\n else {\n freq[start]=0;\n }\n }\n }\n else {\n if(freq[start]>0) freq[start]=1;\n }\n start+=1;\n end-=1;\n }\n \n if(freq[0]>0) freq[0]=1;\n \n int count=0;\n for(int i=0;i0) count+=freq[i];\n }\n return count;\n }\n};\n" }, { "path": "GFG/Hamiltonian Path/Hamiltonian Path.cpp", "content": "\n }\n};\n" }, { "path": "GFG/Hamiltonian Path/Hamiltonian Path.java", "content": "class Solution \n{ \n int n;\n boolean check(int N, int M, ArrayList> Edges) \n { \n // code here\n n=N;\n Map> map=new HashMap<>();\n for(ArrayList edge:Edges){\n int src=edge.get(0);\n int des=edge.get(1);\n map.putIfAbsent(src,new ArrayList<>());\n map.putIfAbsent(des,new ArrayList<>());\n map.get(src).add(des);\n map.get(des).add(src);\n }\n \n Set set=new HashSet<>();\n for(int node=1;node<=N;node++){\n if(dfs(node,set,map)){\n return true;\n }\n }\n return false;\n }\n boolean dfs(int curr,Set set,Map> map){\n set.add(curr);\n if(set.size()==n){\n return true;\n }\n \n for(int neb:map.get(curr)){\n if(!set.contains(neb) && dfs(neb,set,map)){\n return true;\n }\n }\n \n set.remove(curr);//back..\n return false;\n }\n} \n" }, { "path": "GFG/Hamiltonian Path/README.md", "content": "## Hamiltonian Path\n\nA Hamiltonian path, is a path in an undirected graph that visits each vertex exactly once. Given an undirected graph, the task is to check if a Hamiltonian path is present in it or not.\n\n**Example 1:**\n\n```\nInput:\nN = 4, M = 4\n\nEdges[][]= { {1,2}, {2,3}, {3,4}, {2,4} }\n\nOutput:\n1 \nExplanation: \n\nThere is a hamiltonian path: \n1 -> 2 -> 3 -> 4 \n\n```\n**Example 2:**\n\n```\nInput:\nN = 4, M = 3 \n\nEdges[][] = { {1,2}, {2,3}, {2,4} } \n\nOutput: \n0 \n\nExplanation: \nIt can be proved that there is no \nhamiltonian path in the given graph\n```\n\n***\n\n**Your task:**\nYou don't need to read input or print anything. Your task is to complete the function **check()** which takes the N (the number of vertices), M (Number of edges) and the list of Edges[][] (where Edges[i] denotes the undirected Edge between vertices Edge[i][0] and Edges[i][1] ) as input parameter and returns true (boolean value) if the graph contains Hamiltonian path,otherwise returns false. \n\n\n**Expected Time Complexity:** O(N!).\n**Expected Auxiliary Space:** O(N+M).\n\n\n**Constraints:**\n1 ≤ N ≤ 10\n1 ≤ M ≤ 15\nSize of Edges[i] is 2\n1 ≤ Edges[i][0],Edges[i][1] ≤ N\n" }, { "path": "GFG/Help Ishaan/Help Ishaan.cpp", "content": "\tpublic:\n\tbool isPrime(int x){\n\n if(x==1)return false;\n\n if(x==2||x==3)\n\n return true;\n\n if(x%2==0||x%3==0)\n\n return false;\n\n for(int i=5;i*i<=x;i+=6){\n\n if(x%i==0||x%(i+2)==0)\n\n return false;\n\n }\n\n return true;\n\n }\n\t\tint NthTerm(int N){\n\t\t // Code here\n\t\t if(isPrime(N))\n\n return 0;\n\n int n1,n2;\n\n n1=N-1,n2=N+1;\n\n while(n1>1 && isPrime(n1)==0)\n\n n1--;\n\n while(isPrime(n2)==0)\n\n n2++;\n\n \n\n return (n1>1)?min(N-n1,n2-N):(n2-N); \n\t\t}\n\n};\n" }, { "path": "GFG/Help Ishaan/Help Ishaan.java", "content": "class Solution\n{\n public static boolean isPrime(int n){\n if(n==1){\n return false;\n }\n else if(n==2 || n==3){\n return true;\n }\n else if(n%2==0 || n%3==0){\n return false;\n }\n else{\n for(int i=5;i<=Math.sqrt(n);i+=6){\n if(n%(i)==0 || n%(i+2)==0){\n return false;\n }\n }\n return true;\n }\n \n }\n public int NthTerm(int n)\n {\n if(isPrime(n)==true){\n return 0;\n }\n else{\n \n int diff=0;\n if(n-19<=0){\n diff=0;\n }\n else{\n diff=n-19;\n }\n int min=Integer.MAX_VALUE;\n for(int i=diff;i<(n+19);i++){\n if(isPrime(i)){\n min=Integer.min((int)Math.abs(i-n),min);\n }\n }\n return min;\n \n \n }\n }\n}\n\n\n// A different code for the same solution\n\nclass Solution\n{\n public static boolean isPrime(int num){\n if(num<2){\n return false;\n }\n for(int i = 2; i<= Math.sqrt(num); i++){\n if(num % i == 0){\n return false;\n }\n }\n return true;\n }\n public int NthTerm(int n)\n {\n // code here\n int diff = 0;\n if(isPrime(n)){\n return diff;\n }\n while(true){\n if(isPrime(n+diff) || isPrime(n-diff)){\n break;\n }\n diff++;\n }\n return diff;\n \n }\n}\n" }, { "path": "GFG/Help Ishaan/README.md", "content": "## Help Ishaan\n\nIshaan has been given a task by his teacher. He needs to find the **Nth** term of a series. His teacher gives him some examples to help him out (Refer examples below). He is a bit weak in pattern searching so to help him his teacher told him that the **Nth term is related to prime numbers**. The Nth term is the **difference of N and the closest prime number to N.** Help him find the Nth term for a given N.\n \n\n**Example 1:**\n```\nInput: N = 10\n\nOutput: 1\n\nExplanation: Closest prime to 10 is 11.\n```\n\n**Example 2:**\n```\nInput: N = 7\n\nOutput: 0\n\nExplanation: Closest prime to 7 is 7.\n \n```\n**Your Task:**\n\nYou don't need to read or print anything. Your task is to complete the function **NthTerm()** which takes **N** as input paramater and returns **Nth** term.\n \n\n**Expected Time Complexity:** O(N* √ N)\n**Expected Space Complexity:** O(1)\n\n**Constraints:**\n1 <= N <= 100000\n" }, { "path": "GFG/Help a Thief/Help a thief.cpp", "content": "// { Driver Code Starts\n//Initial Template for C++\n\n#include \nusing namespace std;\n\n // } Driver Code Ends\n//User function Template for C++\n\nclass Solution\n{\npublic:\n int maxCoins(int A[], int B[], int T, int N)\n {\n // code here\n vector> v;\n for (int i = 0; i < N; i++)\n {\n v.push_back({B[i], A[i]});\n }\n sort(v.rbegin(), v.rend());\n int k = 0;\n for (int i = 0; i < N; i++)\n {\n if (T == 0)\n {\n return k;\n }\n int p = min(v[i].second, T);\n k += p * v[i].first;\n T -= p;\n }\n return k;\n }\n};\n\n// { Driver Code Starts.\nint main() {\n int t;\n cin >> t;\n while (t--) {\n int T,N;\n cin>>T>>N;\n \n int A[N], B[N];\n \n for(int i=0; i>A[i];\n for(int i=0; i>B[i];\n\n Solution ob;\n cout << ob.maxCoins(A,B,T,N) << endl;\n }\n return 0;\n} // } Driver Code Ends" }, { "path": "GFG/Help a Thief/README.md", "content": "# Help a Thief!!!\n## Easy\n
\n

You have to help a thief to steal as many as GoldCoins as possible from a GoldMine. There he saw N Gold Boxes an each Gold Boxes consists of Ai Plates each plates consists of Bi Gold Coins. Your task is to print the maximum gold coins theif can steal if he can take a maximum of T plates.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nT = 3, N = 3 \nA[] = {1, 2, 3}\nB[] = {3, 2, 1}\nOutput:\n7\nExplanation:\nThe thief will take 1 plate of coins\nfrom the first box and 2 plate of coins\nfrom the second plate. 3 + 2*2 = 7.
\n\n

Example 2:

\n\n
Input:\nT = 0, N = 3 \nA[] = {1, 3, 2}\nB[] = {2, 3, 1}\nOutput:\n0\nExplanation:\nThe thief can't take any plates.\nSo he can't steal any coins.
\n\n

 

\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function maxCoins() which takes 2 Integers T, and N and two arrays A and B of size N as input and returns the maximum number of gold coins the thief can steal if he can take a maximum of T plates.

\n\n

 

\n\n

Expected Time Complexity: O(N*logN)
\nExpected Auxiliary Space: O(N)

\n\n

 

\n\n

Constraints:
\n0 <= T,N <= 104
\n1 <= A[i] <= 104
\n1 <= B[i] <= 104

\n

\n
" }, { "path": "GFG/Help the Old Man/Help the old man.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(a[0]);\n int n = Integer.parseInt(a[1]);\n \n Solution ob = new Solution();\n List ans = new ArrayList();\n ans = ob.shiftPile(N, n);\n System.out.println(ans.get(0)+\" \"+ans.get(1));\n }\n }\n}// } Driver Code Ends\n\nclass Solution{\n public static void hanoi(int N,int A,int B,int C,ArrayList> r){\n if(N==0)return;\n hanoi(N-1,A,C,B,r);\n ArrayList z=new ArrayList();\n z.add(A);\n z.add(B);\n r.add(z);\n hanoi(N-1,C,B,A,r);\n }\n static List shiftPile(int N, int n){\n ArrayList> r=new ArrayList>();\n hanoi(N,1,3,2,r);\n return r.get(n-1);\n }\n}" }, { "path": "GFG/Help the Old Man/README.md", "content": "# Help the Old Man!!!\n## Easy \n
\n

A poor old man works in a palace for a living. One day the old man's wife met with an accident. She needed an immediate operation but the old man's savings were not enough for the operation. He went running to the king to beg for money. The king told that he will not only pay the full amount for the operation but also double his salary. But for that the old man had to pass a test. The king showed him a pile of glass plates kept one above another, each one being smaller than the one beneath. The plates were kept in box 1. He had to transfer the plates to box 3 using box 2. However, there were some constraints. The old man could only take one plate at a time and he could only place a smaller plate on top of a larger plate. He could take a plate only from the top. Help the old man do so. There are N plates and he has to tell the nth move in the format (i, j) where a plate is being moved from ith box to jth box.

\n\n

Note:
\nGiven any number of plates, they can be transferred from box 1 to box 3 using box 2 using the following steps.
\nStep 1: Transfer first N-1 plates from box 1 to box 2 using box 3.
\nStep 2: Transfer the remaining plate from box 1 to box 3.
\nStep 3: Transfer the first N-1 plates from box 2 to box 3 using box 1.

\n\n

Example 1:

\n\n
Input: N = 2, n = 2\nOutput: 1 3\nExplaination:  The plate on top of box 1 is \nfirst transferred to box 2. The second plate \nfrom box 1 is transferred to box 3 and finally \nthe plate from box 2 is transferred to box 3. \nIn each situation, all the constraints are \nsatisfied. You are required to print the 2nd \nmove which is \"Move plate from box 1 to box 3\", \nhence 1 3.
\n\n

Example 2:

\n\n
Input: N = 3, n = 4.\nOutput: 1 3\nExplaination: The movements of plates will \nbe from 1 to 3. Then from 1 to 2. Then from \n3 to 2. And finally 4th move from 1 to 3.
\n\n

Your Task:
\nYou do not need to read input or print anyting. Your task is to complete the function shiftPile() which takes N and n as input parameters and returns the nth move in a list.

\n\n

Expected Time Complexity: O(2N)
\nExpected Auxiliary Space: O(1)

\n\n

Constraints:
\n1 ≤ N ≤ 20
\n1 ≤ n ≤ 1000 

\n

\n
" }, { "path": "GFG/Hungry Pizza Lovers/Hungry pizza lovers.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t String line = br.readLine();\n\t\t String[] element = line.trim().split(\"\\\\s+\");\n\t\t int sizeOfArray = Integer.parseInt(element[0]);\n\t\t \n\t\t int arr [][] = new int[sizeOfArray][2];\n\t\t \n\t\t for(int i = 0;i ans;\n\t\t ans = obj.permute(arr, sizeOfArray);\n\t\t for(int i: ans)\n\t\t System.out.println(i);\n\t\t}\n\t}\n}\n\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Complete{\n \n \n // Function for finding maximum and value pair\n public static ArrayList permute (int arr[][], int n) {\n Map map=new HashMap<>();\n for(int i=0;iInteger.compare(a[0]+a[1],b[0]+b[1]));\n ArrayList ans=new ArrayList<>();\n \n for(int i=0;i\n

Dominos Pizza has hungry customers waiting in the queue. Each unique order is placed by a customer at time x[i], and the order takes y[i] units of time to complete.
\nYou have information on all n orders, Find the order in which all customers will receive their pizza and return it. If two or more orders are completed at the same time then sort them by non-decreasing order number.

\n\n

Example 1:

\n\n
Input : arr[ ] = {{4,1}, {6,2}, {7,6}, \n                       {8,1}, {1,3}}\nOutput : 5 1 2 4 3\nExplanation:\nHere an array can be transform to \n{5, 8, 13, 9, 4}. Here 5th index order \nreceived first then 1st order, 2nd order...\nreturn {5, 1, 2, 4, 3}\n
\n\n


\nExample 2:

\n\n
Input : arr[ ] = {{1,1}, {1,1}, {1,1}} \nOutput :  1 2 3
\n\n

 

\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function permute() that takes 2-d array (arr), sizeOfArray (n), and return the array of order in which customers will receive their pizza. The driver code takes care of the printing.

\n\n

Expected Time Complexity: O(N*LOG(N)).
\nExpected Auxiliary Space: O(N).

\n\n

Constraints:
\n1 ≤ N ≤ 105
\n1 ≤ arr[i][0], arr[i][1] ≤ 105

\n

\n " }, { "path": "GFG/IPL/IPL.cpp", "content": "vector max_of_subarrays(vector arr, int n, int k) {\n \n dequepq;\n vectorans;\n \n for(int i=0;i=k-1){ \n ans.push_back(arr[pq.front()]);\n }\n }\n \n return ans;\n }" }, { "path": "GFG/IPL 2021 - Match Day 2/IPL 2021 - Match Day 2 gfg med s22.cpp", "content": "#include \nusing namespace std;\n\nclass Solution {\n public:\n vector max_of_subarrays(vector arr, int n, int k) {\n // your code here\n vectorres;\n multisetm;\n\n for(int i =0; i> t;\n\n while (t--) {\n\n int n, k;\n cin >> n >> k;\n\n vector arr(n);\n for (int i = 0; i < n; i++) cin >> arr[i];\n Solution ob;\n vector res = ob.max_of_subarrays(arr, n, k);\n for (int i = 0; i < res.size(); i++) cout << res[i] << \" \";\n cout << endl;\n }\n\n return 0;\n}\n" }, { "path": "GFG/Ishaan Loves Chocolates/Ishaan loves chocolates.py", "content": "#User function Template for python3\n\ndef chocolates (arr, n):\n return min(arr)\n \n\n\n#{ \n# Driver Code Starts\n#Initial Template for Python 3\n\n\nfor _ in range(0,int(input())):\n n = int(input())\n arr = list(map(int, input().strip().split()))\n ans = chocolates(arr, n)\n print(ans)\n \n\n\n\n\n\n# } Driver Code Ends" }, { "path": "GFG/Ishaan Loves Chocolates/README.md", "content": "# Ishaan Loves Chocolates\n## Easy\n
\n

As we know, Ishaan has a love for chocolates. He has bought a huge chocolate bar that contains N chocolate squares. Each of the squares has a tastiness level which is denoted by an array A[].
\nIshaan can eat the first or the last square of the chocolate at once. Ishaan has a sister who loves chocolates too and she demands the last chocolate square. Now, Ishaan being greedy eats the more tasty square first. 
\nDetermine the tastiness level of the square which his sister gets.

\n\n

Example 1:

\n\n
Input : arr[ ] = {5, 3, 1, 6, 9}\nOutput : 1\nExplanation:\nInitially: 5 3 1 6 9\nIn first step: 5 3 1 6\nIn Second step: 5 3 1\nIn Third step: 3 1\nIn Fourth step: 1\nReturn 1
\n\n


\n
\nExample 2:

\n\n
Input : arr[ ] = {5, 9, 2, 6} \nOutput :  2\n\n
\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function chocolates() that takes an array (arr), sizeOfArray (n) and return the tastiness level of the square which his sister gets. The driver code takes care of the printing.

\n\n

Expected Time Complexity: O(N).
\nExpected Auxiliary Space: O(1).

\n\n

 

\n\n

Constraints : 
\n1 ≤ N ≤ 105
\n1 ≤ A[i] ≤ 109

\n

\n
" }, { "path": "GFG/Josephus problem/Josephus problem.java", "content": "class Solution\n{\n public int josephus(int n, int k)\n {\n //Your code here\n if(n==1)return n;\n return (josephus(n-1,k)+(k-1))%n +1;\n }\n\n}\n" }, { "path": "GFG/Jump Game/Jump game.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n \n String S1[] = read.readLine().split(\" \");\n \n int[] A = new int[N];\n \n for(int i=0; i=0;i--)\n {\n step++;\n if(A[i]>=step)step=0;\n }\n if(step==0)return 1;\n return 0;\n } \n}" }, { "path": "GFG/Jump Game/README.md", "content": "# Jump Game\n## Medium \n
\n

Given an positive integer N and a list of N integers A[]. Each element in the array denotes the maximum length of jump you can cover. Find out if you can make it to the last index if you start at the first index of the list.

\n\n


\nExample 1:

\n\n
Input:\nN = 6\nA[] = {1, 2, 0, 3, 0, 0} \nOutput:\n1\nExplanation:\nJump 1 step from first index to\nsecond index. Then jump 2 steps to reach \n4th index, and now jump 2 steps to reach\nthe end.\n
\n\n

Example 2:

\n\n
Input:\nN = 3\nA[] =  {1, 0, 2}\nOutput:\n0\nExplanation:\nYou can't reach the end of the array.\n
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function canReach() which takes a Integer N and a list A of size N as input and returns 1 if the end of the array is reachable, else return 0.

\n\n


\nExpected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 <= N <= 105
\n0 <= A[i] <= 105

\n

\n
" }, { "path": "GFG/Jumping Numbers/Jumping Numbers.cpp", "content": "class Solution {\n public:\n long long jumpingNums(long long x) {\n // code here\n if(x<=9)return x;\n \n queueq;\n \n for(int i=0; i<=9; i++)q.push(i);\n \n int ans = INT_MIN;\n \n while(q.size()>0){\n \n int digit = q.front();\n q.pop();\n \n \n ans = max(ans,digit);\n \n int rem = digit%10;\n \n int num1 = digit*10 + rem - 1;\n \n int num2 = digit*10 + rem + 1;\n \n if(rem == 0){\n if(num2<=x)\n q.push(num2);\n \n }\n \n else if(rem==9){\n if(num1<=x)q.push(num1);\n }\n \n else{\n\n if(num1<=x) q.push(num1);\n\n \n\n if(num2<=x)q.push(num2);\n\n }\n }\n \n return ans;\n }\n};\n" }, { "path": "GFG/Jumping Numbers/README.md", "content": "## Jumping Numbers\n\n\nGiven a positive number X. Find the largest Jumping Number which is smaller than or equal to X. \nJumping Number: A number is called Jumping Number if all adjacent digits in it differ by only 1. All single-digit numbers are considered as Jumping Numbers. For example 7, 8987 and 4343456 are Jumping numbers but 796, 677 and 89098 are not.\n\n \n\n**Example 1:**\n\n```\n\nInput:\nX = 10\n\nOutput:\n10\n\nExplanation:\n10 is the largest Jumping Number\npossible for X = 10.\n\n```\n\n**Example 2:**\n\n```\nInput:\nX = 50\n\nOutput:\n45\n\nExplanation:\n45 is the largest Jumping Number\npossible for X = 50.\n ```\n\n**Your Task:**\nYou don't need to read input or print anything. Your task is to complete the function **jumpingNums()** which takes an Integer X as input and returns the largest Jumping Number less than or equal to X.\n\n \n\nExpected Time Complexity: O(k), where k is no of jumping numbers\nExpected Auxiliary Space: O(k), where k is no of jumping numbers\n\n \n\nConstraints:\n1 <= X <= 109\n" }, { "path": "GFG/K-Ary Tree/README.md", "content": "# K-Ary Tree\n## Easy \n
\n

Find the number of leaf nodes in a full k-ary tree of height m.
\nNote: You have to return the answer module 109+7.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nk = 2, m = 2\nOutput:\n4\nExplanation:\nA full Binary tree of height 2 has 4 leaf nodes.
\n\n

Example 2:

\n\n
Input:\nk = 2, m = 1\nOutput:\n2\nExplanation:\nA full Binary tree of height 1 has 2 leaf nodes.
\n\n

 

\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function karyTree() which takes 2 Integers k, and m as input and returns the number of leaf nodes in a full k-ary Tree.

\n\n

 

\n\n

Expected Time Complexity: O(log(m))
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n1 <= k,m <= 108

\n

\n
" }, { "path": "GFG/Knight Walk/Knight Walk.cpp", "content": "/*\n This code is contributed by:\n - Shubham Kumar Jha (https://github.com/Shubhamjha1710)\n - Adarsh Urmaliya (https://github.com/Satellite-system)\n*/\nclass Solution {\npublic:\n\tint minStepToReachTarget(vector&KnightPos, vector&TargetPos, int N)\n\t{\n\t queue> q;\n\t vector> visit(N+1 , vector(N+1, false));\n\t \n\t q.push({KnightPos[0] , KnightPos[1]});\n\t visit[KnightPos[0]][KnightPos[1]] = 1;\n\t \n\t \n\t int lvl = -1;\n\t vector> dir = {{-1,-2},{-2,-1},{-2,1},{-1,2},{1,-2},{2,-1},{2,1},{1,2}};\n\t while(q.empty() == false)\n\t {\n\t lvl += 1;\n\t int sz = q.size();\n\t for(int k = 0;k= 1 && ny >= 1 && nx <= N && ny <= N) && visit[nx][ny] == false)\n\t {\n\t q.push({nx , ny});\n\t visit[nx][ny] = true;\n\t }\n\t }\n\t }\n\t }\n\t \n\t return -1;\n\t // Code here\n\t}\n};\n\n/*\nAnother Approach : Store the number of steps it taken to each square and from them find the minimum Distance Steps needed to reach Target Position.\nSteps to reach other squares from starting Square could be find By BFS Algorithm, so we will use this Algorithm.\nFirst initialize Stating position as steps 0, now from each position we have total 8 Possible pos(positions), where we could traverse(given that those\nare valid positions, and have never been visited before), and store stps in vector.\nWhenever we encounter the target positon, we return it as we are using BFS algorithm, that's why whenever we react to target position,\nthen that would be our First time when we have reached that position, hence will be in shortest steps.\n*/\n\nclass Solution {\npublic:\n bool isValid(int r, int c, int n){\n if(r<=0 || c<=0 || r>n || c>n) return false;\n return true;\n}\n\tint minStepToReachTarget(vector&KnightPos, vector&TargetPos, int N){\n\t if(KnightPos[0]==TargetPos[0] && KnightPos[1]==TargetPos[1]){\n\t return 0;\n\t }\n\t \n\t queue> st;\n\t vector> dis(N+2, vector(N+2, -1));\n\t \n\t st.push({KnightPos[0], KnightPos[1]});\n\t dis[KnightPos[0]][KnightPos[1]] = 0;\n\t \n\t vector> pos={{1,2}, {2,1}, {-1,2}, {1,-2}, {-1,-2}, {-2,-1}, {-2,1}, {2,-1}};\n\t \n\t while(!st.empty()){\n\t pair tp = st.front();\n\t st.pop();\n \t \n\t \n\t for(int j=0;j<8; ++j){\n\t int nr = tp.first + pos[j][0], nc = tp.second+pos[j][1];\n\t \n \t if(isValid(nr, nc, N) && dis[nr][nc]==-1){\n \t st.push({nr, nc});\n \t dis[nr][nc] = 1 + dis[tp.first][tp.second];\n \t }\n \t if(nr==TargetPos[0] && nc==TargetPos[1])\n \t return 1 + dis[tp.first][tp.second];\n\t }\n \t \n\t }\n\t \n\t return dis[TargetPos[0]][TargetPos[1]];\n\t}\n};\n" }, { "path": "GFG/Knight Walk/Knight Walk.java", "content": "class Pair{\n int i;\n int j;\n int dist;\n Pair(int i,int j,int d){\n this.i=i;\n this.j=j;\n this.dist=d;\n }\n}\nclass Solution\n{\n public int minStepToReachTarget(int KnightPos[], int TargetPos[], int N)\n {\n // Code here\n int[] x=new int[]{1,1,2,2,-1,-1,-2,-2};\n int[]y=new int[]{2,-2,1,-1,2,-2,1,-1};\n \n Queue q=new LinkedList<>();\n q.add(new Pair(KnightPos[0],KnightPos[1],0));\n boolean [][]vis=new boolean[N+1][N+1];\n vis[KnightPos[0]][KnightPos[1]]=true;\n while(q.size()>0){\n int sz=q.size();\n while(sz-->0){\n Pair curr=q.remove();\n int i=curr.i;\n int j=curr.j;\n int dist=curr.dist;\n if(i==TargetPos[0] && j==TargetPos[1])return dist;\n for(int k=0;k<8;k++){\n if(isValid(i+x[k],j+y[k],vis,N)){\n q.add(new Pair(i+x[k],j+y[k],dist+1));\n vis[i+x[k]][j+y[k]]=true;\n }\n }\n }\n }\n return -1;\n }\n boolean isValid(int i,int j,boolean[][]vis,int N){\n if(i<1 || j<1 || i>N || j>N || vis[i][j]){\n return false;\n }\n return true;\n }\n}\n" }, { "path": "GFG/Kth smallest element/Kth smallest element.py", "content": "#User function Template for python3\nimport heapq\n\nclass Solution:\n def kthSmallest(self,arr, l, r, k):\n '''\n arr : given array\n l : starting index of the array i.e 0\n r : ending index of the array i.e size-1\n k : find kth smallest element and return using this function\n '''\n heap = []\n for i in arr:\n heapq.heappush(heap, i)\n for i in range(k-1):\n heapq.heappop(heap)\n return heapq.heappop(heap)\n\n#{ \n# Driver Code Starts\n#Initial Template for Python 3\n\n#contributed by RavinderSinghPB\nif __name__ == '__main__': \n import random \n t=int(input())\n for tcs in range(t):\n n=int(input())\n arr=list(map(int,input().strip().split()))\n k=int(input())\n ob=Solution()\n print(ob.kthSmallest(arr, 0, n-1, k))\n \n# } Driver Code Ends\n" }, { "path": "GFG/LCM Triplet/LCM Triplet.java", "content": "class Solution {\n long lcmTriplets(long N) {\n // code here\n if(N<=2)return N;\n if((N&1)==1)return N*(N-1)*(N-2);\n if(N%3==0)return (N-1)*(N-3)*(N-2);\n return N*(N-1)*(N-3);\n }\n}\n" }, { "path": "GFG/Largest subtree sum in a tree/Largest subtree sum in a tree.cpp", "content": "class Solution {\n public:\n int subtree(Node* root, int& ans){\n if(root==NULL){\n return 0;\n }\n int lsum = subtree(root->left,ans);\n int rsum = subtree(root->right,ans);\n int tot = root->data + lsum + rsum;\n ans = max(ans,tot);\n return tot;\n }\n int findLargestSubtreeSum(Node* root){\n int ans = INT_MIN;\n subtree(root,ans);\n return ans;\n \n }\n};\n" }, { "path": "GFG/Largest subtree sum in a tree/Largest subtree sum in a tree.java", "content": "class Solution {\n static int ans;\n public static int findLargestSubtreeSum(Node root) {\n // code here\n ans=Integer.MIN_VALUE;\n dfs(root);\n return ans;\n }\n static int dfs(Node root){\n int sum=root.data;\n if(root.left!=null){\n sum+=dfs(root.left);\n }\n if(root.right!=null){\n sum+=dfs(root.right);\n }\n ans=Math.max(ans,sum);\n return sum;\n }\n}\n" }, { "path": "GFG/Last modified ball/Last modified ball.java", "content": "class Solution {\n int solve(int N, int[] A) {\n // code here\n for(int i=N-1;i>=0;i--){\n if(A[i]<9)return i+1;\n }\n return -1;\n }\n};\n" }, { "path": "GFG/Longest Bitonic subsequence/Longest Bitonic subsequence.java", "content": "class Solution\n{\n public int LongestBitonicSequence(int[] nums)\n {\n // Code here\n int n=nums.length;\n int[]inc=new int[n];\n for(int i=0;i=0;j--){\n if(nums[j]inc[i]){\n inc[i]=inc[j]+1;\n }\n }\n }\n int[]dec=new int[n];\n for(int i=n-1;i>=0;i--){\n dec[i]=1;\n for(int j=i+1;jdec[i]){\n dec[i]=dec[j]+1;\n }\n }\n }\n \n int ans=0;\n for(int i=0;i max=new PriorityQueue<>(Collections.reverseOrder());\n PriorityQueue min=new PriorityQueue<>();\n int ans=0;\n for(int i=0,j=0;i1){\n min.remove(arr[j]);\n max.remove(arr[j]);\n j++;\n }\n \n ans=Math.max(ans,i-j+1);\n }\n return ans;\n \n }\n};\n" }, { "path": "GFG/Magic Triplets/Magic Triplets.java", "content": "class Solution{\n public int countTriplets(int[] nums){\n // code here\n int ans=0;\n int n=nums.length;\n for(int j=1;j=0;i--){\n if(nums[i]nums[j])larger++;\n }\n ans+=smaller*larger;\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Majority Element/Majority Element.java", "content": "//Boyer-Moore Voting Algorithm\n\nclass Solution {\n public int majorityElement(int[] nums) {\n int count = 0;\n Integer candidate = null;\n\n for (int num : nums) {\n if (count == 0) {\n candidate = num;\n }\n count += (num == candidate) ? 1 : -1;\n }\n\n return candidate;\n }\n}\n\n//=================================================================\n\n//recursive\nclass Solution {\n\npublic int majorityElement(int[] nums) {\n return recurse(nums, 0);\n }\n \n public int recurse(int[] nums, int start){\n int n = nums.length;\n int tracker= 1;\n for(int i=start+1;i map=new HashMap<>();\n for(int i=0;i n // 2):\n return majorityNum\n else:\n return -1" }, { "path": "GFG/Majority Element/README.md", "content": "# Majority Element\n\n### Medium\n\nGiven an array **A** of **N** elements. Find the majority element in the array. A majority element in an array A of size N is an **element that appears more than N/2 times in the array.**\n\n### Example 1:\n
\nInput:\nN = 3 \nA[] = {1,2,3} \nOutput:\n-1\nExplanation:\nSince, each element in \n{1,2,3} appears only once so there \nis no majority element.\n
\n\n### Example 2:\n
\nInput:\nN = 5 \nA[] = {3,1,3,3,2} \nOutput:\n3\nExplanation:\nSince, 3 is present more\nthan N/2 times, so it is \nthe majority element.\n
\n\n\n\n**Your Task:**\nThe task is to complete the function **majorityElement()** which returns the majority element in the array. If no majority exists, return -1.\n \n\n\n**Expected Time Complexity:** O(N).\n\n**Expected Auxiliary Space:** O(1).\n \n\n\n**Constraints:**\n\n1 ≤ N ≤ 107\n\n0 ≤ Ai ≤ 106" }, { "path": "GFG/Make array elements unique/Make array elements unique.java", "content": "class Solution {\n public long minIncrements(int[] arr, int N) {\n // Code here\n Arrays.sort(arr);\n int ans=0;\n for(int i=1;i=arr[i]){\n ans+=arr[i-1]-arr[i]+1;\n arr[i]=arr[i-1]+1;\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Max Min/Max Min.cpp", "content": "class Solution\n{\n public:\n int findSum(int A[], int N)\n {\n \t//code here.\n \t\n \tint maxVal=INT_MIN;\n \tint minVal=INT_MAX;\n \tfor(int i=0;iA[x]):min=A[x]\n if(max

Given an array A of size N of integers. Your task is to find the sum of minimum and maximum element in the array.

\n\n

Example 1:

\n\n
Input:\nN = 5\nA[] = {-2, 1, -4, 5, 3}\nOutput: 1\nExplanation: min = -4, max =  5. Sum = -4 + 5 = 1
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 4\nA[]  = {1, 3, 4, 1}\nOutput: 5\nExplanation: min = 1, max = 4. Sum = 1 + 4 = 5\n
\n\n

 

\n\n

Your Task:  
\nYou don't need to read input or print anything. Your task is to complete the function findSum() which takes the array A[] and its size N as inputs and returns the summation of minimum and maximum element of the array.

\n\n

 

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n1 <= N <= 105
\n-109 <= Ai <= 109

\n\n" }, { "path": "GFG/Maximize the sum of selected numbers from an array to make it empty/Maximize the sum of selected numbers from a sorted array to make it empty.cpp", "content": "class Solution{\n public:\n int maximizeSum(int a[], int n) \n {\n // Complete the function\n \n unordered_map ans;\n int sum=0;\n bool arr[n];\n for(int i=0;i=0;i--)\n {\n if(arr[i] == false)\n {\n arr[i]=true;\n sum+= a[i];\n if(ans[a[i]-1] > 0)\n {\n arr[i-ans[a[i]]]=true;\n ans[a[i]-1]--;\n }\n }\n }\n return sum;\n }\n\n};\n" }, { "path": "GFG/Maximize the sum of selected numbers from an array to make it empty/Maximize the sum of selected numbers from an array to make it empty.java", "content": "class Complete{\n \n \n // Function for finding maximum and value pair\n public static int maximizeSum (int arr[], int n) {\n //Complete the function\n int[] map=new int[100001];\n for(int x:arr){\n map[x]++;\n }\n int sum=0;\n for(int i=n-1;i>=0;i--){\n int curr=arr[i];\n if(map[curr]!=0){\n sum+=curr;\n map[curr]--;\n if(map[curr-1]!=0){\n map[curr-1]--;\n }\n }\n \n }\n return sum;\n }\n \n \n" }, { "path": "GFG/Maximize the sum of selected numbers from an array to make it empty/README.md", "content": "## Maximize the sum of selected numbers from a sorted array to make it empty\n\n\n\n\nGiven a array of N numbers, we need to maximize the sum of selected numbers. At each step, you need to select a number Ai, delete one occurrence of Ai-1 (if exists), and Ai each from the array. Repeat these steps until the array gets empty. The problem is to maximize the sum of the selected numbers.\n\n**Note:** Numbers need to be selected from maximum to minimum.\n\n```\nExample 1:\n\nInput : arr[ ] = {1, 2, 2, 2, 3, 4}\n\nOutput : 10\n\nExplanation:\nWe select 4, so 4 and 3 are deleted leaving us with {1,2,2,2}.\nThen we select 2, so 2 & 1 are deleted. We are left with{2,2}.\nWe select 2 in next two steps, thus the sum is 4+2+2+2=10.\n```\n\n```\nExample 2:\n\nInput : arr[ ] = {1, 2, 3} \n\nOutput : 4\n\nExplanation: We select 3, so 3 and 2 are deleted leaving us with {1}.\nThen we select 1, 0 doesn't exist so we delete 1. thus the sum is 3+1=4.\n``` \n\n**Your Task:**\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function **maximizeSum()** that takes an array (arr), sizeOfArray (n), and return the maximum sum of the selected numbers. The driver code takes care of the printing.\n\n**Expected Time Complexity:** O(N).\n**Expected Auxiliary Space:** O(N).\n\n\n**Constraints:**\n1 ≤ N ≤ 105\n1 ≤ A[i] ≤ 105\n" }, { "path": "GFG/Maximum Number of Toys/Maximum Number of Toys.java", "content": "// Nlogn + Q(K + logN)\n\nclass Pair{\n private K cost;\n private V index;\n public Pair(K a,V b){\n this.cost=a;\n this.index=b;\n }\n public K getCost(){\n return this.cost;\n }\n public V getIndex(){\n return this.index;\n }\n}\n\n\nclass Solution {\n ArrayList maximumToys(int N, int A[],\n int Q, ArrayList Queries[]){\n ArrayList> arr=new ArrayList<>(N);\n for(int i=0;i(A[i],i));\n }\n \n Collections.sort(arr,(a,b)->a.getCost()-b.getCost());//Nlogn\n \n HashMap map=new HashMap<>();\n for(int i=0;i res=new ArrayList<>(Q);\n \n for(int i=0;i damaged=new HashSet<>();\n for(int j=0;j=arr.get(s).getCost()){\n if(!damaged.contains(s)){\n ans++;\n rem-=arr.get(s).getCost();\n }\n s++;\n }\n res.add(ans);\n }\n return res;\n }\n}\n" }, { "path": "GFG/Maximum Profit By Choosing A Subset Of Intervals/Maximum Profit By Choosing A Subset Of Intervals.java", "content": "class Solution {\n public static int maximum_profit(int n, int[][] arr) {\n // code here\n Arrays.sort(arr,(a,b)->{\n if(a[0]!=b[0]) return a[0]-b[0];\n return a[1]-b[1];\n });\n int[]dp=new int[n];\n return rec(0,arr,n,dp);\n }\n static int rec(int index,int[][]arr,int n,int[]dp){\n if(index>=n)return 0;\n if(dp[index]!=0)return dp[index];\n int not_select=rec(index+1,arr,n,dp);\n int nextIndex = findNext(index+1,arr[index][1],arr,n);\n int select = arr[index][2] + rec(nextIndex,arr,n,dp);\n return dp[index]=Math.max(select,not_select);\n }\n static int findNext(int i,int prevEnd,int[][]arr,int n){\n while(i=prevEnd){\n break;\n }else{\n i++;\n }\n }\n return i;\n }\n}\n" }, { "path": "GFG/Maximum Sub Array/Maximum Sub Array.java", "content": "class Solution {\n\n ArrayList findSubarray(int a[], int n) {\n // code here\n int maxSum=0;\n int maxStart=0;\n int maxEnd=0;\n int currSum=0;\n int currStart=0;\n for(int i=0;imaxSum){\n maxSum=currSum;\n maxStart=currStart;\n maxEnd=i+1;\n }else if(currSum==maxSum){\n int currDis=i+1-currStart;\n int maxDis=maxEnd-maxStart;\n if(currDis>maxDis){\n maxStart=currStart;\n maxEnd=i+1;\n }\n }\n \n }\n \n ArrayList ans=new ArrayList<>();\n for(int i=maxStart;itemp(26);\n\t\t for(int i=0;ik){\n\t\t temp[s[l]-'A']--;\n\t\t l++;\n\t\t }\n\t\t else ans = max(ans,i-l+1);\n\t\t }\n\t\t return ans;\n\t\t}\n\n};\n" }, { "path": "GFG/Maximum Sub-String after at most K changes/Maximum Sub-String after at most K changes.java", "content": "class Solution\n{\n public int characterReplacement(String s, int k)\n {\n // code here\n int[]arr=new int[26];\n int prev=0;\n int ans=0;\n for(int i=0;isame){\n diff+=same;\n same=i;\n }else{\n diff+=i;\n }\n }\n return diff<=k? same+diff : -1;\n }\n}\n" }, { "path": "GFG/Maximum Sub-String after at most K changes/README.md", "content": "## Maximum Sub-String after at most K changes\n\n\nWe have a string s of length n, which contains only UPPERCASE characters and we have a number k (always less than n). We can make at most k changes in our string. In one change, you can replace any s[i] (0<= i < n) with any uppercase character (from 'A' to 'Z'). After k changes, find the maximum possible length of the sub-string which have all same characters.\n\n**Example 1:**\n\n```\nInput: s = \"ABAB\", k = 2\nOutput: 4\nExplanation: Change 2 'B' into 'A'. \nNow s = \"AAAA\"\n\n```\n\nExample:2\n\n```\n\nInput: s = \"ADBD\", k = 1\nOutput: 3\nExplanation: Change 'B' into 'D'.\nNow s = \"ADDD\"\n```\n***\n\n**Your Task:**\nYou don't need to read or print anything. Your task is to complete the function **characterReplacement()** which takes s and k as input parameters and returns the maximum length of sub-string after doing k changes.\n \n\n**Expected Time Complexity:** O(n)\n**Expected Space Complexity:** O(26)\n" }, { "path": "GFG/Maximum Sum LCM/Maximum Sum LCM.java", "content": "//User function Template for Java\nclass Solution {\n static long maxSumLCM(int n) {\n // code here\n long ans=0;\n for(int i=1;i<=(int)Math.sqrt(n);i++){\n if(n%i==0){\n ans+=i;\n if(n/i!=i)ans+=(n/i);\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Maximum Value/Maximum Value.java", "content": "class Solution {\n ArrayList maximumValue(Node node) {\n //code here\n Queue q=new LinkedList<>();\n ArrayList ans=new ArrayList<>();\n q.add(node);\n while(!q.isEmpty()){\n int currLevelSize = q.size();\n int max=0;\n while(currLevelSize-->0){\n Node curr=q.remove();\n max=Math.max(max,curr.data);\n if(curr.left!=null)q.add(curr.left);\n if(curr.right!=null)q.add(curr.right);\n }\n ans.add(max);\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Maximum of all subarrays of size k/Maximum of all subarrays of size k.java", "content": "class Solution\n{\n //Function to find maximum of each subarray of size k.\n static ArrayList max_of_subarrays(int arr[], int n, int k)\n {\n // Your code here\n Deque q=new ArrayDeque<>();\n for(int i=0;i0 && q.peekLast() ans =new ArrayList<>();\n ans.add(q.peekFirst());\n int x=0;\n for(int i=k;i0 && q.peekLast()max)max=matrix[i][C-1];\n }\n \n int desired=(R*C +1)/2;\n \n while(min=r){\n return;\n }\n int mid = l + (r-l)/2;\n mergeSort(arr,l,mid);\n mergeSort(arr,mid+1,r);\n merge(arr,l,mid,r);\n }\n}\n" }, { "path": "GFG/Merge two BST 's/Merge two BST.cpp", "content": "\n//This Approch uses Recursuion \n\nclass Solution\n{\n public:\n //Function to return a list of integers denoting the node \n //values of both the BST in a sorted order.\n void inorder1(Node* root, vector &v1){\n if(root){\n inorder1(root->left,v1);\n v1.push_back(root->data);\n inorder1(root->right,v1);\n }\n }\n \n //calling Inorder\n void inorder2(Node* root, vector &v1){\n if(root){\n inorder2(root->left,v1);\n v1.push_back(root->data);\n inorder2(root->right,v1);\n }\n }\n vector merge(Node *root1, Node *root2)\n {\n vector v1;\n inorder1(root1,v1);//we are calling this inorder to add all the element in the main vector so that at the end we get a sorted array by merging both element in the main vector\n inorder2(root2,v1);\n sort(v1.begin(),v1.end());\n return v1;\n }\n};\n" }, { "path": "GFG/Min operations/Min operations.java", "content": "class Solution {\n\n public static int solve(int a, int b) {\n\n // code here\n\n if(a==b)return 0;\n\n if((a & b) == a || (a & b) == b)return 1;\n\n return 2;\n\n }\n\n} \n" }, { "path": "GFG/Minimize number of Students to be removed/Minimize number of Students to be removed.java", "content": "class Solution {\n public int removeStudents(int[] H, int n) {\n // code here\n ArrayList dp=new ArrayList<>();\n for(int i=0;i arr){\n int l=0;\n int h=arr.size()-1;\n while(l<=h){\n int mid=(l+h)/2;\n if(arr.get(mid)>=ele){\n h=mid-1;\n }else{\n l=mid+1;\n }\n }\n return l;\n }\n};\n" }, { "path": "GFG/Minimize the sum/Minimize the sum.java", "content": "class Solution {\n long minimizeSum(int N, int arr[]) {\n // code here\n long ans=0;\n PriorityQueue pq=new PriorityQueue<>();\n for(int i:arr){\n pq.add(i);\n }\n while(pq.size()>1){\n int curr=pq.remove()+pq.remove();\n ans+=curr;\n pq.add(curr);\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Minimum Cost of ropes/Minimum Cost of ropes.java", "content": "class Solution\n{\n //Function to return the minimum cost of connecting the ropes.\n long minCost(long arr[], int n) \n {\n // your code here\n long cost = 0;\n if(n < 2){\n return cost;\n }\n PriorityQueue pq = new PriorityQueue();\n for(int i = 0; i < n; i++){\n pq.add(arr[i]);\n }\n while(true){\n long first = pq.peek();\n pq.remove();\n long second = pq.peek();\n pq.remove();\n long temp = first + second;\n cost = cost + temp;\n if(pq.isEmpty()){\n break;\n }\n pq.add(temp);\n }\n return cost;\n }\n}\n" }, { "path": "GFG/Minimum Costs of Ropes/Minimum Costs of Ropes.cpp", "content": "#include \nusing namespace std;\n\nclass Solution\n{\n public:\n //Function to return the minimum cost of connecting the ropes.\n long long minCost(long long arr[], long long n) {\n // Your code here\n if(n==1) return 0; // base case if 1 rope is only given then we don't have to add so return 0\n \n priority_queue, greater> pq; // taking priority_queue in main_heap\n for(int i=0; i1){\n // getting 1st elem mini from top and popping out from priority_queue\n long long x = pq.top(); pq.pop();\n // getting 2nd elem mini from top and popping out from priority_queue\n long long y = pq.top(); pq.pop();\n // adding 1st mini and 2nd mini\n res+=(x+y);\n // pushing to Priority queue to add with other numbers also\n pq.push(x+y);\n }\n return res;\n // TC: O(N log N) -> pq takes log n and loop is running for n times so it becomes nlogn\n // SC: O(N) - pq is taking N Space to store\n }\n};\nint main() {\n long long t;\n cin >> t;\n while (t--) {\n long long n;\n cin >> n;\n long long i, a[n];\n for (i = 0; i < n; i++) {\n cin >> a[i];\n }\n Solution ob;\n cout << ob.minCost(a, n) << endl;\n }\n return 0;\n}" }, { "path": "GFG/Minimum characters to be added at front to make string palindrome/Minimum characters to be added at front to make string palindrome oc2.cpp", "content": "#include\nusing namespace std;\nclass Solution {\npublic:\n int minChar(string str){\n //Write your code here\n int i =0, j = str.length()-1;\n int temp_j =j, res =0; \n while(i <=j){\n // to check curr with reverse, if matches incr\n if(str[i]== str[j]){\n i++; j--;\n }else{\n // otherwise\n res++;\n i=0;\n j=--temp_j;\n }\n }\n return res;\n }\n};\nint main()\n{\n\tint t;\n\tcin>>t;\n\twhile(t--)\n\t{\n\t string str;\n\t cin >> str;\n\t Solution ob;\n\t int ans = ob.minChar(str);\n\t cout << ans< minPartition(int N)\n {\n vector v;\n \n if(N>=2000){\n int cnt = N/2000;\n for(int i=0;i=500){\n int cnt = N/500;\n for(int i=0;i=200){\n int cnt = N/200;\n for(int i=0;i=100){\n int cnt = N/100;\n for(int i=0;i=50){\n int cnt = N/50;\n for(int i=0;i=20){\n int cnt = N/20;\n for(int i=0;i=10){\n int cnt = N/10;\n for(int i=0;i=5){\n int cnt = N/5;\n for(int i=0;i=2){\n int cnt = N/2;\n for(int i=0;i=1){\n int cnt = N;\n for(int i=0;i minPartition(int N)\n {\n // code here\n int[]a=new int[]{1,2,5,10,20,50,100,200,500,2000};\n List ans=new ArrayList<>();\n int i=9;\n while(i>=0){\n if(a[i]>N){\n i--;\n }else{\n while(N>=a[i]){\n ans.add(a[i]);\n N-=a[i];\n }\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Minimum sum partition/Minimum sum partition.cpp", "content": "\n};\n" }, { "path": "GFG/Minimum sum partition/Minimum sum partition.java", "content": "class Solution\n{\n\n\tpublic int minDifference(int arr[], int n) \n\t{ \n\t // Your code goes here\n\t Map map=new HashMap<>();\n\t return dfs(arr,n-1,0,0,map);\n\t} \n\tpublic int dfs(int[]arr,int n,int s1,int s2,Map map){\n\t if(n<0){\n\t return Math.abs(s1-s2);\n\t }\n\t String key=n+\",\"+s1;\n\t if(!map.containsKey(key)){\n\t int first=dfs(arr,n-1,s1+arr[n],s2,map);\n\t int sec=dfs(arr,n-1,s1,s2+arr[n],map);\n\t map.put(key,Math.min(first,sec));\n\t }\n\t return map.get(key);\n\t}\n}\n" }, { "path": "GFG/Minimum sum partition/README.md", "content": "## Minimum sum partition\n\n\nGiven an array arr of size n containing non-negative integers, the task is to divide it into two sets S1 and S2 such that the absolute difference between their sums is minimum and find the minimum difference\n\n\n**Example 1:**\n\n```\nInput: N = 4, arr[] = {1, 6, 11, 5}\n\nOutput: 1\n\nExplanation: \nSubset1 = {1, 5, 6}, sum of Subset1 = 12 \nSubset2 = {11}, sum of Subset2 = 11 \n```\n\n**Example 2:**\n\n```\nInput: N = 2, arr[] = {1, 4}\n\nOutput: 3\n\nExplanation: \nSubset1 = {1}, sum of Subset1 = 1\nSubset2 = {4}, sum of Subset2 = 4\n```\n\n**Your Task:** \n\nYou don't need to read input or print anything. Complete the function **minDifference()** which takes N and array arr as input parameters and returns the integer value\n\n\n**Expected Time Complexity:** O(N*|sum of array elements|)\n**Expected Auxiliary Space:** O(N*|sum of array elements|)\n\n\n**Constraints:**\n1 ≤ N*|sum of array elements| ≤ 106\n0 < arr[i] <= 105\n" }, { "path": "GFG/Missing number in matrix.java/Missing number in matrix.java", "content": "class Solution\n{\n public long MissingNo(int[][] mat)\n {\n // code here\n int n=mat.length;\n int x=-1;\n int y=-1;\n long rowSum[]=new long[n];\n long colSum[]=new long[n];\n long leftDia=0;\n long rightDia=0;\n \n for(int i=0;i=l) {\n if(f[i]==0) ans+=i;\n else ans+=f[i];\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Modified Numbers and Queries/Modified Numbers and Queries oc3.cpp", "content": "#include \nusing namespace std;\n\nclass Solution {\n private:void Sieve(vector &Primes, int n){\n Primes[1]=1;\n for(int i =2; i<=n; i++)\n if(Primes[i] ==0)\n for(int j =i; j<=n; j+=i)\n Primes[j]+=i;\n };\n public:\n int sumOfAll(int l, int r){\n // code here\n vectorPrimes(r+1, 0);\n Sieve(Primes, r);\n int sum=0;\n for(int i =l; i<=r; i++)\n sum+=Primes[i];\n return sum;\n }\n};\nint main() {\n int t;\n cin >> t;\n while (t--) {\n int l, r;\n cin>>l>>r;\n Solution ob;\n cout<1, 2->2 and 1+2=3. \n\n```\n\n## Example 2:\n\n```\nInput:\nl = 1, r = 6\n\nOutput: 18\n\nExplanation:1->1, 2->2, 3->3, 4->2\n5->5, 6->2+3=5, 1+2+3+2+5+5 = 18. \n\n```\n\n**Your Task:**\nYou dont need to read input or print anything. Complete the function **sumOfAll()** which takes l and r as input parameter and returns sum all the numbers ( as represented ) in the given range both L and R included.\n\n**Expected Time Complexity:** O(nloglogn)\n\n**Expected Auxiliary Space:** O(N)\n\n**Constraints:**\n\n1 <= l <= r <=104\n\n" }, { "path": "GFG/Move Last Element to Front of a Linked List/Move Last Element to Front of a Linked List 2 different approaches.java", "content": "First Approach:\n\nTime Complexity:O(N)\nAuxiliary Space:O(N)\n \n \nCode:\n\n\nclass Solution {\n public static Node moveToFront(Node head) {\n if(head==null || head.next==null){\n return head;\n }\n \n ArrayListaa=new ArrayList();\n Node temp=head;\n while(temp!=null){\n aa.add(temp.data);\n temp=temp.next;\n }\n int a=aa.get(aa.size()-1);\n aa.remove(aa.size()-1);\n aa.add(0,a);\n Node temp2=new Node(-1);\n Node temp3=temp2;\n \n for(int a1:aa){\n temp2.next=new Node(a1);\n temp2=temp2.next;\n }\n \n return temp3.next;\n \n }\n}\n\n\n\n\n=======================================================================================================================================================================\n \n\nSecond Approach:\n\nTime Complexity:O(N)\nAuxiliary Space:O(1)\n \n\nCode:\n\nclass Solution {\n public static Node moveToFront(Node head) {\n if(head==null){\n return null;\n }\n else if(head.next==null){\n return head;\n }\n Node temp=head;\n Node prev=null;\n Node current=head;\n while(current.next!=null){\n prev=current;\n current=current.next;\n }\n current.next=head;\n prev.next=null;\n return current;\n }\n}\n \n\n\n\n\n\n" }, { "path": "GFG/Move Last Element to Front of a Linked List/Move Last Element to Front of a Linked List.cpp", "content": "class Solution{\npublic:\n ListNode *moveToFront(ListNode *head){\n \n if(head->next == NULL) return head;\n \n ListNode *temp = head;\n \n while(head->next->next!=NULL)\n \n head = head->next;\n head->next->next = temp;\n temp = head->next;\n head->next = NULL;\n \n return temp;\n \n }\n};\n" }, { "path": "GFG/Move Last Element to Front of a Linked List/Move Last Element to Front of a Linked List.java", "content": "class Solution {\n public static Node moveToFront(Node head) {\n // code here\n if(head.next==null)return head;\n Node temp=head;\n while(temp.next.next!=null){\n temp=temp.next;\n }\n Node last=temp.next;\n temp.next=null;\n last.next=head;\n return last;\n }\n}\n" }, { "path": "GFG/Move Last Element to Front of a Linked List/README.md", "content": "## Move Last Element to Front of a Linked List\n\n\nYou are given the head of a Linked List. You have to move the last element to the front of the Linked List and return the list.\n\n \n\n**Example 1:**\n\n```\nInput:\nN = 5\n\nList = {2,5,6,2,1}\n\nOutput:\n{1,2,5,6,2}\n\nExplanation:\nIn the given linked list, the last element is 1,\nafter moving the last element to the front the\nlinked list will be {1,2,5,6,2}.\n \n```\n\n**Example 2:**\n\n```\nInput:\nN = 1\n\nList = {2}\n\nOutput:\n{2}\n\nExplanation:\nHere 2 is the only element so, the linked list\nwill remain the same.\n \n```\n\n***\n\n**Your Task:**\n\nYou don't need to read input or print anything. Your task is to complete the function **moveToFront()** which takes the address of the head of the linked list and returns the modified linked list.\n\n \n\n**Expected Time Complexity:** O(N)\n**Expected Auxiliary Space:** O(1)\n\n \n\n**Constraints:**\n1 <= N <= 105\n0 <= Elements of List <= 109\nSum of N over all test cases doesn't exceeds 106\n" }, { "path": "GFG/Next Greater Element/Next Greater Element.java", "content": "class Solution{\n public static long[] nextLargerElement(long[] arr, int n) { \n // Your code here\n long[]ans=new long[n];\n Stack st=new Stack<>();\n for(int i=n-1;i>=0;i--){\n while(!st.isEmpty() && st.peek() ar=new ArrayList();\n if(isHappyNumber(i, ar))\n {\n return i;\n }\n }\n return -1;\n }\n public static boolean isHappyNumber(int n, ArrayList ar)\n {\n if(ar.contains(n))\n {\n return false;\n }\n if(n==1)\n {\n return true;\n }\n ar.add(n);\n n=findSquareNumber(n);\n boolean res=isHappyNumber(n, ar);\n return res;\n }\n public static int findSquareNumber(int n)\n {\n int newNumber=0;\n while(n>0)\n {\n int rem=n%10;\n newNumber+=(rem*rem);\n n=n/10;\n }\n return newNumber;\n }\n}\n" }, { "path": "GFG/Nine Divisors/Nine Divisors.cpp", "content": "class Solution{ \npublic:\n long long int nineDivisors(long long int N){\n //Code Here\n if(N < 36) return 0;\n \n long long size = sqrt(N);\n \n long long count = 0;\n \n vector sieve(size+1);\n \n for(int i = 1; i <= size; i++)\n {\n sieve[i] = i;\n }\n \n for(long long i = 2; i*i <= size; i++)\n {\n if(sieve[i] != i) continue;\n for(long long j = i*i; j <= size; j+=i)\n {\n if(sieve[j] == j)\n sieve[j] = i;\n }\n }\n \n for(long long i = 2; i <= size; i++)\n {\n long long p = sieve[i];\n \n long long q = sieve[i/p];\n \n if((p!=q && p*q == i && q !=1) || (sieve[i] == i && pow(i,8) <= N))\n {\n count++;\n }\n }\n return count;\n }\n};\n" }, { "path": "GFG/Nine Divisors/Nine Divisors.java", "content": "class Solution{\n static long nineDivisors(long N){\n //Code Here\n long ans=0;\n int size=(int)Math.sqrt(N);\n int prime[]=new int[size+1];\n for(int i=1;i<=size;i++){\n prime[i]=i;\n }\n \n //fill sieve\n for(int i=2;i*i<=size;i++){\n if(prime[i]==i){\n for(int j=i*i;j<=size;j+=i){\n if(prime[j]==j){\n prime[j]=i;\n }\n }\n }\n }\n //check for root n\n for(int i=2;i<=size;i++){\n int p=prime[i];\n \n int q=prime[i/p];\n \n if((p!= q && p*q==i && q!=1) ||\n (prime[i]==i && Math.pow(i,8)<=N)){\n ans+=1;\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Number Formation/Number Formation.cpp", "content": "class Solution {\n\n \n\n public:\n const int mod=1e9+7;\n int getSum(int X, int Y, int Z) {\n // Your code goes here\n long long exactsum[X+1][Y+1][Z+1],exactnum[X+1][Y+1][Z+1];\n for (int i = 0; i <=X; i++){\n for (int j = 0; j <= Y; j++) {\n for (int k = 0; k <= Z; k++) {\n exactsum[i][j][k] = 0;\n exactnum[i][j][k] = 0;\n }\n }\n }\n long long ans=0;\n exactnum[0][0][0] = 1LL;\n for (int i = 0; i <= X; ++i){\n for (int j = 0; j <= Y; ++j){\n for (int k = 0; k <= Z; ++k) {\n if (i > 0){\n exactsum[i][j][k] += (exactsum[i - 1][j][k] * 10 + 4 * exactnum[i - 1][j][k]) % mod;\n exactnum[i][j][k] += exactnum[i - 1][j][k] % mod;\n }\n if (j > 0) {\n exactsum[i][j][k] += (exactsum[i][j - 1][k] * 10 + 5 * exactnum[i][j - 1][k]) % mod;\n exactnum[i][j][k] += exactnum[i][j - 1][k] % mod;\n }\n if (k>0){\n exactsum[i][j][k] += (exactsum[i][j][k-1] * 10 + 6 * exactnum[i][j][k-1]) % mod;\n exactnum[i][j][k] += exactnum[i][j][k-1] % mod;\n }\n ans+=exactsum[i][j][k]%mod;\n ans=ans%mod;\n }\n }\n }\n return ans;\n }\n};\n\n" }, { "path": "GFG/Number Formation/Number Formation.java", "content": "class Solution {\n\n public int getSum(int X, int Y, int Z) {\n // Your code goes here\n int mod=1000000007;\n long[][][] exactSum=new long[X+1][Y+1][Z+1];\n long[][][] num=new long[X+1][Y+1][Z+1];\n num[0][0][0]=1L;\n \n long ans=0L;\n for(int i=0;i<=X;i++){\n for(int j=0;j<=Y;j++){\n for(int k=0;k<=Z;k++){\n if(i>0){\n exactSum[i][j][k]+=(exactSum[i-1][j][k]*10 +4*num[i-1][j][k])%mod;\n num[i][j][k]+=num[i-1][j][k]%mod;\n }\n if(j>0){\n exactSum[i][j][k]+=(exactSum[i][j-1][k]*10 +5*num[i][j-1][k])%mod;\n num[i][j][k]+=num[i][j-1][k]%mod;\n }\n if(k>0){\n exactSum[i][j][k]+=(exactSum[i][j][k-1]*10 +6*num[i][j][k-1])%mod;\n num[i][j][k]+=num[i][j][k-1]%mod;\n }\n ans+=exactSum[i][j][k]%mod;\n ans%=mod;\n }\n }\n }\n return (int)ans;\n }\n}\n" }, { "path": "GFG/Number Formation/README.md", "content": "## Number Formation\n\nGiven three integers x, y, and z, the task is to find the sum of all the numbers formed by \nhaving 4 at most x times, having 5 at most y times, and having 6 at most z times as a digit.\n\n**Note:** Output the sum modulo 109+7.\n\n**Example 1:**\n\n```\nInput: X = 1, Y = 1, Z = 1 \n\nOutput: 3675\n\nExplanation: 4 + 5 + 6 + 45 + 54 + 56 \n+ 65 + 46 + 64 + 456 + 465 \n+ 546 + 564 + 645 + 654 = 3675\n```\n**Example 2:**\n\n```\nInput: X = 0, Y = 0, Z = 0\n\nOutput: 0\n\nExplanation: No number can be formed\n\n```\n\n***\n\n**Your Task:** \nYou don't need to read input or print anything. Complete the function **getSum()** which takes X, Y and Z as input parameters and returns the integer value\n\n**Expected Time Complexity:** O(X*Y*Z)\n**Expected Auxiliary Space:** O(X*Y*Z)\n\nConstraints:\n0 ≤ X, Y, Z ≤ 60\n\n" }, { "path": "GFG/Number Of Islands/Number Of Islands.cpp", "content": "class Solution {\n public:\n \n //dfs function for finding island\n \n void dfs(vector>&v,int l,int i,int j,int n,int m){\n\n if(i>n-1||j>m-1||i<0||j<0){\n\n return;\n\n }\n\n if(v[i][j]!=l){\n\n return;\n\n }\n \n // update number\n \n v[i][j]+=1;\n\n dfs(v,l,i-1,j,n,m); // up\n\n dfs(v,l,i+1,j,n,m); // down\n\n dfs(v,l,i,j-1,n,m); // left\n\n dfs(v,l,i,j+1,n,m); // right\n\n }\n\n \n\n vector numOfIslands(int n, int m, vector> &operators) {\n\n int k=operators.size();\n \n //flag\n\n int l=1;\n\n vector ans;\n\n vector> v(n,vector(m,0));\n \n // iterate around the number of operations\n\n for(int i=0;i numOfIslands(int rows, int cols, int[][] operators) {\n //Your code here\n int[][] mat=new int[rows][cols];\n List ans=new ArrayList<>();\n UnionFind uf=new UnionFind(rows,cols);\n int[] dx=new int[]{1,0,-1,0};\n int[] dy=new int[]{0,1,0,-1};\n \n for(int[]operator:operators){\n int x=operator[0];\n int y=operator[1];\n mat[x][y]=1;\n for(int i=0;i<4;i++){\n int nx=x+dx[i];\n int ny=y+dy[i];\n if(nx>=0 && ny>=0 && nx\nusing namespace std;\n\nclass Solution {\n public:\n void dfs(vector>& grid, int i, int j, int xi, int xj, int n, int m, vector&ans){\n if(i<0 || j<0 || i>=n || j>=m || grid[i][j]==0) return;\n \n ans.push_back(i-xi);\n ans.push_back(j-xj);\n grid[i][j] =0;\n dfs(grid, i-1, j, xi, xj, n,m, ans);\n dfs(grid, i+1, j, xi, xj, n,m, ans);\n dfs(grid, i, j-1, xi, xj, n,m, ans);\n dfs(grid, i, j+1, xi, xj, n,m, ans);\n }\n int countDistinctIslands(vector>& grid) {\n // code here\n set>st;\n int n = grid.size(), m= grid[0].size();\n for(int i =0; ians;\n dfs(grid,i,j,i,j,n,m,ans);\n st.insert(ans);\n }\n }\n }\n return st.size();\n }\n};\nint main() {\n\n int t;\n cin >> t;\n while (t--) {\n int n, m;\n cin >> n >> m;\n vector> grid(n, vector(m));\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < m; j++) {\n cin >> grid[i][j];\n }\n }\n Solution obj;\n cout << obj.countDistinctIslands(grid) << endl;\n }\n}\n\n\n// Another Approach :\n/*\n Instead of changing the original content/values of grid vector, we can also use a different vector storing each visited indexes,\n while keeping grid vector intact, as in general it's not recommended to change values of original vector.\n \n Below is my Code class implementing my logic, I hope it will help,\n*/\n\nclass Solution {\n public:\nvoid dfs(int i,int j,int r,int c,vector> &vis, vector> &v,vector>&a){\n int n = v.size(), m = v[0].size();\n if(r>=n || c>=m || r<0 || c<0 || v[r][c]==0 || vis[r][c]==1) return;\n \n a.push_back({i,j});\n vis[r][c] = 1;\n \n dfs(i+1,j,r+1,c,vis,v,a);\n dfs(i,j+1,r,c+1,vis,v,a);\n dfs(i-1,j,r-1,c,vis,v,a);\n dfs(i,j-1,r,c-1,vis,v,a);\n \n} \n int countDistinctIslands(vector>& grid) {\n set>> st;\n \n vector> vis(grid.size(),vector(grid[0].size(),0));\n \n for(int i=0;i> v;\n dfs(0,0,i,j,vis,grid,v);\n if(v.size()>0) st.insert(v);\n }\n }\n }\n \n \n return st.size();\n }\n};\n" }, { "path": "GFG/Number of Distinct Islands/Number of Distinct Islands.py", "content": "import sys\nclass Solution:\n sys.setrecursionlimit(10**8)\n def countDistinctIslands(self, grid : List[List[int]]) -> int:\n ans = set()\n n=len(grid)\n m=len(grid[0])\n\n def dfs(r,c,ans):\n if r<0 or c<0 or r>=n or c>=m or grid[r][c]!=1:\n return\n grid[r][c] = 0\n dfs(r, c-1, arr)\n arr.append('R')\n dfs(r, c+1, arr)\n arr.append('D')\n dfs(r+1, c, arr)\n arr.append('U')\n dfs(r-1, c, arr)\n arr.append('L')\n\n for i in range(n):\n for j in range(m):\n if grid[i][j] == 1:\n arr = []\n dfs(i,j,arr)\n ans.add(tuple(arr))\n return len(ans)\n" }, { "path": "GFG/Number of turns in binary tree/Number of turns in binary tree.cpp", "content": "/*\n This code is contributed by-->\n - Abhishek Kumar (https://github.com/Abhi2061)\n - Adarsh Urmaliya (https://github.com/Satellite-system)\n*/\n\nclass Solution{\n public:\n \n // function should return the number of turns required to go from first node to second node \n int NumberOFTurns(struct Node* root, int first, int second)\n {\n // Your code goes here\n Node *head = lca(root, first, second);\n \n int F = countTurns(head, first, ' ');\n int S = countTurns(head, second, ' ');\n \n int ans = F + S;\n \n if(head->data != first and head->data != second)\n ans++;\n \n return ans;\n }\n \n //Function to return the lowest common ancestor in a Binary Tree.\n Node* lca(Node* root ,int n1 ,int n2 )\n {\n //Your code here \n \n if(!root)\n return root;\n \n if(root->data == n1 or root->data == n2)\n return root;\n \n Node *Left = lca(root->left, n1, n2);\n Node *Right = lca(root->right, n1, n2);\n \n if(Left and !Right)\n return Left;\n \n else if(!Left and Right)\n return Right;\n \n else if(Left and Right)\n return root;\n \n else\n return nullptr;\n }\n \n // function should return the minimum number of turn to reach a node.\n int countTurns(Node* root, int n, char d)\n {\n if(!root)\n return 1e5;\n \n if(root->data == n)\n return 0;\n \n int Left = countTurns(root->left, n, 'L');\n int Right = countTurns(root->right, n, 'R');\n \n if(d == 'L')\n Right++;\n if(d == 'R')\n Left++;\n \n return min(Left, Right);\n }\n};\n\n\n// Another Approach :: \n\n// We can use Vector, and store the char as 'L' when we move to left of node in 'R' when me move to right of node, in a common vector, \n// when we got to find first number, we then store all that data to vector named First, similarily for second number we save to vector named Second,\n// now in main function we would traverse through, First and Second vector so as to remove common char stored for common Nodes, then after the common \n// nodes have been filtered, we travese in both vectors separately so as to count number of points when char has been changed from the previous char, as that\n// would mean a turn from LEFT to RIGHT or from RIGHT to LEFT, also just after removing the common nodes we would check if we have traversed any vector completely, \n// that would mean that one of the node is ancestor to other, in that case we would not increment an extra for a turn at an ancestor node..\n \n// MY code : \n\nclass Solution{\n public:\nvoid traverseHelper(Node* root, int first, int second, vector &FirstSeries, \n vector &SecondSeries, vector &cmn, int num){\n if(!root || num ==2) return;\n if(root->data==first){\n num++;\n FirstSeries = cmn;\n }\n if(root->data==second){\n num++;\n SecondSeries = cmn;\n }\n \n cmn.push_back('L');\n traverseHelper(root->left, first, second, FirstSeries, SecondSeries, cmn, num);\n cmn.pop_back();\n \n if(num==2) return;\n \n cmn.push_back('R');\n traverseHelper(root->right, first, second, FirstSeries, SecondSeries, cmn, num);\n cmn.pop_back();\n} \n // function should return the number of turns required to go from first node to second node \n int NumberOFTurns(struct Node* root, int first, int second)\n {\n vector FirstSeries, SecondSeries, cmn;\n traverseHelper(root, first, second, FirstSeries, SecondSeries, cmn, 0);\n \n int i=0;\n for(; i< min(FirstSeries.size(), SecondSeries.size()); i++){\n if(FirstSeries[i] != SecondSeries[i]) break;\n }\n \n int cnt = 0;\n if(i == FirstSeries.size() && i == SecondSeries.size()) return cnt;\n \n // For the case of Different Ancestors\n if(i> displayContacts(int n, string contact[], string s)\n {\n // code here\n //tried to make it as simple as possible\n sort(contact,contact+n);\n\n set st;\n\n for(int i=0;i> ans;\n\n for(int j=0;j temp;\n\n for(auto it:st){\n\n if(s.substr(0,j+1)==it.substr(0,j+1)) temp.push_back(it);\n\n }\n\n if(temp.size()==0) temp.push_back(\"0\");\n\n ans.push_back(temp);\n\n }\n\n return ans;\n }\n };\n" }, { "path": "GFG/Phone directory/Phone directory.java", "content": "class Trie{\n Map> map;\n Map next;\n Trie(){\n map=new HashMap<>();\n next=new HashMap<>();\n }\n}\n\n\nclass Solution{\n static ArrayList> displayContacts(int n, \n String contact[], String s)\n {\n // code here \n ArrayList> ans=new ArrayList<>();\n Trie head=new Trie();\n \n //create trie\n for(String st:contact){\n Trie curr=head;\n for(char c:st.toCharArray()){\n curr.map.putIfAbsent(c,new TreeSet<>());\n curr.map.get(c).add(st);\n curr.next.putIfAbsent(c,new Trie());\n curr=curr.next.get(c);\n }\n }\n \n Trie curr=head;\n for(int i=0;i list=new ArrayList<>();\n if(curr.map.containsKey(s.charAt(i))){\n for(String str:curr.map.get(s.charAt(i))){\n list.add(str);\n }\n }\n if(list.size()==0)list.add(\"0\");\n ans.add(list);\n \n if(curr.next.containsKey(s.charAt(i))){\n curr=curr.next.get(s.charAt(i));\n }else{\n break;\n }\n }\n while(ans.size()!=s.length()){\n ArrayList list=new ArrayList<>();\n list.add(\"0\");\n ans.add(list);\n }\n return ans;\n \n }\n}\n\n\n\n\n//Method 2\n\nclass Solution{\n static class Trie {\n Trie child[]=new Trie[26];\n Boolean word[]=new Boolean[26];\n }\n static ArrayList> displayContacts(int n, \n String contact[], String s)\n {\n // code here\n ArrayList> res=new ArrayList<>();\n Trie head = new Trie();\n for(int i=0;i curList=new ArrayList<>();\n if(flag==1) { // No string found with prefix\n curList.add(\"0\");\n res.add(curList);\n continue;\n }\n if( cur.word[s.charAt(i)-'a']!=null && cur.word[s.charAt(i)-'a'] == true) {\n curList.add(new String(sb.toString()));\n }\n findAllPrefixes(cur, sb, curList); \n if(curList.size()>0) // Adding all words which start with prefix 0-i of String s.\n res.add(curList);\n else {\n curList.add(\"0\");\n res.add(curList);\n }\n \n }\n return res;\n }\n public static int findAllPrefixes(Trie cur, StringBuilder sb, ArrayList curList) { // Adding all words which start with the preficx from o-i of string s, storing in curList\n int childVis = -1;\n for(int i=0;i<26;i++) {\n if(cur.child[i]!=null && childVis!=i) {\n sb.append(\"\"+(char)(i+'a'));\n if(cur.child[i].word[i]!=null && cur.child[i].word[i]==true) {\n curList.add(new String(sb.toString()));\n }\n childVis=findAllPrefixes(cur.child[i], sb, curList);\n sb.deleteCharAt(sb.length()-1);\n }\n }\n return -1;\n }\n}\n" }, { "path": "GFG/Primes sum/Primes sum.cpp", "content": "class Solution {\n public:\n bool checkPrime(int n)\n\n {\n\n if(n<2)\n\n return false;\n\n for(int i=2; i<=sqrt(n); i++)\n\n {\n\n if(n%i==0)\n\n return false;\n\n }\n\n return true;\n\n }\n \n string isSumOfTwo(int N){\n // code here\n \n for(int i=2; i downwardDigonal(int N, vector> A)\n\t{\n\t\t// Your code goes here\n\t\tvectorv;\n\t\tfor(int i=0;i downwardDigonal(int N, int A[][])\n {\n // code here \n ArrayList ans=new ArrayList<>();\n int row=0;\n int col=0;\n while(col=0){\n ans.add(A[r][c]);\n r++;\n c--;\n }\n col++;\n }\n col=N-1;\n row=1;\n while(row=0){\n ans.add(A[r][c]);\n r++;\n c--;\n }\n row++;\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Print Diagonally/README.md", "content": "## Print Diagonally\n\nGive a **N * N** square matrix **A**, return all the elements of its **anti-diagonals** from top to bottom.\n\n**Example 1:**\n```\nInput: \nN = 2\nA = [[1, 2],\n [3, 4]]\nOutput:\n1 2 3 4\nExplanation: \n\n```\n\n![ScreenShot2022-10-17at9-1665980852](https://user-images.githubusercontent.com/76674591/196438008-83b2851a-b6b9-4a19-949b-06826956a58e.png)\n\n```\nHence, elements will be returned in the \norder {1, 2, 3, 4}.\n\n```\n**Example 2:**\n\n```\nInput: \nN = 3 \nA = [[1, 2, 3],\n [4, 5, 6],\n [7, 8, 9]]\nOutput: \n1 2 4 3 5 7 6 8 9\nExplanation: \n```\n\n![ScreenShot2022-10-17at9-1665980941](https://user-images.githubusercontent.com/76674591/196438089-a533157f-3d20-4be3-a631-dcb4fda61cff.png)\n\n```\nHence, elements will be returned in \nthe order {1, 2, 4, 3, 5, 7, 6, 8, 9}.\n```\n***\n\n**Your Task:**\n\nYou don't need to read input or print anything. Your task is to complete the function **downwardDigonal()** which takes an integer N and a 2D matrix A[ ][ ] as input parameters and returns the list of all elements of its anti-diagonals from top to bottom.\n\n**Expected Time Complexity:** O(N*N)\n**Expected Auxillary Space:** O(N*N)\n\nConstraints:\n1 ≤ N, M ≤ 103\n0 ≤ A[i][j] ≤ 106\n\n" }, { "path": "GFG/Print leaf nodes from preorder traversal of BST/Print leaf nodes from preorder traversal of BST.cpp", "content": "class Solution {\n public:\n vector leafNodes(int a[],int n) {\n // code here\n \n stack s;\n vector vec;\n s.push(a[0]);\n for(int i=1;i1){\n vec.push_back(ln);\n }\n }\n s.push(a[i]);\n }\n if(!s.empty()){\n vec.push_back(s.top());\n }\n return vec;\n }\n};\n" }, { "path": "GFG/Print leaf nodes from preorder traversal of BST/Print leaf nodes from preorder traversal of BST.java", "content": "class Solution\n{\n public int[] leafNodes(int arr[], int N)\n {\n // code here\n ArrayList ans=new ArrayList<>();\n Stack st=new Stack<>();\n st.push(arr[0]);\n for(int i=1;i=2){\n ans.add(temp);\n }\n }\n }\n ans.add(st.peek());\n int[] res=new int[ans.size()];\n int idx=0;\n for(int i:ans){\n res[idx++]=i;\n }\n return res;\n }\n}\n" }, { "path": "GFG/Print leaf nodes from preorder traversal of BST/README.md", "content": "## Print leaf nodes from preorder traversal of BST\n\nGiven a preorder traversal of a BST, find the leaf nodes of the tree without building the tree.\n\n\n**Example 1:**\n```\nInput:\nN = 2\n\narr = {2,1}\n\nOutput: {1}\n\nExplaination: 1 is the only leaf node.\n```\n**Example 2:**\n```\nInput:\nN = 3\n\nArr = {3, 2, 4}\n\nOutput: {2, 4}\n\nExplaination: 2, 4 are the leaf nodes.\n```\n***\n\n**Your Task:**\nYou don't need to read input or print anything. Your task is to complete the function **leafNodes()** which takes the array arr[] and its size N as input parameters and returns the leaf nodes of the tree.\n\n\n**Expected Time Complexity:** O(N)\n**Expected Auxiliary Space:** O(N)\n\n\n**Constraints:**\n1 ≤ N ≤ 103\n1 ≤ arr[i] ≤ 103\n" }, { "path": "GFG/Queries on a matrix/Queries on a matrix hard s25 gfg.cpp", "content": "#include \nusing namespace std;\n\nclass Solution {\n public:\n vector> solveQueries(int n, vector> Queries) {\n // Code here\n vector>mat(n, vector (n,0));\n \n for(auto e: Queries){\n int a,b,c,d;\n a = e[0]; b=e[1]; c=e[2]; d=e[3];\n \n mat[a][b] +=1;\n if(c > tc;\n while (tc--) {\n int n, q;\n cin >> n >> q;\n vector> Queries;\n for (int i = 0; i < q; i++) {\n vector cur(4);\n for (int j = 0; j < 4; j++) cin >> cur[j];\n Queries.push_back(cur);\n }\n Solution obj;\n vector> ans = obj.solveQueries(n, Queries);\n for (auto i : ans) {\n for (auto j : i) cout << j << \" \";\n cout << \"\\n\";\n }\n }\n return 0;\n}\n// } Driver Code Ends" }, { "path": "GFG/Rearrange Array Alternately/Rearrange Array Alternately.java", "content": "class Solution{\n \n // temp: input array\n // n: size of array\n //Function to rearrange the array elements alternately.\n public static void rearrange(long arr[], int n){\n \n // Your code here\n int l=0;\n int r=n-1;\n long mod=1000001;\n for(int i=0;i> &vis,int n,int m,vector> &grid)\n {\n vis[r][c]=1;\n for(int i=0;i<4;i++){\n int nr=r+delrow[i];\n int nc=c+delcol[i];\n if(nr>=0 && nr=0 && nc> fill(int n, int m, vector> grid)\n {\n vector> vis(n,vector(m,0));\n for(int j=0;j findLeastGreater(vector& arr, int n) {\n \n \n vector v; \n\n sets;\n\n for(int i=n-1;i>=0;i--)\n\n {\n\n auto up=s.upper_bound(arr[i]); //finds the nearest greater value\n\n if(up==s.end()) //if not find nearest grater value\n\n v.push_back(-1); \n\n else\n\n v.push_back(*up);\n\n \n\n s.insert(arr[i]); //insert ans in array\n\n }\n\n reverse(v.begin(),v.end()); //reverse it cause we itarate to last\n\n return v;\n }\n};\n" }, { "path": "GFG/Replace every element with the least greater element on its right/Replace every element with the least greater element on its right.java", "content": "class Solution {\n public static ArrayList findLeastGreater(int n, int[] arr) {\n // code here\n TreeSet set=new TreeSet<>();\n ArrayList ans =new ArrayList<>();\n for(int i=n-1;i>=0;i--){\n set.add(arr[i]);\n if(set.higher(arr[i])==null)ans.add(-1);\n else ans.add(set.higher(arr[i]));\n }\n Collections.reverse(ans);\n return ans;\n }\n}\n\n\n// second Method using Binary Search Tree\n\n\nclass Solution {\n static class Node {\n int val;\n Node left;\n Node right;\n Node(int val) {\n this.val=val;\n this.left=null;\n this.right=null;\n }\n }\n public static ArrayList findLeastGreater(int n, int[] arr) {\n Node head = null;\n ArrayList res=new ArrayList<>();\n for(int i=arr.length-1;i>=0;i--) {\n if(head==null) {\n head=new Node(arr[i]);\n }\n else {\n Node prev=addNodeInBST(arr[i], head, head);\n \n if(prev.val>arr[i]) {\n prev.left=new Node(arr[i]);\n }\n else {\n prev.right=new Node(arr[i]);\n }\n }\n \n int max[]=new int[1];\n max[0]=Integer.MAX_VALUE;\n leastGreater(head, max, arr[i]);\n if(max[0]==Integer.MAX_VALUE) {\n arr[i]=-1;\n }\n else {\n arr[i]= max[0];\n }\n }\n \n for(int i=0;ival) {\n return addNodeInBST(val, cur.left, cur);\n }\n else {\n return addNodeInBST(val, cur.right, cur);\n }\n }\n \n public static void leastGreater(Node head, int []max, int value) {\n if(head==null) {\n return ;\n } \n \n \n if(head.val>value) {\n max[0]=Math.min(max[0], head.val);\n }\n \n if(head.val>value) {\n leastGreater(head.left, max, value);\n }\n else {\n leastGreater(head.right, max, value);\n }\n }\n}\n \n" }, { "path": "GFG/Reverse Spiral Form of Matrix/Reverse Spiral Form of Matrix.cpp", "content": "class Solution {\n public:\n vector reverseSpiral(int R, int C, vector>&a) {\n // code here\n \n vectorans;\n\n \n\n int top=0,left=0,right=C-1,bottom=R-1;\n\n while(top<=bottom and left<=right)\n\n { // top row\n\n if(top<=bottom)\n\n {\n\n for(int i=left;i<=right;i++)\n\n ans.push_back(a[top][i]);\n\n \n\n top++;\n\n }\n\n // right column\n\n if(left<=right){\n\n for(int i=top;i<=bottom;i++)\n\n {\n\n ans.push_back(a[i][right]);\n\n }\n\n right--;\n\n }\n\n //bottom row (reverse order)\n\n if(top<=bottom)\n\n {\n\n for(int i=right;i>=left;i--)\n\n {\n\n ans.push_back(a[bottom][i]);\n\n }\n\n bottom--;\n\n }\n\n //left column (reverse order)\n\n if(left<=right)\n\n {\n\n for(int i=bottom;i>=top;i--)\n\n {\n\n ans.push_back(a[i][left]);\n\n }\n\n left++;\n\n }\n\n }\n\n // reverse ans vector\n\n reverse(ans.begin(),ans.end());\n\n return ans;\n }\n};\n" }, { "path": "GFG/Reverse Spiral Form of Matrix/Reverse Spiral Form of Matrix.java", "content": "class Solution\n{\n public int[] reverseSpiral(int R, int C, int[][] a)\n {\n // code here\n int[] ans=new int[R*C];\n int idx=R*C-1;\n \n int up=0;\n int down=a.length-1;\n int left=0;\n int right=a[0].length-1;\n \n \n \n while(idx>=0){\n //upper row\n for(int i=left;i<=right && idx>=0;i++){\n ans[idx--]=a[up][i];\n }\n up++;\n \n //last col\n for(int i=up;i<=down && idx>=0;i++){\n ans[idx--]=a[i][right];\n }\n right--;\n \n //lower row\n for(int i=right;i>=left && idx>=0;i--){\n ans[idx--]=a[down][i];\n }\n down--;\n \n for(int i=down;i>=up && idx>=0;i--){\n ans[idx--]=a[i][left];\n }\n left++;\n }\n \n return ans;\n \n }\n}\n" }, { "path": "GFG/Satisfy the equation/Satisfy the equation.java", "content": "class Pair{\n int x;\n int y;\n Pair(int a,int b){\n x=a;\n y=b;\n }\n}\n\n\n// 1 2 4 5==curr\n// 0 3 4 5 ==ans\n\nclass Solution {\n \n static int[] satisfyEqn(int[] A, int N) {\n // code here\n int ans[]=new int[4];\n Arrays.fill(ans,Integer.MAX_VALUE);\n Map map=new HashMap<>();//key-> sum, values-> indices\n \n for(int i=0;icurr[idx]){\n replace=true;\n break;\n }else if(ans[idx] map=new HashMap<>();\n for(int i=0;imax){\n max=curr;\n ans=new StringBuilder(temp);\n }\n \n if(curr<0){\n curr=0;\n temp=new StringBuilder();\n }\n }\n return ans.toString();\n }\n}\n\n\n\n//Approach 2\nclass Solution{\n static String maxSum(String w,char x[],int b[], int n){\n int i= 0;\n int j=0;\n int max=Integer.MIN_VALUE;\n int res[]=new int[52];\n for(int k=0;k<52;k++) {\n res[k]=2000;\n }\n for(int k=0;k='a' && x[k]<='z')\n res[x[k]-'a']=b[k];\n else\n res[x[k]-'A'+26]=b[k];\n }\n for(int k=0;k<26;k++) {\n if(res[k]==2000) {\n res[k]=97+k;\n }\n }\n for(int k=26;k<52;k++) {\n if(res[k]==2000) {\n res[k]=65+k-26;\n }\n }\n int count =0;\n int maxI=0;\n int maxJ=0;\n while(j='a' && w.charAt(j)<='z')\n count+=res[w.charAt(j)-'a'];\n else\n count+=res[w.charAt(j)-'A'+26];\n if(count>max) {\n max=count;\n maxI=i;\n maxJ=j;\n }\n \n if(count<0) {\n count=0;\n i=j+1;\n }\n j+=1;\n }\n return w.substring(maxI, maxJ+1);\n }\n}\n" }, { "path": "GFG/Search Pattern (KMP-Algorithm)/Search Pattern (KMP-Algorithm).java", "content": "class Solution\n{\n \n ArrayList search(String pat, String txt)\n {\n int pn=pat.length(), tn=txt.length();\n int lps[]=new int[pn];\n fill(lps,pat,pn);\n ArrayList list=new ArrayList<>();\n \n int j=0;\n for(int i=0;i search(String pat, String S)\n {\n int total=26, mod=101;\n ArrayList list=new ArrayList<>();\n int p=0, s=0, sn=S.length(), pn=pat.length();\n \n // calculate most significant position\n // (we will need this when we have to remove most signicant position value)\n // The value of h would be \"pow(d, M-1)%q\"\n int h = 1; \n for (int i = 0; i < pn-1; i++)\n h = (h*total)%mod;\n \n // System.out.println(h);\n\n for(int i=0;i=n || j>=m)\n return false;\n return true;\n }\n\n int shortestPath(vector> &grid, pair source, pair destination){\n if(source==destination){\n return 0;\n }\n int n=grid.size();\n int m =grid[0].size();\n queue,int>>q;\n q.push({source,0});\n grid[source.first][source.second]=0;\n while(!q.empty()){\n int row = q.front().first.first;\n int col = q.front().first.second;\n int dis = q.front().second;\n q.pop();\n if(row==destination.first && col==destination.second){\n return dis;\n }\n if(isSafe(row+1,col,n,m) && grid[row+1][col]==1){\n q.push({{row+1,col},dis+1});\n grid[row+1][col]=0;\n }\n if(isSafe(row-1,col,n,m) && grid[row-1][col]==1){\n q.push({{row-1,col},dis+1});\n grid[row-1][col]=0;\n }\n if(isSafe(row,col+1,n,m) && grid[row][col+1]==1){\n q.push({{row,col+1},dis+1});\n grid[row][col+1]=0;\n }\n if(isSafe(row,col-1,n,m) && grid[row][col-1]==1){\n q.push({{row,col-1},dis+1});\n grid[row][col-1]=0;\n }\n }\n return -1;\n }\n};\n" }, { "path": "GFG/Shortest Distance in a Binary Maze/Shortest Distance in a Binary Maze.java", "content": "class Solution {\n\n class Pair{\n int x;\n int y;\n Pair(int i,int j){\n x=i;\n y=j;\n }\n }\n int shortestPath(int[][] grid, int[] src, int[] des) {\n Queue q=new LinkedList<>();\n q.add(new Pair(src[0],src[1]));\n grid[src[0]][src[1]]=0;\n int dis=0;\n while(!q.isEmpty()){\n int sz=q.size();\n while(sz-->0){\n Pair curr=q.remove();\n int i=curr.x;\n int j=curr.y;\n if(i==des[0] && j==des[1])return dis;\n if(i>0 && grid[i-1][j]==1){\n grid[i-1][j]=0;\n q.add(new Pair(i-1,j));\n }\n if(j>0 && grid[i][j-1]==1){\n grid[i][j-1]=0;\n q.add(new Pair(i,j-1));\n }\n if(i q=new LinkedList<>();\n visited[source[0]][source[1]]=1;\n if(grid[source[0]][source[1]] == 0) return -1;\n q.add(new Pair(source[0], source[1]));\n int ans=0;\n while(!q.isEmpty()) {\n int n=q.size();\n while(n>0) {\n Pair p=q.poll();\n if(p.i==destination[0] && p.j==destination[1]) return ans;\n \n Pair up=getPair(p.i, p.j+1, grid, visited);\n Pair down=getPair(p.i, p.j-1, grid, visited);\n Pair left=getPair(p.i-1, p.j, grid, visited);\n Pair right=getPair(p.i+1, p.j, grid, visited);\n \n if(up!=null) q.add(up);\n if(down!=null) q.add(down);\n if(left!=null) q.add(left);\n if(right!=null) q.add(right);\n n-=1;\n }\n ans+=1;\n }\n return -1;\n }\n public Pair getPair(int x, int y, int[][] grid, int [][]visited) {\n if(x<0 || y<0 || x>=grid.length || y>=grid[0].length) return null;\n if(grid[x][y]==0 || visited[x][y]==1) {\n return null;\n }\n visited[x][y]=1; \n return new Pair(x, y);\n }\n}\n" }, { "path": "GFG/Shortest Path by Removing K walls/Shortest Path by Removing K walls.java", "content": "class Solution {\n static int shotestPath(int[][] mat, int n, int m, int k) {\n // code here\n int[][]dirs={{1,0},{0,1},{0,-1},{-1,0}};\n Queue q=new LinkedList<>();\n q.add(new int[]{0,0,k});\n boolean[][][]vis=new boolean[n][m][k+1];\n vis[0][0][k]=true;\n int dis=0;\n while(!q.isEmpty()){\n int sz=q.size();\n while(sz-->0){\n int[]curr=q.remove();\n if(curr[0]==n-1 && curr[1]==m-1)return dis;\n for(int[]d:dirs){\n int i=curr[0]+d[0];\n int j=curr[1]+d[1];\n int obs=curr[2];\n if(i=0 && j>=0){\n if(mat[i][j]==0 && !vis[i][j][obs]){\n q.add(new int[]{i,j,obs});\n vis[i][j][obs]=true;\n }else if(mat[i][j]==1 && obs>0 && !vis[i][j][obs-1]){\n q.add(new int[]{i,j,obs-1});\n vis[i][j][obs-1]=true;\n }\n }\n }\n }\n dis++;\n }\n return -1;\n }\n};\n" }, { "path": "GFG/Shortest Prime Path/Shortest Prime Path.java", "content": "class Solution\n{\n boolean[] prime;\n Solution()\n {\n prime =new boolean[10000];\n Arrays.fill(prime,true);\n prime[0]=prime[1]=false;\n for(int i=2;i<10000;i++){\n if(!prime[i])continue;\n for(int j=2;i*j<10000;j++)prime[i*j]=false;\n }\n // Every index of prime stores zero or one\n // If prime[i] is zero means i is not a prime\n // If prime[i] is one means i is a prime\n }\n \n public int shortestPath(int Num1,int Num2){\n // Complete this function using prime array\n \n boolean[]vis=new boolean[10000];\n Queue q=new LinkedList<>();\n q.add(new int[]{Num1,0});\n vis[Num1]=true;\n while(!q.isEmpty()){\n int[] curr=q.remove();\n if(curr[0]==Num2)return curr[1];\n \n char[] arr= Integer.toString(curr[0]).toCharArray();\n for(int i=0;i<4;i++){\n for(char ch='0';ch<='9';ch++){\n char prevChar = arr[i];\n arr[i]=ch;\n int newNum = Integer.parseInt(new String(arr));\n if(!vis[newNum] && prime[newNum] && newNum>=1000){\n vis[newNum]=true;\n q.add(new int[]{newNum,curr[1]+1});\n }\n arr[i]=prevChar;\n }\n }\n }\n return -1;\n }\n}\n" }, { "path": "GFG/Shreyansh and his bits/Shreyansh and his bits.java", "content": "class Solution{\n long[][]dp;\n long count(long n)\n {\n dp=new long[64][64];\n for(int i=0;i<64;i++){\n Arrays.fill(dp[i],-1);\n }\n int ones=0;\n int positions=0;\n long ans=0;\n while(n>0){\n if((n&1)==1){\n ones++;\n ans+=nCr(positions,ones);\n }\n n=n>>1;\n positions++;\n }\n return ans;\n }\n long nCr(int n,int r){\n if(r>n){\n return 0;\n }\n if(r==0 || r==n)return 1;\n if(dp[n][r]!=-1)return dp[n][r];\n return dp[n][r]=nCr(n-1,r-1)+nCr(n-1,r);\n }\n}\n" }, { "path": "GFG/Single valued subtree/Single valued subtree.java", "content": "class Solution\n{\n int ans;\n public int singlevalued(Node root)\n {\n //code here\n ans=0;\n dfs(root);\n return ans;\n }\n Integer dfs(Node root){\n if(root==null)return null;\n Integer lefty=dfs(root.left);\n Integer righty=dfs(root.right);\n if(lefty!=null && righty!=null && lefty==righty && lefty==root.data){\n ans++;\n return righty;\n }else if(root.left==null && root.right==null){\n ans++;\n return root.data;\n }else if(root.left==null && righty!=null && righty==root.data){\n ans++;\n return root.data;\n }else if(root.right==null && lefty!=null && lefty==root.data){\n ans++;\n return root.data;\n }\n return null;\n }\n}\n" }, { "path": "GFG/Sort an array of 0s, 1s and 2s/Sort an array of 0s, 1s and 2s.java", "content": "class Solution\n{\n public static void sort012(int a[], int n)\n {\n // code here \n int zero=0;\n int one=0;\n int two=0;\n for(int i:a){\n if(i==0){\n zero++;\n }else if(i==1){\n one++;\n }else{\n two++;\n }\n }\n \n int idx=0;\n while(zero>0){\n zero--;\n a[idx++]=0;\n }\n while(one-->0){\n a[idx]=1;\n idx++;\n }\n while(two-->0){\n a[idx++]=2;\n }\n }\n}\n" }, { "path": "GFG/Sort an array of 0s, 1s and 2s/Sort an array of 0s,1s and 2s s29.cpp", "content": "#include\nusing namespace std;\nclass Solution\n{\n public:\n void sort012(int a[], int n)\n {\n // code here \n int zero =0, one =0, two =n-1;\n while(one<=two){\n if(a[one]==0){\n swap(a[one] ,a[zero]); zero++, one++;\n }else if(a[one]==2){\n swap(a[one], a[two]); two--;\n }else one++;\n }\n }\n \n};\nint main() {\n\n int t;\n cin >> t;\n\n while(t--){\n int n;\n cin >>n;\n int a[n];\n for(int i=0;i> a[i];\n }\n\n Solution ob;\n ob.sort012(a, n);\n\n for(int i=0;i> &matrix, int m, int n, int k)\n {\n // Your code goes here\n vector v;\n int left = 0, right = n-1, top = 0, bottom = m-1;\n int direction = 1;\n while(left <= right and top <= bottom){\n if(direction == 1){ // --->\n for(int i=left;i<=right;i++) v.push_back(matrix[top][i]);\n direction = 2;\n top++;\n }\n else if(direction == 2){ // downwords\n for(int i=top;i<=bottom;i++) v.push_back(matrix[i][right]);\n direction = 3;\n right--;\n }\n else if(direction == 3){ // <----\n for(int i=right;i>=left;--i) v.push_back(matrix[bottom][i]);\n direction = 4;\n bottom--;\n }else if(direction == 4){ // upwards\n for(int i=bottom;i>=top;--i) v.push_back(matrix[i][left]);\n direction = 1;\n left++;\n }\n }\n return v[k-1];\n }\n\n};\n" }, { "path": "GFG/Split Array Largest Sum/Split Array Largest Sum.java", "content": "class Solution {\n static int splitArray(int[] arr , int N, int K) {\n // code here\n int l=0;\n int h=0;\n int ans=0;\n for(int i:arr){\n l=Math.max(l,i);\n h+=i;\n }\n \n while(l<=h){\n int mid=l+(h-l)/2;\n if(isPossible(mid,arr,K)){\n ans=mid;\n h=mid-1;\n }else{\n l=mid+1;\n }\n }\n return ans;\n }\n static boolean isPossible(int maxSum,int[]arr,int k){\n int cnt=0;\n int currSum=0;\n for(int i:arr){\n if(currSum+i>maxSum){\n cnt++;\n currSum=i;\n }else{\n currSum+=i;\n }\n }\n \n if(currSum<=maxSum)cnt++;\n return cnt<=k;\n }\n};\n" }, { "path": "GFG/Stepping Numbers/README.md", "content": "## Stepping Numbers\n\nA number is called a stepping number if all adjacent digits have an absolute difference of 1, e.g. '321' is a Stepping Number while 421 is not. Given two integers **n** and **m**, find the count of all the stepping numbers in the range [n, m].\n\n**Example 1:**\n```\nInput: n = 0, m = 21\n\nOutput: 13\n\nExplanation: Stepping no's are 0 1 2 3 4 5\n6 7 8 9 10 12 21\n\n```\n\n\n\n**Example 2:**\n\n```\nInput: n = 10, m = 15\n\nOutput: 2\n\nExplanation: Stepping no's are 10, 12\n\n```\n\n***\n\n**Your Task:** \n\nYou don't need to read input or print anything. Your task is to complete the function **steppingNumbers()** which takes the integer n and integer m as input parameters and returns the number of stepping numbers in the range between n and m.\n\n**Expected Time Complexity:** O(log(M))\n\n**Expected Auxiliary Space:** O(SN) where SN is the number of stepping numbers in the range\n\n\n**Constraints:**\n0 ≤ N < M ≤ 10^7\n" }, { "path": "GFG/Stepping Numbers/Stepping Numbers.cpp", "content": "class Solution{\npublic:\nunordered_map mp;\n\npublic:\n void dfs(int n, int m)\n {\n if (n > m)\n return;\n\n if (mp.find(n) != mp.end())\n return;\n\n mp[n] = 1;\n\n if (n % 10 == 0)\n dfs(n * 10 + 1, m);\n else if (n % 10 == 9)\n dfs(n * 10 + 8, m);\n else\n {\n dfs(n * 10 + (n % 10) - 1, m);\n dfs(n * 10 + (n % 10) + 1, m);\n }\n }\n int steppingNumbers(int n, int m)\n {\n // Code Here\n mp.clear();\n\n for (int i = 0; i <= 9; i++)\n dfs(i, m);\n\n int ans = 0;\n\n for (auto i : mp)\n ans += (i.first >= n and i.second <= m);\n\n return ans;\n }\n\n};\n" }, { "path": "GFG/Stepping Numbers/Stepping Numbers.java", "content": "class Solution{\n int steppingNumbers(int n, int m){\n // code here\n int ans=0;\n if(n==0)ans++;\n Queue q=new LinkedList<>();\n for(int i=1;i<=9;i++){\n q.add(i);\n }\n while(q.size()>0){\n int sz=q.size();\n while(sz-->0){\n int ele=q.remove();\n if(ele>=n && ele<=m)ans++;\n int lastDigit=ele%10;\n if(lastDigit==9){\n int next=ele*10+8;\n if(next<=m)q.add(next);\n }else if(lastDigit==0){\n int next=ele*10+1;\n if(next<=m)q.add(next);\n }else{\n int smaller=ele*10+(lastDigit-1);\n if(smaller<=m)q.add(smaller);\n int greater=ele*10+(lastDigit+1);\n if(greater<=m)q.add(greater);\n }\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG/Substrings of length k with k-1 distinct elements/README.md", "content": "## Substrings of length k with k-1 distinct elements\n\nGiven a String **S** and an integer **K**. Find the count of all substrings of length **K** which have exactly **K-1** distinct characters.\n\n\n## Example 1:\n\n```\nInput:\n\nS = \"abcc\"\nK = 2\n\nOutput:\n\n1\n\nExplanation:\n\nPossible substrings of length K = 2 are\nab : 2 distinct characters\nbc : 2 distinct characters\ncc : 1 distinct character\nOnly one valid substring exists {\"cc\"}. \n```\n\n## Example 2:\n\n```\nInput:\n\nS = \"aabab\"\nK = 3\n\nOutput :\n\n3\n\nExplanation:\n\nPossible substrings of length K = 3 are\naab : 2 distinct characters\naba : 2 distinct characters\nbab : 2 distinct characters.\nAll of these Substrings are a possible answer,\nso the count is 3.\n```\n\n**Your Task:** \nYou don't need to read input or print anything. Your task is to complete the function **countOfSubstrings()** which takes a String **S** and an integer **K** as input and returns the count of substrings of length **K** having **K-1** distinct characters.\n\n\n**Expected Time Complexity:** O(|S|)\n**Expected Auxiliary Space:** O(constant)\n\n\n**Constraints:**\n1 ≤ K ≤ |S| ≤ 105\n" }, { "path": "GFG/Substrings of length k with k-1 distinct elements/Substrings of length k with k-1 distinct elements.cpp", "content": "\n};\n" }, { "path": "GFG/Substrings of length k with k-1 distinct elements/Substrings of length k with k-1 distinct elements.java", "content": "class Solution {\n static int countOfSubstrings(String s, int k) {\n // code here\n int ans=0;\n int[]freq=new int[26];\n for(int i=0;i0)cnt++;\n }\n int i=0;\n int j=k;\n while(j<=s.length()){\n if(cnt==k-1){\n ans++;\n }\n if(j==s.length())break;\n freq[s.charAt(i)-'a']--;\n if(freq[s.charAt(i)-'a']==0)cnt--;\n freq[s.charAt(j)-'a']++;\n if(freq[s.charAt(j)-'a']==1)cnt++;\n i++;\n j++;\n }\n \n return ans;\n }\n};\n" }, { "path": "GFG/Sum of Beauty of All Substrings/Sum of Beauty of All Substrings.java", "content": "class Solution {\n public static int beautySum(String s) {\n // code here\n int ans=0;\n int n=s.length();\n for(int size=3;size<=n;size++){\n int i=0;\n int j=size;\n int[]freq=new int[26];\n for(int k=i;kmp;\n for(int i = 0 ; i < n ; i++){\n mp[arr[i]]++;\n }\n int cnt = 0;\n for(auto x : mp){\n cnt+=x.second;\n }\n if(mp['R']%2==0 and mp['B']%2==0 and mp['G']%2==0){\n return 2;\n }\n else if(mp['R']%2==1 and mp['B']%2==1 and mp['G']%2==1){\n return 2;\n }\n else{\n return 1;\n }\n }\n};\n" }, { "path": "GFG/The Smurfs/The Smurfs.java", "content": "\nclass Solution{\n static int minFind(int n, String a[]){\n // code here\n int r=0;\n int g=0;\n int b=0;\n for(int i=0;i\nusing namespace std;\nclass Solution {\n public:\n int numsGame(int N) {\n // code here\n // as per example tom wins in every even number, \n if(N%2==0) return 1;\n else return 0;\n }\n};\nint main() {\n int t;\n cin >> t;\n while (t--) {\n int N;\n \n cin>>N;\n\n Solution ob;\n cout << ob.numsGame(N) << endl;\n }\n return 0;\n}" }, { "path": "GFG/Tom and jerry/Tom and Jerry.java", "content": "class Solution {\n static int numsGame(int N) {\n // code here\n if(N%2==0)return 1;\n return 0;\n }\n};\n" }, { "path": "GFG/Tom and jerry/Tom and Jerry.py", "content": "class Solution:\n def numsGame(self, N):\n # code here\n if(N%2==0):\n return 1\n else:\n return 0\n" }, { "path": "GFG/Transform to Sum Tree/Transform to Sum Tree.java", "content": "class Solution{\n public void toSumTree(Node root){\n //add code here.\n dfs(root);\n }\n int dfs(Node root){\n if(root==null)return 0;\n int val = root.data;\n int lefty=dfs(root.left);\n int righty=dfs(root.right);\n root.data=lefty+righty;\n return val + lefty + righty;\n }\n}\n" }, { "path": "GFG/Two numbers with odd occurrences/README.md", "content": "## Two numbers with odd occurrences\n\n\nGiven an unsorted array, Arr[] of size N and that contains even number of occurrences for all numbers except two numbers. Find the two numbers in decreasing order which has odd occurrences.\n\n**Example 1:**\n\n```\nInput:\nN = 8\n\nArr = {4, 2, 4, 5, 2, 3, 3, 1}\n\nOutput: {5, 1} \n\nExplaination: 5 and 1 have odd occurrences.\n```\n**Example 2:**\n\n```\nInput:\nN = 8\n\nArr = {1 7 5 7 5 4 7 4}\n\nOutput: {7, 1}\n\nExplaination: 7 and 1 have odd occurrences.\n```\n\n***\n\n\n**Your Task:**\nYou don't need to read input or print anything. Your task is to complete the function **twoOddNum()** which takes the array Arr[] and its size N as input parameters and returns the two numbers in decreasing order which have odd occurrences.\n\n\n**Expected Time Complexity: O(N)\nExpected Auxiliary Space: O(1)\n\n\nConstraints:\n2 ≤ N ≤ 106\n1 ≤ Arri ≤ 1012\n" }, { "path": "GFG/Two numbers with odd occurrences/Two numbers with odd occurrences.cpp", "content": "class Solution{\n public:\n vector twoOddNum(long long int Arr[], long long int N) \n {\n // code here\n vector< long long int> v;\n\nlong long int res=0,x=0,count=0,b=0;\n\n \n\nfor(long long int i=0;i> UniquePartitions(int n)\n {\n // Code here\n ArrayList> ans=new ArrayList<>();\n ArrayList curr=new ArrayList<>();\n int idx=n-1;\n \n int[]arr=new int[n];\n for(int i=0;i> ans,ArrayList curr,\n int idx,int n,int[]arr){\n if(idx<0 || n<0)return;\n curr.add(arr[idx]);\n if(n-arr[idx]==0){\n ans.add(new ArrayList<>(curr));\n }\n dfs(ans,curr,idx,n-arr[idx],arr);\n curr.remove(curr.size()-1);\n dfs(ans,curr,idx-1,n,arr);\n \n }\n}\n" }, { "path": "GFG/Wine Buying and Selling/Wine Buying and Selling.java", "content": "//{ Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\npublic class GFG {\n public static void main(String[] args) throws Exception {\n Scanner sc = new Scanner(System.in);\n int T = sc.nextInt();\n while(T>0)\n {\n int N = sc.nextInt();\n int arr[] = new int[N];\n for(int i=0; i q=new LinkedList<>();\n for(int i=0;i0)q.add(new int[]{i,arr[i]});\n }\n int i=0;\n long ans=0l;\n while(!q.isEmpty()){\n while(i0)i++;\n int sell=Math.abs(arr[i]);\n while(sell>0){\n int buy=q.peek()[1];\n int pos=q.peek()[0];\n if(sell>=buy){\n ans+=(Math.abs(i-pos)*buy);\n sell-=buy;\n q.remove();\n }else{\n ans+=(Math.abs(i-pos)*sell);\n q.peek()[1]=buy-sell;\n sell=0;\n }\n }\n i++;\n }\n \n return ans;\n \n \n //Method 2\n ArrayList positive=new ArrayList<>();\n ArrayList negative=new ArrayList<>();\n \n for(int i=0;i=0) {\n positive.add(i);\n }\n else {\n negative.add(i);\n }\n }\n long ans=0;\n int neg=0;\n int i=0;\n while(i=Math.abs(Arr[negative.get(neg)])) {\n long diff=Math.abs(positive.get(i)-negative.get(neg));\n long sum=-1*Arr[negative.get(neg)];\n Arr[positive.get(i)]= Arr[positive.get(i)]+Arr[negative.get(neg)];\n ans+=sum*diff;\n neg+=1;\n }\n else {\n long diff=Math.abs(positive.get(i)-negative.get(neg));\n long sum=Arr[positive.get(i)];\n Arr[negative.get(neg)]= Arr[negative.get(neg)]+Arr[positive.get(i)];\n ans+=sum*diff;\n i+=1;\n }\n }\n return ans;\n }\n}\n\n//{ Driver Code Starts.\n// } Driver Code Ends\n\n\n//{ Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\npublic class GFG {\n public static void main(String[] args) throws Exception {\n Scanner sc = new Scanner(System.in);\n int T = sc.nextInt();\n while(T>0)\n {\n int N = sc.nextInt();\n int arr[] = new int[N];\n for(int i=0; i map=new HashMap<>();\n map.put(0L,1L);\n long sum=0;\n long ans=0;\n for(long i:arr){\n sum+=i;\n if(map.containsKey(sum)){\n ans+=map.get(sum);\n }\n map.put(sum,map.getOrDefault(sum,0L)+1);\n }\n return ans;\n }\n}\n" }, { "path": "GFG/k-th smallest element in BST/k-th smallest element in BST.java", "content": "\nclass Solution {\n // Return the Kth smallest element in the given BST\n public int KthSmallestElement(Node root, int k) {\n // Write your code here\n Node curr=root;\n int count=0;\n int ans=-1;\n while(curr!=null){\n if(curr.left==null){\n count++;\n if(count==k)return curr.data;\n curr=curr.right;\n }else{\n Node leftSubtree=curr.left;\n while(leftSubtree.right!=null && leftSubtree.right!=curr){\n leftSubtree=leftSubtree.right;\n }\n \n if(leftSubtree.right==null){\n leftSubtree.right=curr;\n curr=curr.left;\n }else{\n leftSubtree.right=null;\n count++;\n if(count==k)return curr.data;\n curr=curr.right;\n }\n }\n }\n return ans;\n }\n}\n" }, { "path": "GFG_Find_all_distinct_subset_(or subsequence", "content": "class Solution{\n public:\n vector DistinctSum(vectornums){\n // tabulation - bottom up approach - used , it is faster than memoization\n\t vectorres;\n\t int sum =0, m= nums.size();\n\t for(auto n : nums) sum+=n;\n\t \n\t vector>dp_tab(m+1, vector(sum+1));\n\t for(int i=0; i<=m;i++){\n\t for(int j =0; j<=sum; j++){\n\t if(j==0) dp_tab[i][j] = true;\n\t else if(i==0) dp_tab[i][j] = false;\n\t else if(j>=nums[i-1])\n\t dp_tab[i][j] = dp_tab[i-1][j-nums[i-1]] || dp_tab[i-1][j];\n\t else dp_tab[i][j] = dp_tab[i-1][j];\n\t }\n\t }\n\t for(int j =0; j<=sum; j++){\n\t for(int i =0; i<=m; i++){\n\t if(dp_tab[i][j]){\n\t res.push_back(j);\n\t break;\n\t }\n\t }\n\t }\n\t return res;\n\t// TC: O(n*sum), SC: O(n*sum)\n }\n\n};\n" }, { "path": "Game with nos", "content": "int* game_with_number(int arr[], int n)\n{\n \n // Complete the function\n for(int i=1;i= 0 ? start : -1;\n }\n}\n" }, { "path": "Geek and Number String s23 med.cpp", "content": "#include\nusing namespace std; \nclass Solution{\npublic:\n int minLength(string s, int n) {\n // code here\n vectorv={\"12\",\"21\",\"34\",\"43\",\"56\",\"65\",\"78\",\"87\",\"09\",\"90\"};\n int n1=n;\n stackst;\n for(int i=0;i1)\n {\n string temp=\"\";\n char a=st.top(); st.pop();\n char b=st.top(); st.pop();\n temp+=a;\n temp+=b;\n if(find(v.begin(),v.end(),temp)==v.end())\n {\n st.push(b);\n st.push(a);\n }\n }\n }\n return st.size();\n } \n};\nint32_t main()\n{\n ios_base::sync_with_stdio(0);\n cin.tie(NULL);\n cout.tie(NULL);\n\n int t;\n cin >> t;\n while(t--)\n {\n int n;\n cin >> n;\n\n string s;\n cin >> s;\n\n Solution obj;\n cout << obj.minLength(s, n) << \"\\n\";\n }\n return 0;\n}" }, { "path": "Geek and Number String.cpp", "content": "class Solution{\npublic:\n int minLength(string s, int n) {\n // code here\n stack S;\n char arr[10] = {'9','2','1','4','3','6','5','8','7','0'};\n \n for(char it : s)\n {\n if(!S.empty() and arr[S.top()-'0'] == it)\n S.pop();\n else\n S.push(it);\n }\n \n return S.size();\n } \n};\n" }, { "path": "Geek and Number String.java", "content": "\n=======\n public int minLength(String s, int n) { \n \t// code here\n \tStackst=new Stack<>();\n \tint pair[]=new int[]{9,2,1,4,3,6,5,8,7,0};\n \tfor(char ch:s.toCharArray()){\n \t int key=ch-'0';\n \t if(st.size()==0){\n \t st.push(key);\n \t }else{\n \t if(st.peek()==pair[key]){\n \t st.pop();\n \t }else{\n \t st.push(key);\n \t }\n \t }\n \t}\n \treturn st.size();\n }\n}\n\nApproach 2:\n\nclass Solution { \n\n public int minLength(String s1, int n) { \n \tStackstack=new Stack();\n \t\n \tfor(int i=0;i 255)\n return false;\n temp.clear();\n count++;\n }\n else\n temp.push_back(op[i]);\n }\n \n if(temp[0] == '0')\n {\n for(int i=1; i &ans)\n {\n if(ip.size() == 0)\n {\n if(isValid(op))\n ans.push_back(op);\n \n return;\n }\n \n if(op.size() == 0)\n {\n op.push_back(ip[0]);\n ip.erase(ip.begin()+0);\n }\n \n if(op[op.size()-1] == '.')\n {\n string opt = op + ip[0];\n ip.erase(ip.begin()+0);\n solve(ip,opt,ans);\n }\n else\n {\n \n string op1 = op + '.';\n solve(ip,op1,ans);\n string op2 = op + ip[0];\n ip.erase(ip.begin()+0);\n solve(ip,op2,ans);\n }\n \n \n }\n \n vector genIp(string &s) {\n vector ans;\n if(s.size() < 4)\n ans.push_back(\"-1\");\n else\n {\n string op = \"\";\n solve(s,op,ans);\n if(ans.size() == 0)\n ans.push_back(\"-1\");\n }\n \n return ans;\n }\n\n};\n\n// Another approach\n\n// class Solution{\n// public:\n// vector ans;\n \n// bool isValidIp(string &s)\n// {\n// string temp = \"\";\n \n// for(int i=0; i 1 and temp[0] == '0'))\n// return false;\n \n// if(stoll(temp) > 255)\n// return false;\n \n// temp = \"\";\n// }\n// }\n \n// if(temp.empty() or (temp.length() > 1 and temp[0] == '0'))\n// return false;\n \n// if(stoll(temp) > 255)\n// return false;\n \n// return true;\n// }\n \n// void solve(string &s, int i, int cnt)\n// {\n// if(cnt == 3)\n// {\n// if(isValidIp(s))\n// ans.push_back(s);\n \n// return;\n// }\n \n// for(int p=i+1; p genIp(string &s) {\n// // Your code here\n// ans.clear();\n \n// if(s.length() >= 4 and s.length() <= 12)\n// solve(s, 0, 0);\n \n// if(ans.empty())\n// ans.push_back({\"-1\"});\n \n// return ans;\n// }\n\n// };\n" }, { "path": "Generate IP Addresses.java", "content": "class Solution {\n public ArrayList genIp(String s) {\n // code here\n ArrayList ans=new ArrayList<>();\n int n=s.length();\n if(n>12){\n ans.add(\"-1\");\n return ans;\n }\n for(int i=1;i3 || (s.charAt(0)=='0' && n>1) || Integer.parseInt(s)>255)return false;\n return true;\n \n }\n}\n" }, { "path": "Generate IP Addresses.py", "content": "class Solution:\n def genIp(self, s):\n n = len(s)\n arr = set()\n if len(s)<4: return []\n for i in range(1, n):\n if int(s[:i]) > 256 or str(int(s[:i])) != s[:i]:\n continue\n for j in range(i+1, n):\n if int(s[i:j]) > 256 or str(int(s[i:j])) != s[i:j]: continue\n for k in range(j+1, n):\n if int(s[j:k]) > 256 or str(int(s[j:k])) != s[j:k]: continue\n if int(s[k:]) > 256 or str(int(s[k:])) != s[k:]: continue\n \n ipAdd = s[:i] + \".\" + s[i:j] + \".\" + s[j:k]+ \".\" + s[k:]\n arr.add(ipAdd)\n return list(arr)\n" }, { "path": "Generate all Parentheses II.java", "content": "public class Solution {\n \n private ArrayList res;\n \n\tpublic ArrayList generateParenthesis(int A) {\n\t res = new ArrayList<>();\n\t StringBuilder str = new StringBuilder();\n\t rec(0, 0, 0, str, A);\n\t return res;\n\t}\n\t\n\tpublic void rec(int leftCount, int rightCount, int index, StringBuilder str, int n) {\n\t if (leftCount > n || rightCount > n)return; \n\t if (rightCount > leftCount)return;\n\t \n\t if (index == 2 * n) {\n\t res.add(str.toString());\n\t return;\n\t }\n\t \n\t str.append('(');\n\t rec(leftCount + 1, rightCount, index + 1, str, n);\n\t str.deleteCharAt(str.length() - 1);\n\t \n\t str.append(')');\n\t rec(leftCount, rightCount + 1, index + 1, str, n);\n\t str.deleteCharAt(str.length() - 1);\n\t \n\t}\n\t\n\t\n}\n" }, { "path": "Get min at pop.java", "content": "\nclass GetMin\n{\n //Function to push all the elements into the stack.\n public static Stack _push(int arr[],int n)\n {\n // your code here\n Stack s=new Stack<>();\n s.push(arr[0]);\n \n for(int i=1;is)\n {\n // your code here\n while(!s.isEmpty()){\n System.out.print(s.pop()+\" \");\n }\n }\n}\n" }, { "path": "Greater of Lesser.java", "content": "public class Solution {\n public int solve(ArrayList A, ArrayList B, int C) {\n int i=0;\n int j=0;\n for(int num:A){\n if(num>C)i++;\n }\n for(int num:B){\n if(nummax){\n ans++;\n max=A[i];\n }\n }\n return ans;\n }\n}\n" }, { "path": "Hamiltonian Path - GFG/README.md", "content": "# Hamiltonian Path\n## Medium\n

A Hamiltonian path, is a path in an undirected graph that visits each vertex exactly once. Given an undirected graph, the task is to check if a Hamiltonian path is present in it or not.

\n\n

Example 1:

\n\n
Input:\nN = 4, M = 4\nEdges[][]= { {1,2}, {2,3}, {3,4}, {2,4} }\nOutput:\n1 \nExplanation: \nThere is a hamiltonian path: \n1 -> 2 -> 3 -> 4
\n\n

Example 2:

\n\n
Input:\nN = 4, M = 3 \nEdges[][] = { {1,2}, {2,3}, {2,4} } \nOutput: \n0 \nExplanation: \nIt can be proved that there is no \nhamiltonian path in the given graph\n
\n\n

Your task:
\nYou don't need to read input or print anything. Your task is to complete the function check() which takes the N (the number of vertices), M (Number of edges) and the list of Edges[][] (where Edges[i] denotes the undirected Edge between vertices Edge[i][0] and Edges[i][1] ) as input parameter and returns true (boolean value) if the graph contains Hamiltonian path,otherwise returns false. 

\n\n


\nExpected Time Complexity: O(N!).
\nExpected Auxiliary Space: O(N+M).

\n\n


\nConstraints:
\n1 ≤ N ≤ 10
\n1 ≤ M ≤ 15
\nSize of Edges[i] is 2
\n1 ≤ Edges[i][0],Edges[i][1] ≤ N

\n
" }, { "path": "Hamiltonian Path - GFG/hamiltonian-path.java", "content": "//{ Driver Code Starts\n//Initial Template for Java\nimport java.io.*;\nimport java.util.*; \nclass GFG{\n public static void main(String args[]) throws IOException { \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n \n while(t-- > 0){\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n int M = Integer.parseInt(input_line[1]);\n \n input_line = read.readLine().trim().split(\"\\\\s+\");\n ArrayList> Edges = new ArrayList>(); \n for(int i = 0; i < M; i++){\n ArrayList e = new ArrayList();\n e.add(Integer.parseInt(input_line[2*i]));\n e.add(Integer.parseInt(input_line[2*i+1]));\n Edges.add(e);\n }\n Solution ob = new Solution();\n if(ob.check(N, M, Edges)){\n System.out.println(1);\n }\n else{\n System.out.println(0);\n }\n }\n } \n} \n// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution \n{ \n int n;\n boolean check(int N, int M, ArrayList> Edges) \n { \n // code here\n n=N;\n Map> map=new HashMap<>();\n for(ArrayList edge:Edges){\n int src=edge.get(0);\n int des=edge.get(1);\n map.putIfAbsent(src,new ArrayList<>());\n map.putIfAbsent(des,new ArrayList<>());\n map.get(src).add(des);\n map.get(des).add(src);\n }\n \n Set set=new HashSet<>();\n for(int node=1;node<=N;node++){\n if(dfs(node,set,map)){\n return true;\n }\n }\n return false;\n }\n boolean dfs(int curr,Set set,Map> map){\n set.add(curr);\n if(set.size()==n){\n return true;\n }\n \n for(int neb:map.get(curr)){\n if(!set.contains(neb) && dfs(neb,set,map)){\n return true;\n }\n }\n \n set.remove(curr);//back..\n return false;\n }\n} " }, { "path": "Height Using Parent Array.java", "content": "class Solution{\n static int findHeight(int N, int arr[]){\n int h=1;\n int k=arr[N-1];\n while(arr[k]!=-1){\n k=arr[k];\n h++;\n }\n return h+1;\n }\n}\n" }, { "path": "Highest Product.java", "content": "public class Solution {\n public int maxp3(int[] A) {\n int n=A.length;\n Arrays.sort(A);\n int ans=Math.max(A[0]*A[1]*A[n-1],A[n-3]*A[n-1]*A[n-2]);\n return ans;\n }\n}\n" }, { "path": "Highest Score.java", "content": "public class Solution {\n public int highestScore(String[][] A) {\n HashMap totalMarks=new HashMap<>();\n HashMap freqMarks=new HashMap<>();\n for(String x[]:A){\n long marks=Long.parseLong(x[1]);\n if(totalMarks.containsKey(x[0])){\n Long val=totalMarks.get(x[0]);\n long freq=freqMarks.get(x[0]);\n totalMarks.put(x[0],(Long)val+marks);\n freqMarks.put(x[0],++freq);\n }else{\n totalMarks.put(x[0],marks);\n freqMarks.put(x[0],1L);\n }\n }\n long max=Integer.MIN_VALUE;\n for(String x[]:A){\n long sum=totalMarks.get(x[0]);\n long freq=freqMarks.get(x[0]);\n max=Math.max(max,(sum/freq));\n }\n return (int)max;\n }\n}\n\n" }, { "path": "Hit most Balloons.java", "content": "class Solution {\n public int mostBalloons(int N, int arr[][]) {\n int ans=0;\n for(int i=0;i hm=new HashMap<>();\n int count=0;\n for(int j=0;j A) {\n ArrayListl=new ArrayList<>();\n l.add(A.get(0));\n int ans=0;\n \n for(int i=1;i max_of_subarrays(vector arr, int n, int k) {\n // your code here\n vector ans;\n priority_queue> pq;\n for(int i=0; i max_of_subarrays(vector arr, int n, int k) {\n // your code here\n vector ans;\n deque dq;\n \n for(int i=0; i max_of_subarrays(int arr[], int n, int k) {\n // Your code here\n ArrayListans=new ArrayList<>();\n Dequeq=new LinkedList<>();\n for(int i=0;i0 && i-q.peek()>=k){\n q.removeFirst();\n }\n \n while(q.size()>0 && arr[q.getLast()]<=arr[i]){\n q.removeLast();\n }\n q.addLast(i);\n if(i>=k-1)ans.add(arr[q.peek()]);\n }\n \n return ans;\n }\n}\n" }, { "path": "IPL 2021 - Match Day 2.py", "content": "#User function Template for python3\n\nclass Solution:\n def max_of_subarrays(self,arr,n,k):\n '''\n you can use collections module here.\n :param a: given array\n :param n: size of array\n :param k: value of k\n :return: A list of required values \n '''\n #code here\n def arr_max_ind(array, start, end):\n m_ind, m_ele = start, array[start]\n for i in range(start, end):\n if array[i]>=m_ele:\n m_ele = array[i]\n m_ind = i\n return [m_ele, m_ind]\n \n strategy = []\n max_ele, max_ind = arr_max_ind(arr, 0, k)\n for i in range(k, n+1):\n start, end = i-k, k\n if max_ind=i-k:\n if arr[i-1]>max_ele:\n max_ele = arr[i-1]\n max_ind = i-1\n else:\n max_ele, max_ind = arr_max_ind(arr, i-k, i)\n \n strategy.append(max_ele)\n \n return strategy\n" }, { "path": "Identical Binary Trees.java", "content": "public class Solution {\n public int isSameTree(TreeNode A, TreeNode B) {\n if(equal(A,B)){\n return 1;\n }else{\n return 0;\n }\n }\n public boolean equal(TreeNode a,TreeNode b){\n if(a==null && b==null)return true;\n if((a==null && b!=null) || (a!=null && b==null))return false;\n if(a.val!=b.val)return false;\n return equal(a.left,b.left) && equal(a.right,b.right);\n }\n}\n" }, { "path": "Immediate Smaller Element.java", "content": "class Solution {\n void immediateSmaller(int arr[], int n) {\n // code here\n for(int i=0;iarr[i+1]){\n arr[i]=arr[i+1];\n }else{\n arr[i]=-1;\n }\n }\n arr[n-1]=-1;\n }\n}\n" }, { "path": "Immediate Smaller Element.js", "content": "class Solution {\n immediateSmaller(arr,n){\n //code here\n // loop iterates to last numbers\n \t for(let i=0; i0){\n if((y&1)!=0)res=(res*x)%d; //if y is odd then result will be mul by \"a\"\n y=y>>1; // y=y/2\n x=(x*x)%d; // x=x^2 : eg. x^8 = (x^2)^4\n }\n return (int)((d+res)%d);// for -ve testcases d is added in res\n\t}\n}\n" }, { "path": "Implement StrStr.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public int strStr(final String A, final String B) {\n for(int i=0;i<=A.length()-B.length();i++){\n if(A.charAt(i)==B.charAt(0)){\n if(B.equals(A.substring(i,i+B.length()))){\n return i;\n }\n }\n }\n return -1;\n }\n}\n" }, { "path": "Implementing Dijkstra Algorithm.java", "content": "class Solution\n{\n //Function to find the shortest distance of all the vertices\n //from the source vertex S.\n static int[] dijkstra(int V, ArrayList>> adj, int S)\n {\n // distance of all numbers from source\n int[] distance=new int[V];\n //currently we don't know so filling maximum distance\n for(int i=0;i> pq=new PriorityQueue<>(\n new Comparator>(){\n @Override\n public int compare(ArrayList a1,ArrayList a2){\n return a1.get(0)-a2.get(0);\n }\n }\n );\n //adding first pair into our priority queue\n ArrayList a=new ArrayList<>();\n a.add(0);\n a.add(S);\n pq.add(a);\n while(!pq.isEmpty()){\n //getting the smallest distance in pq\n ArrayList arr=pq.remove();\n int currDistance=arr.get(0);\n int number=arr.get(1);\n //if that number was not already traversed then do it\n if(!selected[number]){\n //get all connected pairs for that particular number\n ArrayList> connecteds=adj.get(number);\n for(int i=0;i newList=new ArrayList<>();\n newList.add(newDistance);\n newList.add(connectedNumber);\n pq.add(newList);\n }\n }\n //mark the number as selected\n selected[number]=true;\n }\n }\n return distance;\n }\n}\n\n\n\n\n=======================================================================================================================================\n \n//without using arraylist and comparator ::\n \nclass Solution\n{\n //Function to find the shortest distance of all the vertices\n //from the source vertex S.\n static int[] dijkstra(int V, ArrayList>> adj, int S)\n {\n // distance of all numbers from source\n int[] distance=new int[V];\n //currently we don't know so filling maximum distance\n Arrays.fill(distance,Integer.MAX_VALUE);\n \n //ditance to source will be 0\n distance[S]=0;\n \n //boolean array to check if already a number is selected or not and also to reduce time\n // boolean[] selected=new boolean[V];\n \n //priority queue to always give smallest distance from one number\n PriorityQueue pq=new PriorityQueue<>();\n pq.add(S);\n \n while(!pq.isEmpty()){\n //getting the element from pq\n int number=pq.remove();\n int currDistance=distance[number];\n //get all connected pairs for that particular number\n ArrayList> connecteds=adj.get(number);\n for(int i=0;ij)return null;\n int temp=i;\n int max=Integer.MIN_VALUE;\n int idx=0;\n while(temp<=j){\n if(a[temp]>max){\n max=a[temp];\n idx=temp;\n }\n temp++;\n }\n TreeNode node=new TreeNode(a[idx]);\n node.left=dfs(a,i,idx-1);\n node.right=dfs(a,idx+1,j);\n return node;\n }\n}\n" }, { "path": "Inorder linear Traversal.java", "content": "public class Solution {\n public ArrayList inorderTraversal(TreeNode A) {\n ArrayList list=new ArrayList<>();\n Map map=new HashMap<>();\n Deque stack=new ArrayDeque<>();\n stack.push(A);\n map.put(A,false);\n while(!stack.isEmpty()){\n TreeNode node=stack.pop();\n if(map.get(node)==false){\n if(node.right!=null){\n stack.push(node.right);\n map.put(node.right,false);\n }\n stack.push(node);\n if(node.left!=null){\n stack.push(node.left);\n map.put(node.left,false);\n }\n map.put(node,true);\n }else{\n list.add(node.val);\n } \n }\n return list;\n }\n}\n" }, { "path": "Insert into a Binary Search Tree", "content": "class Solution {\n public TreeNode insertIntoBST(TreeNode root, int val) {\n if(root==null)return new TreeNode(val);\n return addNode(root,root,val);\n }\n public TreeNode addNode(TreeNode head,TreeNode root,int val){\n if(root.val>val){\n if(root.left==null){\n root.left=new TreeNode(val);\n return head;\n }else{\n return addNode(head,root.left,val);\n }\n }else if(root.val in.val) {\n //if there is some faulty node, 'en insert it b/w prev and temp\n prev.next = in ; in.next = temp;\n return;\n }\n prev = temp;\n temp = temp.next;\n }\n prev.next = in;\n //make sure to cut off some extra nodes\n in.next = null;\n return;\n }\n}\n" }, { "path": "Insertion Sort for Singly Linked List.java", "content": "class Solution\n{\n public static Node insertionSort(Node head){\n Node newHead=new Node(-1);\n Node temp=head;\n while(temp!=null){\n Node newtemp=newHead;\n Node toAdd=temp;\n temp=temp.next;\n toAdd.next=null;\n if(newtemp.next==null){\n newtemp.next=toAdd;\n }else{\n while(newtemp!=null){\n if(newtemp.next==null){\n break;\n }\n if(newtemp.next.data=0;i--){\n if(str.charAt(i)!='0'){\n num=str.substring(i);\n break;\n }\n }\n String roman=getRoman(Integer.parseInt(num));\n sb.insert(0,roman);\n A-=Integer.parseInt(num);\n }\n return sb.toString();\n }\n public String getRoman(int a){\n switch(a){\n case 1:\n return \"I\";\n case 2:\n return \"II\";\n case 3:\n return \"III\";\n case 4:\n return \"IV\";\n case 5:\n return \"V\";\n case 6:\n return \"VI\";\n case 7:\n return \"VII\";\n case 8:\n return \"VIII\";\n case 9:\n return \"IX\";\n case 10:\n return \"X\";\n case 20:\n return \"XX\";\n case 30:\n return \"XXX\";\n case 40:\n return \"XL\";\n case 50:\n return \"L\";\n case 60:\n return \"LX\";\n case 70:\n return \"LXX\";\n case 80:\n return \"LXXX\";\n case 90:\n return \"XC\";\n case 100:\n return \"C\";\n case 200:\n return \"CC\";\n case 300:\n return \"CCC\";\n case 400:\n return \"CD\";\n case 500:\n return \"D\";\n case 600:\n return \"DC\";\n case 700:\n return \"DCC\";\n case 800:\n return \"DCCC\";\n case 900:\n return \"CM\";\n case 1000:\n return \"M\";\n case 2000:\n return \"MM\";\n case 3000:\n return \"MMM\";\n }\n return \"\";\n }\n}\n" }, { "path": "Integers in Strings.java", "content": "public class Solution {\n public ArrayList solve(String A) {\n ArrayList arr=new ArrayList<>();\n String[] ar=A.split(\",\");\n for(int i=0;i intersect(final List a, final List b) {\n ArrayList ans=new ArrayList<>();\n int i=0;\n int j=0;\n while(isizeA){\n //move b diff times\n int diff=sizeB-sizeA;\n while(diff--!=0){\n tempB=tempB.next;\n }\n }else if(sizeA>sizeB){\n //move a diff times\n int diff=sizeA-sizeB;\n while(diff--!=0){\n tempA=tempA.next;\n }\n }\n\n //move untill they meet or they become null\n while(tempA!=tempB && tempA!=null && tempB!=null){\n tempA=tempA.next;\n tempB=tempB.next;\n }\n \n if(tempA==null || tempB==null)return null;\n return tempB;\n\t}\n}\n" }, { "path": "Interviewbit/Colorful Number/Colorful Number.java", "content": "public class Solution {\n public int colorful(int num) {\n Set set=new HashSet<>();\n String s=Integer.toString(num);\n for(int i=0;i8:\n return 0\n digitset={ch for ch in A}\n if len(digitset)!=len(A):\n return 0\n if ('1' in digitset) or ('0' in digitset):\n return 0\n if '2' not in digitset:\n return 1\n\n bigrams={A[i:i+2] for i in range(len(A)-1)}\n if ('23'in bigrams or '32' in bigrams) and '6' in digitset:\n return 0\n if ('24'in bigrams or '42' in bigrams) and '8' in digitset:\n return 0\n if ('26'in bigrams or '62' in bigrams) and ('43' in bigrams or '34' in bigrams):\n return 0\n \n return 1\n" }, { "path": "Interviewbit/Copy List/Copy List.java", "content": "/**\n * Definition for singly-linked list with a random pointer.\n * class RandomListNode {\n * int label;\n * RandomListNode next, random;\n * RandomListNode(int x) { this.label = x; }\n * };\n */\npublic class Solution {\n public RandomListNode copyRandomList(RandomListNode head) {\n Map map=new HashMap<>();\n RandomListNode temp=head;\n while(temp!=null){\n map.put(temp,new RandomListNode(temp.label));\n temp=temp.next;\n }\n temp=head;\n RandomListNode newHead=map.get(head);\n while(temp!=null){\n if(temp.next!=null){\n map.get(temp).next=map.get(temp.next);\n }\n map.get(temp).random=map.get(temp.random);\n temp=temp.next;\n }\n return newHead;\n }\n}\n" }, { "path": "Interviewbit/Valid Sudoku/Valid Sudoku.cpp", "content": "int Solution::isValidSudoku(const vector &A) {\n vector> row(9);\n vector> col(9);\n vector> box(9);\n \n for(int i=0;i<9;i++){\n for(int j=0;j<9;j++){\n \n if(A[i][j] != '.'){\n char curr = A[i][j];\n \n if(row[i].find(curr) != row[i].end())\n return 0;\n else row[i].insert(curr);\n \n \n if(col[j].find(curr) != col[j].end())\n return 0;\n else col[j].insert(curr);\n \n int index = i - i%3 + j/3;\n if(box[index].find(curr) != box[index].end())\n return 0;\n else box[index].insert(curr);\n \n }\n }\n }\n \n return 1;\n}\n" }, { "path": "Interviewbit/Valid Sudoku/Valid Sudoku.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public int isValidSudoku(final String[] A) {\n char[][] board=new char[9][9];\n for(int i=0;i<9;i++){\n for(int j=0;j<9;j++){\n board[i][j]=A[i].charAt(j);\n }\n }\n for(int i=0;i<9;i++){\n Set row=new HashSet<>();\n Set col=new HashSet<>();\n Set cube=new HashSet<>();\n int rowindex=(i/3)*3,colindex=(i%3)*3;\n for(int j=0;j<9;j++){\n if(board[i][j]!='.'&&!(row.add(board[i][j])))\n return 0;\n if(board[j][i]!='.'&&!(col.add(board[j][i])))\n return 0;\n if(board[rowindex+j/3][colindex+j%3]!='.'&&!(cube.add(board[rowindex+j/3][colindex+j%3])))\n return 0;\n }\n \n }\n return 1;\n }\n}\n\n" }, { "path": "Invert the Binary Tree.java", "content": "public class Solution {\n public TreeNode invertTree(TreeNode A) {\n if(A==null)return null;\n TreeNode le=null;\n if(A.left!=null){\n le=invertTree(A.left);\n }\n TreeNode ri=null;\n if(A.right!=null){\n ri=invertTree(A.right);\n }\n A.left=ri;\n A.right=le;\n return A;\n }\n}\n" }, { "path": "Is Subsequence.java", "content": "class Solution {\n public boolean isSubsequence(String s, String t) {\n int i = 0;\n for(int j = 0;j=0;i--)\n {\n step++;\n if(A[i]>=step)step=0;\n }\n if(step==0)return 1;\n return 0;\n } \n}\n" }, { "path": "Jump Game IV", "content": "class Solution {\n public int minJumps(int[] arr) {\n if (arr.length == 1) return 0;\n if (arr[0] == arr[arr.length - 1] || arr.length == 2) return 1;\n if (arr[0] == arr[arr.length - 2]) return 2;\n \n Queue q = new LinkedList<>();\n \n HashMap> ind = new HashMap<>();\n \n \n for (int i = 0; i < arr.length; i++) {\n if (!ind.containsKey(arr[i])) {\n ind.put(arr[i], new ArrayList<>());\n }\n ind.get(arr[i]).add(i);\n }\n \n \n \n q.add(arr.length - 1);\n boolean[] seen = new boolean[arr.length];\n int level = 0;\n while (!q.isEmpty()) {\n \n int sz = q.size();\n for (int s = 0; s < sz; s++) {\n int state = q.poll();\n\n if (state == 0) return level;\n\n if (state + 1 < arr.length && !seen[state + 1]) {\n seen[state + 1] = true;\n if (state + 1 == 0) return level + 1;\n \n q.add(state + 1);\n }\n \n if (state - 1 >= 0 && !seen[state - 1]) {\n seen[state - 1] = true;\n if (state - 1 == 0) return level + 1;\n q.add(state - 1);\n }\n\n\n List same = ind.get(arr[state]); \n for (int i : same) {\n if (i == state || seen[i]) continue;\n seen[i] = true;\n if (i == 0) return level + 1;\n q.add(i);\n }\n }\n level++;\n }\n \n \n return -1;\n }\n}\n" }, { "path": "K Largest Elements.java", "content": "public class Solution {\n public ArrayList solve(ArrayList A, int B) {\n Collections.sort(A);\n ArrayList ans=new ArrayList<>();\n for(int i=A.size()-1;i>=A.size()-B;i--){\n ans.add(A.get(i));\n }\n return ans;\n }\n}\n" }, { "path": "K-diff Pairs in an Array.java", "content": "class Solution {\n public int findPairs(int[] nums, int k) {\n Arrays.sort(nums);\n \n int i = 0;\n int n = nums.length;\n int j = 0;\n int count = 0;\n \n while(j < n) {\n j = i + 1;\n \n while(j < n && nums[j] - nums[i] < k) {\n j++;\n }\n \n if (j < n && nums[j] - nums[i] == k) {\n count++;\n }\n \n while(i + 1 < n && nums[i+1] == nums[i]) {\n i++;\n }\n i++;\n }\n return count;\n }\n}\n\n================================================================================\n \n class Solution {\n \t\tpublic int findPairs(int[] nums, int k) {\n \t\t\tMap map = new HashMap();\n \t\t\tfor (int num : nums)\n \t\t\t\tmap.put(num, map.getOrDefault(num, 0) + 1);\n\n \t\t\tint result = 0;\n \t\t\tfor (int i : map.keySet())\n \t\t\t\tif (k > 0 && map.containsKey(i + k) || k == 0 && map.get(i) > 1)\n \t\t\t\t\tresult++;\n \t\t\treturn result;\n \t\t}\n \t}\n" }, { "path": "Kill Captain America - GFG/README.md", "content": "# Kill Captain America\n## Hard \n
\n

Captain America is hiding from Thanos in a maze full of N rooms connected by M gates.
\nThe maze is designed in such a way that each room leads to another room via gates. All connecting gates are unidirectional. Captain America is hiding only in those rooms which are accessible directly/indirectly through every other room in the maze.
\nHelp Thanos find the number of rooms in which Captain America can hide. 

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 5 and M = 5\nV = [[1, 2], [2, 3], [3, 4], [4, 3], [5, 4]]\nOutput: 2\nExplanation:\n\"\"\nWe can look closesly after forming graph \nthan captain america only can hide in a \nroom 3 and 4 because they are the only room \nwhich have gates through them. So,\nanswer is 2.\n\n
\n\n

Example 2:

\n\n
Input:\nN = 2, M = 1\nV = [[1, 2]]\nOutput: 1\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function captainAmerica() which takes the integer N, an integer M and 2-d array V as input parameters and returns the Total no of rooms.
\n
\nExpected Time Complexity: O(N+M)
\nExpected Auxiliary Space: O(N+M)

\n\n

 

\n\n

Constraints:
\n1 ≤ n ≤ 30000
\n1 ≤ m ≤ 200000
\n1 ≤ p,q ≤ n

\n

\n
" }, { "path": "Kill Captain America - GFG/kill-captain-america.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n int M = Integer.parseInt(input_line[1]);\n int V[][] = new int[M+1][2];\n for(int i=0;i> adj = new ArrayList<>();\n \n for(int i=0; i<=N; i++)\n {\n adj.add(new ArrayList<>());\n }\n \n for(int i=0; i q = new ArrayDeque<>();\n boolean visited[] = new boolean[N+1];\n \n visited[mainNd] = true;\n \n q.add(mainNd);\n \n int count = 1;\n \n while(!q.isEmpty())\n {\n int nd = q.poll();\n \n for(int nei : adj.get(nd))\n {\n if(visited[nei]==false)\n {\n count++;\n visited[nei]=true;\n q.add(nei);\n }\n }\n \n }\n \n \n return count;\n }\n \n}" }, { "path": "Killing Spree - GFG/README.md", "content": "# Killing Spree\n## Medium \n
\n

There are Infinite People Standing in a row, indexed from 1.
\nA person having index 'i' has strength of (i*i).
\nYou have Strength 'P'. You need to tell what is the maximum number of People You can Kill With your Strength P.
\nYou can only Kill a person with strength 'X' if P >= 'X'  and after killing him, Your Strength decreases by 'X'. 
\n 

\n\n

Example 1:

\n\n
Input:\nN = 14\nOutput: 3\nExplanation:\nThe strengths of people is 1, 4, 9, 16, .... \nand so on. WE can kill the first 3 person , \nafter which our Power becomes 0 and we cant \nkill anyone else. So answer is 3\n
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 10\nOutput: 2\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function killinSpree() which takes the integer N as input parameters and returns the maximum Number of People You can kill.
\n
\nExpected Time Complexity: O(log(n))
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n1 ≤ T ≤ 103
\n1 ≤ N ≤ 1012

\n

\n
" }, { "path": "Killing Spree - GFG/killing-spree.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n long N = Long.parseLong(input_line[0]);\n Solution ob = new Solution();\n long ans = ob.killinSpree(N);\n System.out.println(ans);\n }\n }\n}\n\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n \n long killinSpree(long n)\n {\n long low=1;\n long high=(long)Math.sqrt(n);\n long ans=0;\n while(low<=high){\n long mid=low+(high-low)/2;\n long sum=(mid*(mid+1)*(2*mid + 1))/6;\n if(sum==n)return mid;\n else if(sum B) {\n Arrays.fill(fact, i, A, B + 1);\n break;\n }\n }\n\n List dig = new ArrayList<>();\n for (int i = 1; i <= A; i++)\n dig.add(i);\n\n StringBuilder res = new StringBuilder();\n \n for (; A > 0; A--) {\n int pos = (B / fact[A - 1]);\n res.append(dig.get(pos));\n dig.remove(pos);\n B = (B % fact[A - 1]);\n }\n\n return res.toString();\n }\n}\n\n" }, { "path": "Kth Row of Pascal's Triangle.java", "content": "public class Solution {\n public int[] getRow(int a) {\n int[] res = new int[a+1];\n\t res[0]=1;\n\t res[a]=1;\n for(int i=1; i=k);\n }\n}\n" }, { "path": "Kth Smallest Element In Tree.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n static int count, result;\n public int kthsmallest(TreeNode root, int B) {\n count = 0;\n result = Integer.MIN_VALUE;\n inorder(root,B);\n return result;\n }\n public static void inorder(TreeNode root,int k){\n if(root == null){\n return;\n }\n inorder(root.left,k);\n count++;\n if(count == k){\n result = root.val;\n return;\n }\n inorder(root.right,k);\n }\n}\n\n" }, { "path": "Kth smallest element.cpp", "content": "class Solution{\n public:\n // arr : given array\n // l : starting index of the array i.e 0\n // r : ending index of the array i.e size-1\n // k : find kth smallest element and return using this function\n int kthSmallest(int arr[], int l, int r, int k) {\n //code here\n int n=r+1;\n sort(arr,arr+n);\n return arr[k-1];\n }\n};\n" }, { "path": "LC 1000. Minimum Cost to Merge Stones.cpp", "content": "class Solution {\npublic:\n\n\n// This problem comes under the category of partition dp.\n\n int mergeStones(vector &stones, int k)\n{\n int n = stones.size();\n \n // Condition to check if it's possible to merge all piles of stones into a single pile\n if ((n - 1) % (k - 1) != 0)\n return -1;\n vector prefixSum(n + 1);\n prefixSum[0] = 0;\n prefixSum[1] = stones[0];\n for (int i = 2; i <= n; i++)\n {\n prefixSum[i] = prefixSum[i - 1] + stones[i - 1];\n }\n vector> dp(n, vector(n, 0));\n for (int i = n - 1; i >= 0; i--)\n {\n for (int j = i+1; j <= n - 1; j++)\n {\n int mini = 1e9;\n for (int idx = i; idx < j; idx = idx + k - 1)\n {\n int cost = dp[i][idx] + dp[idx + 1][j];\n mini = min(cost, mini);\n }\n if((j-i)%(k-1) == 0){\n mini += prefixSum[j+1] - prefixSum[i];\n }\n dp[i][j] = mini;\n }\n }\n return dp[0][n - 1];\n}\n\n};\n" }, { "path": "LCP - GFG/README.md", "content": "# LCP\n## Medium \n
\n

Note: This POTD is a part of Geek Summer Carnival. Solve all POTD consecutively from 5th to 10th April and get a chance to win exclusive discount vouchers on our GfG courses.

\n\n
\n

Geek is at the geek summer carnival. He is given an array of N strings. To unlock exclusive course discounts he needs to find the longest common prefix among all strings present in the array. Can you help him ?

\n\n


\nExample 1:

\n\n
Input:\nN = 4\nar[] = {geeksforgeeks, geeks, geek, geezer}\n\nOutput:\ngee\n\nExplanation: \nLongest common prefix in all the given string is gee.
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 3\nar[] = {apple, ape, april}\n\nOutput:\nap
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Complete the function LCP() that takes integer n and ar[] as input parameters and return the LCP. 

\n\n

 

\n\n

Expected time complexity: O(NlogN)
\nExpected space complexity: O(string length)

\n\n


\nConstraints:
\n1 <= N <= 10^3
\n1 <= String Length <= 100

\n

\n
" }, { "path": "LCP - GFG/lcp.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nimport java.math.*;\n\nclass GFG\n{\n public static void main(String args[])\n {\n Scanner sc = new Scanner(System.in);\n int t = Integer.parseInt(sc.next());\n \n while(t-- > 0)\n {\n int n = Integer.parseInt(sc.next());\n \n String s[] = new String[n];\n for(int i=0;ia.length()-b.length());\n String ans=s[0];\n for(int i=1;i\n

Given a binary tree. Find the size of its largest subtree that is a Binary Search Tree.
\nNote: Here Size is equal to the number of nodes in the subtree.

\n\n

Example 1:

\n\n
Input:\n        1\n      /   \\\n     4     4\n   /   \\\n  6     8\nOutput: 1\nExplanation: There's no sub-tree with size\ngreater than 1 which forms a BST. All the\nleaf Nodes are the BSTs with size equal\nto 1.\n
\n\n

Example 2:

\n\n
Input: 6 6 3 N 2 9 3 N 8 8 2\n            6\n        /       \\\n       6         3\n        \\      /   \\\n         2    9     3\n          \\  /  \\\n          8 8    2 \nOutput: 2\nExplanation: The following sub-tree is a\nBST of size 2: \n       2\n    /    \\ \n   N      8
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function largestBst() that takes the root node of the Binary Tree as its input and returns the size of the largest subtree which is also the BST. If the complete Binary Tree is a BST, return the size of the complete Binary Tree. 

\n\n

Expected Time Complexity: O(N).
\nExpected Auxiliary Space: O(Height of the BST).

\n\n

Constraints:
\n1 ≤ Number of nodes ≤ 105
\n1 ≤ Data of a node ≤ 106

\n

\n " }, { "path": "Largest BST - GFG/largest-bst.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\nimport java.math.*;\n\nclass Node \n{ \n int data; \n Node left, right; \n \n public Node(int d) \n { \n data = d; \n left = right = null; \n } \n}\n\nclass GFG\n{\n static Node buildTree(String str)\n {\n // Corner Case\n if(str.length() == 0 || str.equals('N'))\n return null;\n String[] s = str.split(\" \");\n \n Node root = new Node(Integer.parseInt(s[0]));\n Queue q = new LinkedList();\n q.add(root);\n \n // Starting from the second element\n int i = 1;\n while(!q.isEmpty() && i < s.length)\n {\n // Get and remove the front of the queue\n Node currNode = q.remove();\n \n // Get the curr node's value from the string\n String currVal = s[i];\n \n // If the left child is not null\n if(!currVal.equals(\"N\")) \n {\n \n // Create the left child for the curr node\n currNode.left = new Node(Integer.parseInt(currVal));\n \n // Push it to the queue\n q.add(currNode.left);\n }\n \n // For the right child\n i++;\n if(i >= s.length)\n break;\n currVal = s[i];\n \n // If the right child is not null\n if(!currVal.equals(\"N\")) \n {\n \n // Create the right child for the curr node\n currNode.right = new Node(Integer.parseInt(currVal));\n \n // Push it to the queue\n q.add(currNode.right);\n }\n \n i++;\n }\n \n return root;\n }\n \n public static void main(String args[]) throws IOException {\n \n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine().trim());\n while(t>0)\n {\n String s = br.readLine();\n Node root = buildTree(s);\n \n Solution T = new Solution();\n System.out.println(T.largestBst(root));\n \n t--;\n }\n }\n}\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\n// class Node \n// { \n// int data; \n// Node left, right; \n \n// public Node(int d) \n// { \n// data = d; \n// left = right = null; \n// } \n// }\n\n\nclass Solution{\n static int ans;\n // Return the size of the largest sub-tree which is also a BST\n static int largestBst(Node root){\n if(root==null)return 0;\n ans=0;\n checkBST(root);\n return ans;\n }\n static boolean checkBST(Node root){\n if(root==null)return true;\n boolean isLeftBST=checkBST(root.left);\n boolean isRightBST=checkBST(root.right);\n boolean isLeftSmaller=true;\n boolean isRightLarger=true;\n if(root.left!=null && isLeftBST){\n if(getMAX(root.left)>=root.data)isLeftSmaller=false;\n }\n if(root.right!=null && isRightBST){\n if(getMIN(root.right)<=root.data)isRightLarger=false;\n }\n boolean isBST=isLeftSmaller && isRightLarger && isLeftBST && isRightBST;\n if(isBST){\n ans=Math.max(ans,count(root));\n }\n return isBST;\n }\n static int count(Node root){\n if(root==null)return 0;\n return 1+count(root.left)+count(root.right);\n }\n static int getMIN(Node root){\n if(root.left==null)return root.data;\n return getMIN(root.left);\n }\n static int getMAX(Node root){\n if(root.right==null)return root.data;\n return getMAX(root.right);\n }\n \n}" }, { "path": "Largest Number.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public String largestNumber(final List A) {\n Collections.sort(A,(a,b)->{\n String s1=Integer.toString(a);\n String s2=Integer.toString(b);\n return (s1+s2).compareTo(s2+s1)>0?-1:1;\n });\n StringBuilder sb=new StringBuilder();\n for(int i=0;i0; i++){\n if (A[i]!=len-i){\n A[position[len-i]] = A[i];\n int temp = position[A[i]];\n position[A[i]] = position[len-i];\n A[i] = len-i;\n B--;\n }\n }\n return A;\n }\n}\n" }, { "path": "Largest Rectangle in Histogram.java", "content": "class Solution {\n public int largestRectangleArea(int[] a) {\n int max=0;\n int ps[]=prevSmallest(a);\n int ns[]=nextSmallest(a);\n for(int i=0;i s=new ArrayDeque<>();\n for(int i=0;i=a[i]){\n s.pop();\n }\n if(s.isEmpty()){\n ps[i]=-1;\n }else{\n ps[i]=s.peek();\n }\n s.push(i);\n }\n return ps;\n }\n public int[] nextSmallest(int[]a){\n int ns[]=new int[a.length];\n Deque s=new ArrayDeque<>();\n for(int i=a.length-1;i>=0;i--){\n while(!s.isEmpty() && a[s.peek()]>=a[i]){\n s.pop();\n }\n if(s.isEmpty()){\n ns[i]=a.length;\n }else{\n ns[i]=s.peek();\n }\n s.push(i);\n }\n return ns;\n }\n}\n" }, { "path": "Largest number with given sum - GFG/README.md", "content": "# Largest number with given sum\n## Easy \n
\n

Geek lost the password of his super locker. He remembers the number of digits N as well as the sum S of all the digits of his password. He know that his password is the largest number of N digits that can be made with given sum S. As he is busy doing his homework, help him retrieving his password.

\n\n

Example 1:

\n\n
Input:\nN = 5, S = 12\nOutput:\n93000\nExplanation:\nSum of elements is 12. Largest possible \n5 digit number is 93000 with sum 12.\n
\n\n

Example 2:

\n\n
Input:\nN = 3, S = 29\nOutput:\n-1\nExplanation:\nThere is no such three digit number \nwhose sum is 29.
\n\n

Your Task : 
\nYou don't need to read input or print anything. Your task is to complete the function largestNumber() which takes 2 integers N and S as input parameters and returns the password in the form of string, else return \"-1\" in the form of string.

\n\n

Constraints:
\n1 ≤ N ≤ 104
\n0 ≤ S ≤ 9*104

\n\n

Expected Time Complexity : O(N)
\nExpected Auxilliary Space : O(1)

\n

\n
" }, { "path": "Largest number with given sum - GFG/largest-number-with-given-sum.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass Driverclass\n{\n public static void main(String args[])throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n \n //testcases\n\t\tint t = Integer.parseInt(br.readLine().trim());\n\t\t\n\t while(t-- >0)\n\t {\n\t String inputLine[] = br.readLine().trim().split(\" \");\n\t \n\t //taking n and sum\n int n = Integer.parseInt(inputLine[0]);\n int sum = Integer.parseInt(inputLine[1]);\n \n //calling largestNumber() function\n System.out.println(new Solution().largestNumber(n, sum));\n\t }\n }\n}// } Driver Code Ends\n\n\n\nclass Solution\n{\n //Function to return the largest possible number of n digits\n //with sum equal to given sum.\n static String largestNumber(int n, int sum){\n StringBuilder sb=new StringBuilder();\n while(n-->0){\n if(sum!=0){\n int num=9;\n while(sum0){\n num--;\n }\n sum-=num;\n sb.append(num);\n }else{\n sb.append(0);\n }\n }\n if(sum!=0)return \"-1\";\n return sb.toString();\n }\n}\n\n\n" }, { "path": "Largest prime factor.cpp", "content": "class Solution{\npublic: \nbool isPrime(int N){\n for(int i=2;i<=sqrt(N); i++){\n if(N % i==0) return false;\n }\n return true;\n}\n long long int largestPrimeFactor(int N){\n if(isPrime(N)) return N;\n long long int ans = 0;\n \n for(long long int i=N-1;i>=2;i--){\n if(N%i==0 && isPrime(i)) return i;\n // else cout< largestValues(Node root)\n {\n //code here\n Map map=new HashMap<>();\n dfs(root,1,map);\n ArrayList ans=new ArrayList<>();\n int level=1;\n while(map.containsKey(level)){\n ans.add(map.get(level));\n level++;\n }\n return ans;\n }\n public void dfs(Node root,int level,Map map){\n if(root==null)return;\n if(!map.containsKey(level)){\n map.put(level,root.data);\n }else{\n int cur=root.data;\n int init=map.get(level);\n map.put(level,Math.max(cur,init));\n }\n dfs(root.right,level+1,map);\n dfs(root.left,level+1,map);\n }\n}\n" }, { "path": "Last Node in a Complete Binary Tree.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n public int lastNode(TreeNode A) {\n Queue q=new LinkedList<>();\n q.add(A);\n int val=-1;\n while(q.size()>0){\n int sz=q.size();\n while(sz-->0){\n TreeNode node=q.remove();\n if(node.left!=null)q.add(node.left);\n if(node.right!=null)q.add(node.right);\n val=node.val;\n }\n }\n return val;\n }\n}\n" }, { "path": "Last digit K count.java", "content": "public class Solution {\n public int solve(int A, int B, int C) {\n while((A%10)!=C && AA){\n B--;\n }\n if(A==B && A%10!=C)return 0;\n return (B-A)/10+1;\n }\n\n}\n" }, { "path": "Leaders in an array.java", "content": "public class Solution {\n public ArrayList solve(ArrayList A) {\n int high=-1;\n ArrayList ans=new ArrayList<>();\n for(int i=A.size()-1;i>=0;i--){\n if(A.get(i)>high){\n high=A.get(i);\n ans.add(high);\n }\n }\n return ans;\n }\n}\n" }, { "path": "Leaves to DLL.java", "content": "class Tree{\n // return the head of the DLL and remove those node from the tree as well.\n public Node convertToDLL(Node root)\n {\n // Code here\n if(root==null)\n return null;\n ArrayList al=new ArrayList<>();\n solve(root,al);\n Node head=al.get(0);\n Node prev=al.get(0);\n for(int i=1;i al)\n {\n if(root==null)\n return null;\n \n if(root.right==null && root.left==null)\n {\n al.add(root);\n return null;\n }\n root.left=solve(root.left,al);\n root.right=solve(root.right,al);\n return root;\n }\n \n \n}\n" }, { "path": "Leetcode/104 maximum depth of binary tree/104 maximum depth of binary tree.cpp", "content": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode() : val(0), left(nullptr), right(nullptr) {}\n * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n int maxDepth(TreeNode* root) {\n if(root==NULL){\n return 0;\n }\n int h1=maxDepth(root->left);\n int h2=maxDepth(root->right);\n return 1+max(h1,h2);\n }\n};\n" }, { "path": "Leetcode/104 maximum depth of binary tree/104. Maximum Depth of Binary Tree.java", "content": "class Solution {\n public int maxDepth(TreeNode root) {\n // Base Condition\n if(root == null) return 0;\n // Hypothesis\n int left = maxDepth(root.left);\n int right = maxDepth(root.right);\n // Induction\n return Math.max(left, right) + 1;\n }\n}\n" }, { "path": "Leetcode/104 maximum depth of binary tree/README.md", "content": "

104. Maximum Depth of Binary Tree

Easy

Given the root of a binary tree, return its maximum depth.

\n\n

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.

\n\n

 

\n

Example 1:

\n\"\"\n
Input: root = [3,9,20,null,null,15,7]\nOutput: 3\n
\n\n

Example 2:

\n\n
Input: root = [1,null,2]\nOutput: 2\n
\n\n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the tree is in the range [0, 104].
    • \n\t
  • -100 <= Node.val <= 100
    • \n
\n
\n" }, { "path": "Leetcode/112 Path Sum/112 Path Sum oc4.cpp", "content": "#include\nusing namespace std;\nstruct TreeNode {\n int val;\n TreeNode *left;\n TreeNode *right;\n TreeNode() : val(0), left(nullptr), right(nullptr) {}\n TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}\n };\nclass Solution {\npublic:\n bool hasPathSum(TreeNode* root, int targetSum) {\n if(!root) return false;\n if(!root->left && !root->right && root->val == targetSum) return true;\n return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);\n }\n};" }, { "path": "Leetcode/112 Path Sum/Path Sum.java", "content": "Solution 1:\nUsing ArrayList\n\nclass Solution {\n public static void fun(TreeNode root, int sum , int val, ArrayListaa){\n if(root==null){\n return ;\n }\n else if(root.left==null && root.right==null){\n val=val+root.val;\n aa.add(val);\n return ;\n }\n else{\n fun(root.left,sum,val+root.val,aa);\n fun(root.right,sum,val+root.val,aa);\n }\n }\n public boolean hasPathSum(TreeNode root, int sum) {\n if(root==null){\n return false;\n }\n else{\n ArrayListaa=new ArrayList();\n fun(root,sum,0,aa);\n // System.out.println(aa);\n if(aa.contains(sum)){\n return true;\n }\n return false;\n }\n }\n}\n\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\n\nSolution 2:\nWithout Using ArrayList\n\nclass Solution {\n boolean status=false;\n public void fun(TreeNode root, int sum,int s, boolean status){\n if(root==null){\n return;\n }\n else if(root.left==null && root.right==null){\n s=s+root.val;\n if(s==sum){\n this.status=true;\n }\n }\n else{\n fun(root.left,sum,s+root.val,status);\n fun(root.right,sum,s+root.val,status);\n }\n }\n \n public boolean hasPathSum(TreeNode root, int sum) {\n if(root==null){\n return false;\n }\n else{\n \n fun(root,sum,0,status);\n if(status==true){\n return true;\n }\n return false;\n }\n }\n}\n" }, { "path": "Leetcode/1155. Number of Dice Rolls With Target Sum/1155 Number of Dice Rolls With Target Sum.cpp", "content": "#include\nusing namespace std;\n\n#define MOD 1000000007\nclass Solution {\npublic:\n long long solve(int dice, int faces, int target, vector> &dp){\n // top down appr\n if(target <0) return 0;\n if(dice ==0 and target != 0 || target==0 and dice !=0) return 0;\n if(target ==0 and dice ==0) return 1;\n if(dp[dice][target] != -1)\n return dp[dice][target];\n long long res =0;\n for(int i =1; i<= faces; i++){\n res = (res + solve(dice - 1, faces, target - i, dp))%MOD;\n }\n return dp[dice][target] = res;\n }\n int numRollsToTarget(int n, int k, int target) {\n vector> dp(n + 1, vector(target + 1, -1));\n return solve(n, k, target, dp);\n }\n};" }, { "path": "Leetcode/1155. Number of Dice Rolls With Target Sum/1155. Number of Dice Rolls With Target Sum.java", "content": "class Solution {\n static int MOD = (int)1e9 + 7;\n int helper(int n,int t,int k,int dp[][]){\n if(n < 0 || t < 0) return 0;\n if(n == 0 && t == 0) return 1;\n if(dp[n][t] != -1) return dp[n][t];\n int c_ans = 0;\n for(int i = 1;i <= k;i++){\n c_ans = (c_ans + helper(n - 1,t - i,k,dp)) % MOD;\n }\n return dp[n][t] = c_ans;\n }\n public int numRollsToTarget(int n, int k, int target) {\n int dp[][] = new int[n + 1][target + 1];\n for(var a:dp) Arrays.fill(a,-1);\n return helper(n,target,k,dp);\n }\n}" }, { "path": "Leetcode/1155. Number of Dice Rolls With Target Sum/1155. Number of Dice Rolls With Target Sum.py", "content": "class Solution:\n def numRollsToTarget(self, n: int, k: int, target: int) -> int:\n dicti={}\n m=(10**9)+7\n def rec(i,res):\n if i in dicti:\n if res in dicti[i]:\n return dicti[i][res]\n if res>=target or res+n-i>target or res+(n-i)*k=target:\n return 1\n temp=0\n for j in range(1,k+1):\n temp+=rec(i+1,res+j)\n if i not in dicti:\n dicti[i]={}\n dicti[i][res]=temp\n return temp%m\n return rec(0,0)\n" }, { "path": "Leetcode/1217. Minimum Cost to Move Chips to The Same Position/1217. Minimum Cost to Move Chips to The Same Position.java", "content": "class Solution {\n\npublic int minCostToMoveChips(int[] position) {\n int even = 0;\n int odd = 0;\n for(int i=0; i> threeSum(int[] num) {\n List> result = new ArrayList>();\n if (num.length < 3) {\n return result;\n }\n Arrays.sort(num);\n for (int i = 0; i < num.length - 2; i++) {\n if (i > 0 && num[i] == num[i - 1]) {\n continue;\n }\n int j = i + 1;\n int k = num.length - 1;\n while (j < k) {\n if (num[i] + num[j] + num[k] == 0) {\n List list = new ArrayList();\n list.add(num[i]);\n list.add(num[j]);\n list.add(num[k]);\n result.add(list);\n j++;\n k--;\n while (j < k && num[j] == num[j - 1]) {\n j++;\n }\n while (j < k && num[k] == num[k + 1]) {\n k--;\n }\n } else if (num[i] + num[j] + num[k] < 0) {\n j++;\n } else {\n k--;\n }\n }\n }\n return result;\n }\n}\n" }, { "path": "Leetcode/15. 3Sum/README.md", "content": "

15. 3Sum

\n

Medium

\n
\n
\n

Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0. Notice that the solution set must not contain duplicate triplets.

\n

Notice that the solution set must not contain duplicate triplets.

\n \n

 

\n

Example 1:

\n 
\n  Input: nums = [0,1,1]\n  Output: []\n  Explanation: The only possible triplet does not sum up to 0.\n
\n

Example 2:

\n 
\n  Input: nums = [-1,0,1,2,-1,-4]\n  Output: [[-1,-1,2],[-1,0,1]]\n  Explanation: nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0.\n  nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0.\n  nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0.\n  The distinct triplets are [-1,0,1] and [-1,-1,2].\n  Notice that the order of the output and the order of the triplets does not matter.\n
\n
\n" }, { "path": "Leetcode/151.Reverse Words in a String/Reverse Words in a String.java", "content": "class Solution {\n public String reverseWords(String s) {\n \n String s1=s.trim();\n StringBuilder sb=new StringBuilder();\n ArrayListaa=new ArrayList();\n int i=0;\n while(i-1;i1--){\n sb.append(aa.get(i1));\n sb.append(\" \");\n }\n sb.setLength(sb.length()-1);\n return sb.toString();\n }\n}\n" }, { "path": "Leetcode/1531. String Compression II/1531. String Compression II.cpp", "content": "class Solution {\npublic:\n\n int helper(int currIdx,int prevchar,int curFreq,int k, vector>>> &dp, string &s)\n {\n if(k < 0) return 100000000;\n if(currIdx >= s.size()) return 0;\n \n // if curCharFreqCount, consider it as 10, because, until 10 .. 99, string length will be 2, \n if(curFreq >= 10) curFreq = 10;\n if(dp[currIdx][prevchar][curFreq][k] != -1) return dp[currIdx][prevchar][curFreq][k];\n \n// // exclude\n int res = 100000000;\n \n /*\n 3 cases:\n case 1: We will delete our current character if K is available, so our string length will be minimum.\n case 2: If cur char is not same as prev, our res will be increased by 1 and curCharFreqCount will be 1\n case 3: If cur char is same as prev char, we need to merge it and increase our count\n case 3.1: If curCharFreqCount is either 1 or more than 9, our res will be increased by 1\n case 3.2: Else, we just need to increase curCharFreqCount.\n */\n res = min(res, helper(currIdx + 1, prevchar, curFreq, k - 1, dp, s));\n \n// // include\n if(s[currIdx] - 'a' != prevchar)\n {\n res = min(res, 1 + helper(currIdx + 1, s[currIdx] - 'a', 1, k, dp, s));\n }\n else\n {\n if(curFreq == 1 || curFreq == 9)\n {\n res = min(res, 1 + helper(currIdx + 1, prevchar, curFreq + 1, k, dp, s));\n }\n else res = min(res, helper(currIdx + 1, prevchar, curFreq + 1, k, dp, s));\n }\n \n return dp[currIdx][prevchar][curFreq][k] = res;\n }\n int getLengthOfOptimalCompression(string s, int k) {\n int n = s.size();\n vector>>> dp(n+1, vector>>(28, vector>(11, vector(n+1, -1))));\n string p = s;\n if(n == 100)\n {\n bool isSame = true;\n sort(s.begin(), s.end());\n for(int i = 1; i < s.size(); i++)\n {\n if(s[i] != s[i-1])\n {\n isSame = false;\n break;\n }\n }\n if(isSame) return 4;\n }\n s = p;\n \n return helper(0, 27, 0, k, dp, s);\n }\n\n};\n" }, { "path": "Leetcode/1578 Minimum Time to Make Rope Colorful/1578 Minimum Time to Make Rope Colorful.cpp", "content": "//There are two approch for this Problem both approch are optimal also both uses O(n) Time Complexity\n\n#include\nusing namespace std;\n\n\n//===========================Approch 1======================\n\n\nclass Solution {\npublic:\n int minCost(string s, vector& time) {\n int ans = 0;\n int n = s.length();\n for(int i = 1; i < n; i++)\n {\n if(s[i] == s[i - 1])\n {\n ans += min(time[i], time[i - 1]); \n time[i] = max(time[i], time[i - 1]); \n } \n }\n \n return ans;\n }\n};\n\n\n//===========================Approch 2 =========================\n\n\n\n\nclass Solution {\npublic:\n int minCost(string colors, vector& neededTime) {\n// initializing 2 pointers\n int totalTime =0, i =0, j =0;\n while(i int:\n lenC = len(colors)\n temp = []\n count = 0\n ans = 0\n for x in range(0,lenC):\n if x == lenC-1:\n if colors[x] == colors[x-1]:\n temp.append(neededTime[x])\n count+=1\n temp = sorted(temp)\n if len(temp) > 1:\n for i in range(0,count-1):\n ans+=temp.pop(0)\n temp = []\n count = 0\n else:\n temp = []\n count = 0\n \n elif colors[x] == colors[x+1]:\n temp.append(neededTime[x])\n count += 1\n else:\n temp.append(neededTime[x])\n count+=1\n temp = sorted(temp)\n if len(temp) > 1:\n for i in range(0,count-1):\n ans+=temp.pop(0)\n temp = []\n count=0\n else:\n temp = []\n count=0\n return ans\n" }, { "path": "Leetcode/1662. Check If Two String Arrays are Equivalent/Check If Two String Arrays are Equivalent.java", "content": "Using StringBuilder Objects:\n\nclass Solution {\n public boolean arrayStringsAreEqual(String[] word1, String[] word2) {\n StringBuilder sb1=new StringBuilder();\n StringBuilder sb2=new StringBuilder();\n \n for(String a:word1){\n sb1.append(a);\n }\n \n \n for(String a:word2){\n sb2.append(a);\n }\n \n if(sb1.toString().equals(sb2.toString())){\n return true;\n }\n return false;\n \n \n \n }\n}\n\n=======================================================================================================================================================================\n \nWithout Using StringBuilder objects:\n\nclass Solution {\n public boolean arrayStringsAreEqual(String[] word1, String[] word2) {\n String sum=null;\n String sum2=null;\n \n for(int i=0;inext;\n }\n \n if(count==1){\n return NULL;\n }\n \n int x = count-n;\n if(x==0){\n return head->next;\n }\n p = head;\n for(int i =0;inext;\n }\n p->next = p->next->next;\n return head;\n }\n};\n\n\n\n\n//=============================Approch 2 ========================================================\n\n\n\n#include\nusing namespace std;\n\n/**\n * Definition for singly-linked list.\n * struct ListNode {\n * int val;\n * ListNode *next;\n * ListNode() : val(0), next(nullptr) {}\n * ListNode(int x) : val(x), next(nullptr) {}\n * ListNode(int x, ListNode *next) : val(x), next(next) {}\n * };\n */\nclass Solution {\npublic:\n ListNode* removeNthFromEnd(ListNode* head, int n) {\n ListNode *prev = head, *NextNode = head;\n \n for(int i =0; inext;\n if(!prev) return head->next;\n \n while(prev->next){\n NextNode = NextNode->next;\n prev = prev->next;\n }\n NextNode->next = NextNode->next->next;\n return head;\n }\n};\n" }, { "path": "Leetcode/19 Remove Nth Node From End of List/Remove Nth Node from End Of List.java", "content": "Solution 1:\n\nUsing ArrayList as additional Space\nTime: 2ms \nSpace: 42.3Mb\n\n\nArrayListaa=new ArrayList();\n ListNode temp=head;\n while(temp!=null){\n aa.add(temp.val);\n temp=temp.next;\n }\n aa.remove(aa.size()-n);\n ListNode temp2=new ListNode(-1);\n ListNode temp3=temp2;\n for(int i=0;i &a,vector &b){\n if(a[0]!=b[0])\n return a[0]>b[0];\n return a[1]>& p) {\n sort(p.begin(),p.end(),comp);\n int max = INT_MIN;\n int ans=0;\n for(auto it:p){\n if(max>it[1]){\n ans++;\n }\n else{\n max = it[1];\n }\n }\n return ans;\n }\n};\n\n\n///===============Approch 1=========================\n\n\n// int n = properties.size();\n// int weakp=0;\n// for(int i =0;i> v;\n // int n = properties.size();\n // for(int i =0;i m(v.size(),0);\n // int i =0;\n // for(auto it:v){\n // int x = it.first;\n // int y = it.second;\n // for(auto it1:v){\n // if(x2095. Delete the Middle Node of a Linked List

Medium

You are given the head of the Linked List. Delete the middle node and return the headof the modified linked list. The middle node of the list of size n is the [n/2]thnode from the start using 0-based indexing, where [x]denotes the largest integer less than or equal to x\n \n

 

\n

Example 1:

\n\"\"\n
Input: tops = [2,1,2,4,2,2]\nOutput: [1,3,4,1,2,6]\nExplanation: \nThe above figure represents the given linked list. The indices of the nodes are written below.\nSince n = 7, node 3 with value 7 is the middle node, which is marked in red.\nWe return the new list after removing this node. \n
\n\n \n

 

\n

Constraints:

\n\n
    \n\t
  • The number of nodes in the list is in the range [1, 10]5
    • \n
  • 1 <= Node.val <= 105
    • \n
\n
\n" }, { "path": "Leetcode/2124. Check if All A's Appears Before All B's/2124. Check if All A's Appears Before All B's.java", "content": "Code :\nclass Solution {\n public boolean checkString(String s) {\n int indexb=s.indexOf(\"b\");\n int indexa=s.lastIndexOf(\"a\");\n if(indexa!=-1 && indexb!=-1 && indexa>indexb){\n return false;\n }\n else if(indexa==-1 || indexb==-1){\n return true;\n }\n return true;\n }\n}\n\nTime Complexity:O(String Length)[As indexOf() method will found out the index of a particular character after thraversing the whole string]\nSpace Complexity:O(1)\nAuxiliary Space:O(1)\n \nLeetcode Time:1ms beats 86.26%\nLeetcode Space:42.2Mb beats 42.38%\n \n \n" }, { "path": "Leetcode/218 The Skyline Problem/218 The Skyline Problem s30.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n vector> getSkyline(vector>& buildings) {\n vector> res;\n multiset pq{0};\n \n vector> points;\n \n for(auto b: buildings){\n points.push_back({b[0], -b[2]});\n points.push_back({b[1], b[2]});\n }\n \n sort(points.begin(), points.end());\n \n int ongoingHeight = 0;\n \n for(int i = 0; i < points.size(); i++){\n int currentPoint = points[i].first; // x coordinate\n int heightAtCurrentPoint = points[i].second; // ht\n \n if(heightAtCurrentPoint < 0){\n pq.insert(-heightAtCurrentPoint);\n } else {\n pq.erase(pq.find(heightAtCurrentPoint));\n }\n \n auto pqTop = *pq.rbegin();\n if(ongoingHeight != pqTop){\n ongoingHeight = pqTop;\n res.push_back({currentPoint, ongoingHeight});\n }\n }\n \n return res; \n }\n};" }, { "path": "Leetcode/221. Maximal Square/221. Maximal Square.java", "content": "class Solution {\n public int maximalSquare(char[][] matrix) {\n int rows = matrix.length;\n int cols = matrix[0].length;\n int maxSquare = 0;\n int[][] maxSideLength = new int[rows+1][cols+1];\n\n for(int i=rows-1;i>=0;i--){\n for(int j=cols-1;j>=0;j--){\n if(matrix[i][j] == '1'){\n // maximum sideLength of square is minimum of length covered by either of row, column, diagonal\n maxSideLength[i][j] = Math.min(maxSideLength[i+1][j],Math.min(maxSideLength[i][j+1],maxSideLength[i+1][j+1]))+1;\n maxSquare = Math.max(maxSquare, maxSideLength[i][j]);\n }else{\n maxSideLength[i][j] = 0;\n }\n }\n }\n return maxSquare*maxSquare;\n }\n}\n " }, { "path": "Leetcode/222. Count Complete Tree Nodes/Count Complete Tree Nodes.java", "content": "class Solution {\n int count = 0;\n public int countNodes(TreeNode root) {\n if(root==null) return 0;\n countNodes(root.left);\n count++;\n System.out.print(root.val+\" \");\n countNodes(root.right);\n return count;\n }\n}\n" }, { "path": "Leetcode/2368. Reachable Nodes With Restrictions/Reachable Nodes With Restrictions.cpp", "content": "class Solution {\npublic:\n \n void dfs(vector adj[],vector&vis,int node,int &no){\n vis[node]=1;\n no++;\n for(auto it:adj[node]){\n if(vis[it]==0){\n dfs(adj,vis,it,no);\n }\n }\n }\n \n int reachableNodes(int n, vector>& edges, vector& res) {\n vector adj[n];\n vector v(n,0);\n for(int i =0;inext);\n // ListNode* temp = node;\n int temp = node->next->val;\n node->next->val = node->val;\n node->val = temp;\n node->next = node->next->next;\n // ListNode *t = node->next;\n // free(node);\n // node = t;\n // free(t);\n // cout<val<\nusing namespace std ; \n\nclass Solution {\npublic:\n int commonFactors(int a, int b) {\n \n int count = 1 ; \n \n for(int i = 2 ; i <= b ; i++ )\n {\n if(a % i == 0 && b % i == 0)\n {\n count ++ ; \n }\n }\n return count ; \n }\n};\n" }, { "path": "Leetcode/2428. Maximum Sum of an Hour Glass/2428. Maximum Sum of an Hour Glass.cpp", "content": "#include \nusing namespace std ; \n\nclass Solution {\npublic:\n int maxSum(vector>& grid) {\n int m = grid.size() ; \n // Gives the no. of rows in a matrix. \n int n = grid[0].size() ; \n // Gives the no. of columns in a matrix. \n\n int sum = 0 ; \n // Initialised a variable for calculating the sum. \n int maxi = 0 ; \n // Initialized a variable for comparing and finding the maximum sum. \n for(int i = 1 ; i < m - 1 ; i++) \n {\n for(int j = 1 ; j < n - 1 ; j++)\n {\n // Carefully, Access all the grid indices in the form of hour glass by sticking to one point. \n // Avoid accessing the wrong indices and indices out of bound. \n sum += grid[i][j] + grid[i + 1][j] + grid[i + 1][j - 1] + grid[i + 1][j + 1] + grid[i - 1][j] + grid[i - 1][j + 1] + grid[i - 1][j - 1] ; \n maxi = max(sum , maxi) ; \n // Used the inbuilt max function of C++ to comapare the previous and curreent values. \n\n sum = 0 ; \n // Again, initialised the sum to be zero so that for next iteration it will again start from zero. \n\n }\n\n }\n return maxi ; \n // Return the maximum sum after completing all the iterations. \n// Generalised, Time Complexity of the solution is - O(N^2) - As the nested loop is involved. \n }\n};\n" }, { "path": "Leetcode/263. Ugly Number/263. Ugly Number.cpp", "content": "class Solution {\npublic:\n bool isUgly(int n) {\n if(n == 0) return false;\n if(n == 1) return true;\n \n while(n%2==0)\n {\n n = n/2;\n }\n while(n%3==0)\n {\n n = n/3;\n }\n while(n%5==0)\n {\n n = n/5;\n }\n \n return n == 1 ? true:false;\n }\n};\n" }, { "path": "Leetcode/279. Perfect Squares/279. Perfect Squares.cpp", "content": "class Solution {\n int solve(int ind, vector &nums, int tar, vector> &dp)\n {\n if(tar == 0) \n return 0;\n \n if(ind == 0)\n return tar; \n \n \n if(dp[ind][tar] != -1) return dp[ind][tar];\n \n int excl = solve(ind-1, nums, tar, dp);\n int incl = 1e9;\n if(nums[ind] <= tar)\n incl = 1 + solve(ind, nums, tar-nums[ind], dp);\n \n return dp[ind][tar] = min(excl, incl);\n }\npublic:\n int numSquares(int n) {\n \n if(n <= 3) return n;\n \n vector nums;\n \n for(int i = 1; i*i <= n; i++)\n {\n nums.push_back(i*i);\n \n }\n int m = nums.size();\n \n vector> dp(m+1, vector(n+1, -1)); //n is target\n \n return solve(m-1, nums, n , dp);\n }\n};\n" }, { "path": "Leetcode/336. Palindrome Pairs/336. Palindrome Pairs.java", "content": "class Solution {\n static int palindromepair(int N, String arr[]) {\n for(int i = 0; i< N;i++){\n for(int j =0; j< N;j++){\n if(i!=j){\n String newStr = arr[i]+arr[j];\n if(isPalindrome(newStr)) return 1;\n }\n }\n }\n return 0;\n }\n \n \n static boolean isPalindrome(String input){\n int i = 0;\n int j = input.length() - 1;\n \n while (i < j) {\n if (input.charAt(i) != input.charAt(j)) {\n return false;\n }\n i++;\n j--;\n }\n \n return true;\n }\n};\n" }, { "path": "Leetcode/336. Palindrome Pairs/336. Palindrome pairs.cpp", "content": "#include\nusing namespace std;\n\n\nstruct TrieNode {\n TrieNode *next[26] = {};\n int index = -1;\n vector palindromeIndexes;\n};\n\nclass Solution {\n TrieNode root; // Suffix trie\n void add(string &s, int i) {\n auto node = &root;\n for (int j = s.size() - 1; j >= 0; --j) {\n if (isPalindrome(s, 0, j)) node->palindromeIndexes.push_back(i); // A[i]'s prefix forms a palindrome\n int c = s[j] - 'a';\n if (!node->next[c]) node->next[c] = new TrieNode();\n node = node->next[c];\n }\n node->index = i;\n node->palindromeIndexes.push_back(i); // A[i]'s prefix is empty string here, which is a palindrome.\n }\n \n bool isPalindrome(string &s, int i, int j) {\n while (i < j && s[i] == s[j]) ++i, --j;\n return i >= j;\n }\npublic:\n vector> palindromePairs(vector& words) {\n int N = words.size();\n for (int i = 0; i < N; ++i) add(words[i], i);\n vector> ans;\n for (int i = 0; i < N; ++i) {\n auto s = words[i];\n auto node = &root;\n for (int j = 0; j < s.size() && node; ++j) {\n if (node->index != -1 && node->index != i && isPalindrome(s, j, s.size() - 1)) ans.push_back({ i, node->index }); \n // A[i]'s prefix matches this word and A[i]'s suffix forms a palindrome\n node = node->next[s[j] - 'a'];\n }\n if (!node) continue;\n for (int j : node->palindromeIndexes) { \n // A[i] is exhausted in the matching above. \n // If a word whose prefix is palindrome after matching its suffix with A[i], \n // then this is also a valid pair\n if (i != j) ans.push_back({ i, j });\n }\n }\n return ans;\n }\n};\n" }, { "path": "Leetcode/4. Median of Two Sorted Arrays/4. Median of Two Sorted Arrays.java", "content": "// as median we have to divide values in array\n// left side (some of nums1 and some of nums2)\n// right side (some of nums1 and some of nums2)\n\nclass Solution {\n public double findMedianSortedArrays(int[] arr1, int[] arr2) {\n //taking nums2 bigger always (bcz we taking values from nums2)\n //so to not get index out of bound\n if(arr2.length \"+l+\" \"+r+\"\\n\"+\n // \"cut1 & cut2 => \"+cut1+\" \"+cut2+\"\\n\"+\n // \"left half=> \"+Math.min(l1,l2)+\" \"+Math.max(l1,l2)+\"\\n\"+\n // \"right half=> \"+Math.min(r1,r2)+\" \"+Math.max(r1,r2));\n \n if(l1<=r2 && l2<=r1){\n // System.out.print(l1+\" \")\n if((n+m)%2==0){\n // System.out.println(l1+\" \"+l2+\" \"+r1+\" \"+r2);\n return ( Math.max(l1,l2) + Math.min(r1,r2) )/2.0;\n }else{\n //odd length\n return Math.max(l1,l2);\n }\n }\n \n else if(l1>r2){\n r=cut1-1;\n }\n \n else if(l2>r1){\n l=cut1+1;\n }\n \n }\n return 1L;\n \n }\n}\n" }, { "path": "Leetcode/4. Median of Two Sorted Arrays/Median of Two Sorted Arrays.cpp", "content": "class Solution {\npublic:\n double findMedianSortedArrays(vector& v1, vector& v2) {\n for(int i =0;i readBinaryWatch(int turnedOn) {\n \n List ans=new ArrayList<>();\n \n if(turnedOn>8){\n return ans;\n }\n for(int h=0;h<12;h++){\n for(int m=0;m<60;m++){\n \n //bit count will count total set bit(1) in a numbmer\n if(Integer.bitCount(h*64+m)==turnedOn){\n ans.add(String.format(\"%d:%02d\",h,m));\n }\n }\n }\n return ans;\n }\n}" }, { "path": "Leetcode/401 binary watch/NOTES.md", "content": "​" }, { "path": "Leetcode/401 binary watch/README.md", "content": "

401. Binary Watch

Easy

A binary watch has 4 LEDs on the top to represent the hours (0-11), and 6 LEDs on the bottom to represent the minutes (0-59). Each LED represents a zero or one, with the least significant bit on the right.

\n\n
    \n\t
  • For example, the below binary watch reads \"4:51\".
    • \n
\n\n

\"\"

\n\n

Given an integer turnedOn which represents the number of LEDs that are currently on (ignoring the PM), return all possible times the watch could represent. You may return the answer in any order.

\n\n

The hour must not contain a leading zero.

\n\n
    \n\t
  • For example, \"01:00\" is not valid. It should be \"1:00\".
    • \n
\n\n

The minute must be consist of two digits and may contain a leading zero.

\n\n
    \n\t
  • For example, \"10:2\" is not valid. It should be \"10:02\".
    • \n
\n\n

 

\n

Example 1:

\n
Input: turnedOn = 1\nOutput: [\"0:01\",\"0:02\",\"0:04\",\"0:08\",\"0:16\",\"0:32\",\"1:00\",\"2:00\",\"4:00\",\"8:00\"]\n

Example 2:

\n
Input: turnedOn = 9\nOutput: []\n
\n

 

\n

Constraints:

\n\n
    \n\t
  • 0 <= turnedOn <= 10
    • \n
\n
\n" }, { "path": "Leetcode/437 Path Sum III/pathSum.cpp", "content": "class Solution {\npublic:\n int cnt=0;\n void dfs(TreeNode* root,long long target)\n {\n if(!root)\n return;\n if(root->val==target)\n cnt++;\n dfs(root->left,target-root->val);\n dfs(root->right,target-root->val);\n }\n /////////\n int pathSum(TreeNode* root, int targetSum) \n {\n if(root)\n {\n dfs(root,targetSum);\n pathSum(root->left,targetSum);\n pathSum(root->right,targetSum);\n }\n return cnt;\n }\n};\n" }, { "path": "Leetcode/450 Delete Node in a BST/deleteNode.java", "content": "```java\nclass Solution {\n public TreeNode deleteNode(TreeNode root, int key) {\n // if current node is null, return null\n // this can happen only if the tree is empty or if the key does not exist in the tree\n if (root == null) return null;\n \n // if current node's value is equal to key, then simply delete it\n if (root.val == key) {\n // straightforward case where node is leaf node, then just delete it\n if (root.left == null && root.right == null) {\n return null;\n } else if (root.left != null) {\n // if the left child exists, then the node to attach is the left child's rightmost descendant\n // and we should return the current node's left child as the new root for its parent to attach to\n TreeNode newRoot = root.left;\n TreeNode attach = newRoot;\n while (attach.right != null) {\n attach = attach.right;\n }\n // attach the deleted nodes' right child to the right of the node to attach\n attach.right = root.right;\n return newRoot;\n } else {\n // if the right child exists, then the node to attach is the right child's leftmost descendant\n // and we should return the current node's right child as the new root for its parent to attach to\n TreeNode newRoot = root.right;\n TreeNode attach = newRoot;\n while (attach.left != null) {\n attach = attach.left;\n }\n // attach the deleted nodes' left child to the left of the node to attach\n attach.left = root.left;\n return newRoot;\n }\n }\n \n // if the key is not equal to the current node's value, keep searching for the key using BST property\n // attach the current node to the result of the deletion (which will either return the original child or a new child if the child is deleted)\n if (key > root.val) {\n root.right = deleteNode(root.right, key);\n } else {\n root.left = deleteNode(root.left, key);\n }\n \n // return current node\n return root;\n }\n}\n```\n" }, { "path": "Leetcode/4Sum II/4Sum II.java", "content": "class Solution {\n public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {\n Map map = new HashMap<>();\n for(int k : nums3)\n for(int l : nums4)\n map.put(k + l, map.getOrDefault(k + l, 0) + 1);\n int count = 0;\n for(int i : nums1)\n for(int j : nums2)\n count += map.getOrDefault(-(i + j), 0);\n return count;\n }\n}\n" }, { "path": "Leetcode/622 Design Circular Queue/622 Design Circular Queue med s25.cpp", "content": "#include\nusing namespace std;\n\nclass MyCircularQueue {\npublic:\n MyCircularQueue(int k) {\n// queue holding the elems for circular queue\n q.resize(k);\n// no. of elems in the circular queue\n count =0;\n size =k; // queue size\n headIndex =0; // index of head element\n }\n \n bool enQueue(int value) {\n// handle full case\n if(isFull()) return false;\n q[(headIndex+count)% size] = value;\n count+=1;\n return true;\n }\n \n bool deQueue() {\n// handle empty case\n if(isEmpty()) return false;\n// update head idx\n headIndex= (headIndex+1)% size;\n count-=1;\n return true;\n }\n \n int Front() {\n// handle empty queue case\n if(isEmpty()) return -1;\n return q[headIndex]; // return head elem\n }\n \n int Rear() {\n// handle empty queue case\n if(isEmpty()) return -1;\n return q[(headIndex+count-1) %size];\n }\n \n bool isEmpty() {\n// no elem in queue\n return count == 0;\n }\n \n bool isFull() {\n// return true if the count is equal to the queue size\n return count==size;\n// else return false\n }\n private:\n int count, size, headIndex;\n vector q;\n};\n" }, { "path": "Leetcode/623 Add One Row To Tree/Add one row to tree.java", "content": "class Solution {\n public TreeNode addOneRow(TreeNode root, int val, int depth) {\n if(depth==1) { // if depth is 1 we have to add for root\n TreeNode newH=new TreeNode(val);\n newH.left=root;\n return newH;\n }\n addRow(root, val, 1, depth-1); //starting with root starting from 1 to depth-1\n return root;\n }\n public void addRow(TreeNode root, int val, int height, int expHeight) {\n if(root==null) {\n return ;\n }\n if(expHeight==height) {\n TreeNode left=new TreeNode(val, root.left, null);\n TreeNode right=new TreeNode(val, null, root.right);\n root.left=left;\n root.right=right;\n return ;\n }\n \n addRow(root.left, val, height+1, expHeight);\n addRow(root.right, val, height+1, expHeight);\n\n }\n}\n" }, { "path": "Leetcode/623 Add One Row To Tree/ReadMe.md", "content": "# 623. Add One Row to Tree\nGiven the root of a binary tree and two integers val and depth, add a row of nodes with value val at the given depth depth.\n\nNote that the root node is at depth 1.\n\nThe adding rule is:\n\nGiven the integer depth, for each not null tree node cur at the depth depth - 1, create two tree nodes with value val as cur's left subtree root and right subtree root.\ncur's original left subtree should be the left subtree of the new left subtree root.\ncur's original right subtree should be the right subtree of the new right subtree root.\nIf depth == 1 that means there is no depth depth - 1 at all, then create a tree node with value val as the new root of the whole original tree, and the original tree is the new root's left subtree.\n \n\n### Example 1:\n\n![addrow-tree](https://user-images.githubusercontent.com/75923481/193965191-3f95d1b4-9bf0-499d-ae01-5daee00b9110.jpg)\n\n\nInput: root = [4,2,6,3,1,5], val = 1, depth = 2
\nOutput: [4,1,1,2,null,null,6,3,1,5]
\n\n## Example 2:\n\n![add2-tree](https://user-images.githubusercontent.com/75923481/193965239-82dc673e-015a-46c3-8e0d-9d04907c0c32.jpg)\n\nInput: root = [4,2,null,3,1], val = 1, depth = 3
\nOutput: [4,2,null,1,1,3,null,null,1]
\n \n\nConstraints:\n\nThe number of nodes in the tree is in the range [1, 104].
\nThe depth of the tree is in the range [1, 104].
\n-100 <= Node.val <= 100
\n-105 <= val <= 105
\n1 <= depth <= the depth of tree + 1
\n" }, { "path": "Leetcode/623 Add One Row to Tree/623 Add One Row to Tree.java", "content": "class Solution {\n \n public TreeNode add(TreeNode root, int val, int depth, int currdepth){\n if(root==null) return root;\n \n if(depth==1){\n TreeNode temp = new TreeNode(val);\n // if(side=='l')\n temp.left = root;\n \n \n return temp;\n }\n else if(currdepth==depth-1){\n TreeNode temp1 = new TreeNode(val);\n TreeNode temp2 = new TreeNode(val);\n \n \n temp1.right = root.right;\n temp2.left = root.left;\n \n \n root.left = temp2;\n root.right = temp1;\n return root;\n }else{\n root.left = add(root.left,val,depth,currdepth+1);\n root.right = add(root.right,val,depth,currdepth+1); \n return root;\n }\n \n \n \n \n }\n public TreeNode addOneRow(TreeNode root, int val, int depth) {\n \n if(depth==1){\n TreeNode temp = new TreeNode(val);\n temp.left = root;\n \n return temp;\n }\n return add(root,val,depth,1);\n \n }\n}\n" }, { "path": "Leetcode/658 Find K Closest Elements/658 Find K Closest Elements s29.cpp", "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n vector findClosestElements(vector& arr, int k, int x) {\n int L =0, R = arr.size()-1;\n while(R-L >= k)\n if(x- arr[L] <= arr[R]-x) R--;\n else L++;\n return vector(arr.begin() + L, arr.begin() + R+1);\n }\n};" }, { "path": "Leetcode/658 Find K Closest Elements/Find k Closest Elements.java", "content": "Approach 1:\nclass Solution {\n public List findClosestElements(int[] arr, int k, int x) {\n TreeMap>map=new TreeMap>();\n \n for(int i=0;iset=map.get(a);\n set.add(arr[i]);\n map.put(a,set);\n }\n else{\n LinkedListset=new LinkedList();\n set.add(arr[i]);\n map.put(a,set);\n }\n }\n //System.out.println(map);\n Listlist=new ArrayList();\n boolean flag=false;\n for(int a:map.keySet()){\n LinkedListset=map.get(a);\n for(int b:set){\n list.add(b);\n if(list.size()==k){\n flag=true;\n break;\n }\n }\n if(flag==true){\n break;\n }\n }\n Collections.sort(list);\n return list;\n }\n}\nTime Taken:130ms \n\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\nApproach 2:\nclass Solution {\n public static class Pair implements Comparable{\n \n int ele;\n int diff;\n \n public Pair(int a, int b){\n ele=a;\n diff=b;\n } \n \n public int compareTo(Pair p){\n if((p.diff)==(this.diff)){\n return this.ele-p.ele;\n }\n return this.diff-p.diff;\n }\n \n}\n \n public List findClosestElements(int[] arr, int k, int x) {\n Pair obj[]=new Pair[arr.length];\n for(int i=0;iaa=new ArrayList();\n for(int i=0;i x:\n high = mid - 1\n \n # means x is present at mid\n else:\n return mid\n \n # If we reach here, then the element was not present\n return -1\n" }, { "path": "Leetcode/704 binary search/NOTES.md", "content": "\r\n" }, { "path": "Leetcode/704 binary search/README.md", "content": "

704. Binary Search

Easy

Given an array of integers nums which is sorted in ascending order, and an integer target, write a function to search target in nums. If target exists, then return its index. Otherwise, return -1.

\r\n\r\n

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

\r\n\r\n

 

\r\n

Example 1:

\r\n\r\n
Input: nums = [-1,0,3,5,9,12], target = 9\r\nOutput: 4\r\nExplanation: 9 exists in nums and its index is 4\r\n
\r\n\r\n

Example 2:

\r\n\r\n
Input: nums = [-1,0,3,5,9,12], target = 2\r\nOutput: -1\r\nExplanation: 2 does not exist in nums so return -1\r\n
\r\n\r\n

 

\r\n

Constraints:

\r\n\r\n
    \r\n\t
  • 1 <= nums.length <= 104
    • \r\n\t
  • -104 < nums[i], target < 104
    • \r\n\t
  • All the integers in nums are unique.
    • \r\n\t
  • nums is sorted in ascending order.
    • \r\n
\r\n
\r\n" }, { "path": "Leetcode/72 Edit distance/minDistance.cpp", "content": "/*This code is contributed by mr-optimizer (https://github.com/mr-optimizer) */\nclass Solution {\npublic:\n int memo[501][501];\n int dp(string word1, string word2, int i, int j) {\n if (i == 0)return j;\n if (j == 0)return i;\n if (memo[i][j] != -1)return memo[i][j];\n if (word1[i - 1] == word2[j - 1]) {\n return memo[i][j] = dp(word1, word2, i - 1, j - 1);\n } else {\n return memo[i][j] = 1 + min(dp(word1, word2, i - 1, j), min(dp(word1, word2, i, j - 1), dp(word1, word2, i - 1, j - 1)));\n }\n }\n int minDistance(string word1, string word2) {\n memset(memo, -1, sizeof(memo));\n return dp(word1, word2, word1.size(), word2.size());\n }\n};\n" }, { "path": "Leetcode/72 Edit distance/minDistance.java", "content": "public class Solution {\n public int minDistance(String A, String B) {\n int[][]list=new int[A.length()][B.length()];\n return editDist(A,B,0,0,list);\n }\n int editDist(String A,String B,int x,int y,int[][]memory){\n if(y==B.length())return A.length()-x;\n if(x==A.length())return B.length()-y;\n int ans=memory[x][y];\n if(ans!=0)return ans;\n if(A.charAt(x)==B.charAt(y)){\n ans=editDist(A,B,x+1,y+1,memory);\n }else{\n ans=1+Math.min(editDist(A,B,x+1,y,memory),Math.min(editDist(A,B,x,y+1,memory),editDist(A,B,x+1,y+1,memory)));\n }\n memory[x][y]=ans;\n return ans;\n }\n}\n" }, { "path": "Leetcode/75.Sort colors/75.Sort-colors.java", "content": "class Solution {\n public void sortColors(int[] nums) {\n int count0 = 0;\n int count1=0;\n for(int i=0 ; i 0){\n nums[i] = 0 ;\n \n }\n else if(count1-- > 0){\n nums[i]=1;\n }\n else{\n nums[i]=2;\n }\n }\n }\n}\n" }, { "path": "Leetcode/75.Sort colors/Notes.md", "content": "\n" }, { "path": "Leetcode/75.Sort colors/README.md", "content": "# [75. Sort Colors](https://leetcode.com/problems/sort-colors/)\n\n## Medium\nGiven an array nums with n objects colored red, white, or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white, and blue.\n\nWe will use the integers 0, 1, and 2 to represent the color red, white, and blue, respectively.\n\nYou must solve this problem without using the library's sort function.\n\n## Example 1:\n\n#### Input: nums = [2 , 0 , 2 , 1 , 1 , 0]\n#### Output: [0 , 0 , 1 , 1 , 2 , 2 ]\n\n## Example 2:\n#### Input: nums = [2 , 0 , 1]\n\n#### Output: [0 , 1 , 2]\n\n## Constraints:\n ### n == nums.length\n\n ### 1 <= n <= 300\n\n ### nums[i] is either 0, 1, or 2.\n" }, { "path": "Leetcode/75.Sort colors/Sort colors.cpp", "content": "class Solution {\npublic:\n void sortColors(vector& v) {\n int n =v.size();\n for(int i =0;iv[j+1]){\n swap(v[j],v[j+1]);\n }\n }\n }\n }\n};\n" }, { "path": "Leetcode/766.Toeplitz Matrix/Toeplitz Matrix.java", "content": "Solution 1:\n\nBackward Comparison: Comparison with previous diagonal cee\n\nTime Complexity:O(N*M)\nSpace Complexity:O(N*M)\nAuxiliary Space:O(1)\n \nLeetCode Time: 1 ms faster than 93.83%\nLeetCode Memory: 45.2MB less than 80.01%\n \n\n boolean flag=false;\n int n=arr.length;\n int m=arr[0].length;\n for(int i=01;i>& board, string word) {\n if (word.empty()) return true;\n if (board.empty() || board[0].empty()) return false;\n\n m = board.size();\n n = board[0].size();\n for (int i = 0; i < m; ++i)\n for (int j = 0; j < n; ++j)\n // traverse the board to find the first char\n if (dfsSearch(board, word, 0, i, j)) return true;\n return false;\n }\nprivate:\n int m;\n int n;\n bool dfsSearch(vector>& board, string& word, int k, int i, int j) {\n if (i < 0 || i >= m || j < 0 || j >= n || word[k] != board[i][j]) return false;\n if (k == word.length() - 1) return true; // found the last char\n\n char cur = board[i][j];\n board[i][j] = '*'; // used\n bool search_next = dfsSearch(board, word, k+1, i-1 ,j)\n || dfsSearch(board, word, k+1, i+1, j)\n || dfsSearch(board, word, k+1, i, j-1)\n || dfsSearch(board, word, k+1, i, j+1);\n board[i][j] = cur; // reset\n return search_next;\n }\n};\n" }, { "path": "Leetcode/79.Word Search/NOTES.md", "content": "" }, { "path": "Leetcode/79.Word Search/README.md", "content": "

79. Word Search

Medium

Given an m x n grid of characters board and a string word, return true if word exists in the grid.\n\nThe word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.

\n
\n

Example 1:

\n\"\"\n
Input: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCCED\"\nOutput: true\n
\n
\n

Example 2:

\n\"\"\n
Input: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"SEE\"\nOutput: true\n
\n
\n

Example 2:

\n\"\"\n
Input: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCB\"\nOutput: false\n"
  },
  {
    "path": "Leetcode/838 Push Dominoes/838 Push Dominoes lc med s27.cpp",
    "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n// using 2-pointer\n    string pushDominoes(string dominoes) {\n        int l = 0, n = dominoes.size();\n        for (int r = 0; r < n; r++) {\n            if (dominoes[r] == '.') {\n                continue;\n            } else if ((dominoes[r] == dominoes[l]) || (dominoes[l] == '.' && dominoes[r] == 'L')) {\n                for (int k = l; k < r; k++) dominoes[k] = dominoes[r];\n            } else if (dominoes[l] == 'L' && dominoes[r] == 'R') {\n\n            }  else if (dominoes[l] == 'R' && dominoes[r] == 'L') {\n\n                int m = (r - l - 1) / 2;\n                for (int k = 1; k <= m; k++) dominoes[r - k] = 'L', dominoes[l + k] = 'R';\n            }\n            l = r;\n            dominoes[l] = dominoes[r];\n        }\n        if (dominoes[l] == 'R') for (int k = l; k < n; k++) dominoes[k] = 'R';\n        return dominoes;\n    }\n};"
  },
  {
    "path": "Leetcode/91 Decode Ways/91 Decode Ways oc1.cpp",
    "content": "#include\nusing namespace std;\n\nclass Solution {\npublic:\n    int numDecodings(string s) {\n//         check for empty string or leading zero\n        if(!s.size() || s.front() == '0') return 0;\n        int d1=1, d2 =1;   \n        for(int i =1; inext;\n        }\n        p = head;\n        vector v;\n        while(p!=NULL){\n           v.push_back(p->val);\n           p=p->next; \n        }\n        reverse(v.begin()+left-1,v.begin()+right);\n        p = head;\n        int i=0;\n        while(p!=NULL){\n            p->val = v[i];\n            p=p->next;\n            i++;\n        }\n        return head;\n    }\n};\n\n\n // ListNode* p = head;\n //        int count =0;\n //        while(p!=NULL){\n //            count++;\n //            p=p->next;\n //        }\n //        p = head;\n //        int a[count];\n //        int i =0;\n //        while(p!=NULL){\n //            a[i]=p->val;\n //            p=p->next;\n //            i++;\n //        }\n //        p = head;\n //        reverse(a+(left-1),a+right);\n //        int j =0;\n //        while(p!=NULL){\n //            p->val = a[j];\n //            p=p->next;\n //            j++;\n //        }\n //        return head;\n"
  },
  {
    "path": "Leetcode/92 Reverse Linked List II/Reverse Linked List II.java",
    "content": "public class Solution {\n    public ListNode reverseBetween(ListNode A, int B, int C) {\n\n        ListNode temp = A;\n        ListNode prevtemp = null;\n\n        int count = 1;\n        while(count\nusing namespace std;\n\nclass Solution {\npublic:\n    int alphabet_size[26];\n    int find(int x){\n        return alphabet_size[x] == x ? x: find(alphabet_size[x]);\n    }\n    bool equationsPossible(vector& equations) {\n        int n = (int) equations.size();\n        \n        for(int i =0; i<26; i++) alphabet_size[i]=i;\n        \n        for(auto x : equations){\n            if(x[1]== '='){\n                alphabet_size[find(x[0]-'a')] = find(x[3]-'a');\n            }\n        }\n//         handle != case\n        for(auto x : equations){\n            if(x[1]== '!' && find(x[0]-'a') == find(x[3]-'a')){\n                return false;\n            }\n        }\n            return true;\n    }\n};"
  },
  {
    "path": "Leetcode/Break A Palindrome/Break A Palindrome.java",
    "content": "class Solution{\n  public String breakPalindrome(String s) {\n          if(s.length()<=1){\n              return \"\";\n          }\n          else{\n              int len=0;\n              len=s.length()/2;\n              int i=0;\n              StringBuilder sb=new StringBuilder(s);\n              while(i& nums, int k) {\n        unordered_map mp;\n            for(auto i: nums) {\n                    mp[i]++;\n            }\n            int ans = 0;\n            for(auto x: mp) {\n                    if(k == 0) {\n                            if(x.second > 1) {\n                                    ans++;\n                            }\n                    }else if(mp.find(x.first+k) != mp.end()) {\n                            ans++;\n                    }\n            }\n            return ans;\n    }\n};"
  },
  {
    "path": "Leetcode/Merge Overlapping Intervals/Merge Overlapping Intervals.cpp",
    "content": "class Solution {\npublic:\n    vector> merge(vector>& intervals) {\n        vector> ans;\n            sort(intervals.begin(), intervals.end());\n            \n         vector temp = intervals[0];\n            for(int i= 1; i& neededTime) {\n        if(colors.length() != neededTime.size()) return -1;\n                int time = 0; int maxTime;\n            for(int i=0; i0 && colors[i]!=colors[i-1])\n                           maxTime =0;\n                 \n                  time += min(maxTime, neededTime[i]);\n                  maxTime = max(maxTime, neededTime[i]);  \n            }\n            \n            return time;\n    }\n};"
  },
  {
    "path": "Leetcode/Number of Dice rolls with target sum/Number of dice rolls.cpp",
    "content": "vector dp(target + 1);\n  dp[0] = 1;\n  for (int i = 1; i <= d; ++i) {\n    vector dp1(target + 1);\n    for (int j = 1; j <= f; ++j)\n      for (auto k = j; k <= target; ++k)\n        dp1[k] = (dp1[k] + dp[k - j]) % 1000000007;\n    swap(dp, dp1);\n  }\n  return dp[target];"
  },
  {
    "path": "Leetcode/Remove Letter To Equalize Frequency/Remove Letter To Equalize Frequency.cpp",
    "content": "class Solution {\npublic:\n    bool equalFrequency(string word) {\n        vector v;\n        unordered_map mp;\n        for(char ch : word) mp[ch]++;\n        for(auto x : mp){\n            v.push_back(x.second);\n        }\n        sort(v.begin(), v.end());\n        if(v.size() == 1) return 1;\n        \n        else if(v.size() == 2){\n            if(v[0] == 1 and v[1] == 1) return 1;\n            else if(v[1] - v[0] == 1) return 1;\n            return 0;\n        }\n        \n        else{\n            if(v[0] == 1 and count(v.begin(), v.end(), v[0]) == v.size()) return 1;\n            else if(v[0] == 1 and count(v.begin(), v.end(), v[0]) != v.size()){\n                if(v.size() == 3 and v[v.size() - 1] == 2) return 1;\n            }\n            \n            int sum = 0;\n            for(int x : v) sum += x;\n            \n            if(sum == (v[0] * v.size() + 1)) return 1;\n            else return 0;\n        }\n        return 0;\n    }\n};\n"
  },
  {
    "path": "Leetcode/Sort Colors/Sort Colors.cpp",
    "content": "class Solution {\npublic:\n    void sortColors(vector& nums) {\n        if(nums.size() == 0) return;\n            int i=0, j=0, k = nums.size()-1;\n            while(j<=k) {\n                    if(nums[j] == 2) {\n                            swap(nums[j], nums[k]);  k--;\n                    }\n                    if(nums[j] == 0) {\n                            swap(nums[j], nums[i]);  i++; j++;\n                    }else if(nums[j] == 1) {\n                            j++;\n                    }\n            }\n    }\n};"
  },
  {
    "path": "Leetcode/Top K Frequent Words/Top K Frequent Words.cpp",
    "content": "class Solution {\npublic:\n    #define ps pair\n   class comp {\n  public:\n    bool operator() (const ps &p1, const ps &p2) {\n      if(p1.first == p2.first) return p1.second < p2.second;\n      \n      return p1.first > p2.first;\n    }\n   }; \n    vector topKFrequent(vector& words, int k) {\n        int n=words.size();\n        \n        unordered_mapmap;\n        for(auto x:words){\n            map[x]++;\n        }\n        \n        priority_queue,comp>pq;\n        \n        for(auto x:map){\n            pq.push({x.second,x.first});\n            if(pq.size()>k) pq.pop();\n        }\n        vectorans(k);\n        while(k--){\n            ans[k]=pq.top().second;\n            pq.pop();\n        }\n        return ans;\n    }\n};\n"
  },
  {
    "path": "Leetcode/Two Sum IV-Input is BST/Two Sum IV-Input is a BST.java",
    "content": "Solution 1:\nWithout using set:\n\nApproach:\n1.Doing Inorder Traversal \n2.Storing data values in an arraylist\n3.Applying two pointer algorithm and if target is found return true else return false\n  \nCode:\n\nclass Solution {\n    \n    public void fun(TreeNode root,ArrayListaa){\n        if(root==null){\n            return ;\n        }\n        else{\n            fun(root.left,aa);\n            aa.add(root.val);\n            fun(root.right,aa);\n        }\n    }\n    public boolean findTarget(TreeNode root, int target) {\n        ArrayListaa=new ArrayList();\n        fun(root,aa);\n        int start=0;\n        int end=aa.size()-1;\n        while(starttarget){\n                end--;\n            }\n            else{\n                start++;\n            }\n        }\n        return false;\n    }\n    \n  \n  \n  \nSolution 2:\nUsing Set:\n  \n  \n  Approach:\n1.Doing Inorder Traversal \n2.While traversal if we get (target-root.val) in set we made flag as true else add the root.val in set.\n3.return flag. If flag==true it means target is found else target sum is not present in the BST.\n  \n  class Solution {\n   \n    HashSetset=new HashSet();//global set\n    boolean flag=false;//global variable\n    \n    \n    public void fun(TreeNode root,int target){\n        if(root==null){\n            return;\n        }\n        if(set.contains(target-root.val)){\n            flag=true;\n        }\n        else{\n            set.add(root.val);\n        }\n        fun(root.left,target);\n        fun(root.right,target);\n    }\n     public boolean findTarget(TreeNode root, int target) {\n         fun(root,target);\n         return flag;\n     }\n}\n\n"
  },
  {
    "path": "Length of Last Word.java",
    "content": "public class Solution {\n    // DO NOT MODIFY THE LIST. IT IS READ ONLY\n    public int lengthOfLastWord(final String s) {\n        int ans=0;\n        boolean started=false;\n        for(int i=s.length()-1;i>=0;i--){\n            if(s.charAt(i)==' '){\n                if(started){\n                    return ans;\n                }\n            }else{\n                started=true;\n                ans++;\n            }\n        }\n        return ans;\n    }\n}\n"
  },
  {
    "path": "Length of longest palindrome in Linked List.java",
    "content": "class GfG\n{\n        public static int fun(LinkedListlist,int start, int end){\n            //System.out.println(\"Hi\");\n            \n            while(startlist=new LinkedList();\n          Node temp=head;\n          while(temp!=null){\n              list.add(temp.data);\n              temp=temp.next;\n          }\n          int max=01;\n          int end=list.size()-1;\n          int start=0;\n          \n         for(int i=0;ii;j--){\n                 if(list.get(i)==list.get(j)){\n                     //System.out.println(\"hi\"+list.get(i));\n                     int a=fun(list,i,j);\n                     if(a!=-1){\n                         max=Integer.max(max,j-i+1);\n                         break;\n                     }\n                 }\n                 \n                 \n                 \n                \n             }\n         }\n          \n          return max;\n          \n        }\n}\n"
  },
  {
    "path": "Length of longest palindrome in linked list.java",
    "content": "class GfG\n{\n   \n        public static int maxPalindrome(Node head)\n        {\n          //add code here.\n          ArrayList al = new ArrayList<>();\n          while(head != null){\n              al.add(head.data);\n              head = head.next;\n          }\n          int[] arr = new int[2];\n          int center = 0;\n          while(center < al.size()){\n              center = binary(al,center,arr);\n              center++;\n          }\n          return(arr[1]-arr[0]-1);\n        }\n        public static int binary(ArrayList al , int i, int[] arr){\n            int n = al.size();\n            int new_center = i;\n            int t = i;\n            while(new_center < n-1 && al.get(new_center) == al.get(new_center+1) ){\n                new_center++;\n            }\n            int center = new_center;\n            while(t >= 0 && new_center < n && al.get(t) == al.get(new_center) ){\n                t--;\n                new_center++;\n            }\n            if(arr[1]-arr[0]-1 < new_center-t-1){\n                arr[0] = t;\n                arr[1] = new_center;\n            }\n            return center;\n        }\n}\n"
  },
  {
    "path": "Letter Phone.java",
    "content": "public class Solution {\n    String[] map = {\"0\", \"1\", \"abc\", \"def\", \"ghi\", \"jkl\", \"mno\", \"pqrs\", \"tuv\", \"wxyz\"};\n    public ArrayList letterCombinations(String digits) {\n        ArrayList res = new ArrayList<>();\n        if(digits == null || digits.length() == 0){\n            return res;\n        }\n        dfs(digits, 0, new StringBuilder(), res);\n        return res;\n    }\n    \n    public void dfs(String digits, int index, StringBuilder sb, ArrayList res){\n        if(index == digits.length()){\n            res.add(sb.toString());\n            return;\n        }\n        \n        String str = map[digits.charAt(index) - '0'];\n        for(int i = 0; i < str.length(); i++){\n            sb.append(str.charAt(i));\n            dfs(digits, index + 1, sb, res);\n            sb.deleteCharAt(sb.length() - 1);\n        }\n    }\n}\n"
  },
  {
    "path": "Level Order.java",
    "content": "public class Solution {\n    public ArrayList> levelOrder(TreeNode A) {\n        Queue q=new LinkedList<>();\n        q.add(A);\n        ArrayList> ans=new ArrayList<>();\n\n        while(!q.isEmpty()){\n            int size=q.size();\n            ArrayList arr=new ArrayList<>();\n            for(int i=0;i0 && m>0){\n            if(selectOne){\n                h+=3;\n                m+=2;\n                level++;\n                selectOne=false;\n            }else{\n                selectOne=true;\n                level++;\n                if(h>5 && m>10){\n                    h-=5;\n                    m-=10;\n                }else{\n                    h-=20;\n                    m+=5;\n                }\n            }\n        }\n        return level-1;\n    }\n}\n"
  },
  {
    "path": "Licence Key Formatting.java",
    "content": "class Solution{\n    static String ReFormatString(String s, int k){\n        StringBuilder sb=new StringBuilder(s);\n        StringBuilder sb2=new StringBuilder();\n        for(int i=0;i=0;i--){\n           if(s.charAt(i)!='-'){\n               if(count==k){\n                   count=01;\n                   sb1.append(\"-\");\n                   sb1.append(sb.charAt(i));\n               }\n               else{\n                   count++;\n                   sb1.append(sb.charAt(i));\n               }\n           }\n           \n        }\n        sb1.reverse();\n        return sb1.toString();\n        \n        \n    }\n}\n"
  },
  {
    "path": "License Key Formatting GFG/Licence.cpp",
    "content": "string ReFormatString(string S, int K){\n    \t  int len=0;\n        string temp=\"\";\n        for(int i=0;i=0; i--){\n    \t    if(tmp.length()==K){\n    \t        if(str.length()==0) str = tmp;\n    \t        else str = tmp + \"-\" + str ;\n    \t        tmp = \"\";\n    \t    }\n    \t    if(S[i]!='-'){  \n    \t        char ch;\n    \t        if(islower(S[i])) ch = toupper(int(S[i]));\n    \t        else ch = S[i];\n    \t        tmp = ch + tmp;\n    \t    }\n    \t}\n\n    \tif(tmp.length()>0){\n        \tif(str.length()==0) str = tmp;\n        \telse str = tmp + \"-\" + str;\n    \t}\n\n    \treturn str;\n    }\n};\n"
  },
  {
    "path": "License Key Formatting med s21.cpp",
    "content": "#include\nusing namespace std;\nclass Solution\n{\n   public:\n    string ReFormatString(string S, int K){\n    \tint n = S.size()-1,size =0;\n    \tstring res=\"\", temp=\"\";\n    \t\n    \twhile(n>=0){\n    \t    while(size=0){\n    \t        if(S[n]!='-'){\n    \t           // to check alphabets\n    \t           int check = isalpha(S[n]);\n    \t           if(check){\n    \t               S[n] = toupper(S[n]);\n    \t           }\n    \t           temp+=S[n];\n    \t           size++;\n    \t        }\n    \t        n--;\n    \t    }\n    \t    size=0;\n    \t    res+=temp;\n    \t    temp.clear();\n    \t    if(n>=0) res+='-';\n    \t}\n    \treverse(res.begin(), res.end());\n    \tif(res[0]=='-') return res.substr(1);\n    \treturn res;\n    \t\n    }\n};\n\nint main()\n{\n\tint t;\n\tcin>>t;\n\twhile(t--)\n\t{\n\t    string S;\n\t    cin>>S;\n\t    int K;\n\t    cin >> K;\n\t    Solution ob;  \n\t    string ans=ob.ReFormatString(S, K);\n\t    cout<\nusing namespace std;\n\n// } Driver Code Ends\n//Back-end complete function Template for C++\nclass Solution\n{\n   public:\n    string ReFormatString(string S, int K){\n    \t\n    \tint n = S.size();\n    \tstring ans, temp;\n    \t\n    \t/*we start fro the end of the string , \n    \tbecause only the first group can have contain characters less than K*/\n    \tfor(int i=n-1;i>=0;i--){           \n    \t    char ch = S[i];\n    \t    \n    \t    //if we encounter a dash, ignore and continue\n    \t    if(ch=='-')\n    \t        continue;\n    \t    else{\n    \t        \n    \t        //change to uppercase\n    \t        temp+=toupper(ch);\n    \t        \n    \t        //check temp size\n    \t        if(temp.size() == K){\n    \t            \n    \t            //add temp to ans\n    \t            ans+=temp;      \n    \t            \n    \t            //add dash b/w them\n    \t            ans+='-';\n    \t            \n    \t            //empty the temp to search for next K elements\n    \t            temp=\"\";\n    \t        }\n    \t    }\n    \t}\n    \t\n    \t/*Adding the leftover elements(Since the size of temp never reached K, \n    \ttemp won't enter the if case nested inside the else ABOVE)*/\n    \tans+=temp;\n    \t\n    \t//Since we stored the elements in temp in reverse order, we'll reverse\n    \treverse(ans.begin(), ans.end());\n    \t\n    \t//Incase the first element is a dash, we would remove it\n    \tif(ans[0] == '-')\n    \t    ans.erase(ans.begin());\n    \t    \n    \treturn ans;\n    }\n};\n\n//{ Driver Code Starts.\nint main()\n{\n\tint t;\n\tcin>>t;\n\twhile(t--)\n\t{\n\t    string S;\n\t    cin>>S;\n\t    int K;\n\t    cin >> K;\n\t    Solution ob;  \n\t    string ans=ob.ReFormatString(S, K);\n\t    cout<=0;i--){\n    \t   if(s[i] == '-'){\n    \t       if(cnt== k){\n    \t           cnt=0;\n    \t           ans+= '-';\n    \t       }\n    \t   }else{\n    \t       if(cnt == k){\n    \t           ans+= '-';\n    \t           cnt=0;\n    \t       }\n    \t       cnt++;\n    \t       if(s[i] <= 'z' && s[i] >= 'a'){\n    \t           ans += char('A' + (s[i]-'a'));\n    \t       }else{\n    \t           ans+= s[i];\n    \t       }\n    \t   }\n    \t}\n    \tif(ans.back() == '-'){\n    \t    ans.pop_back();\n    \t}\n    \treverse(ans.begin(), ans.end());\n    \treturn ans;\n    }\n};\n"
  },
  {
    "path": "License Key Formatting.java",
    "content": "class Solution{\n    static String ReFormatString(String S, int K){\n        StringBuilder ans = new StringBuilder();\n        int cnt = 0;\n        for(int i = S.length() - 1; i >= 0; i--) {\n                char ch = S.charAt(i);\n                if(ch != '-' && cnt < K){\n                    ans.append(Character.toUpperCase(ch));\n                    cnt++;\n                }\n                if(cnt==K){\n                    cnt = 0;\n                    ans.append('-');\n                }\n        }\n        ans.reverse();\n        if(ans.length() > 0 && ans.charAt(0)=='-') ans.deleteCharAt(0);\n        return ans.toString();\n        \n    }\n}\n"
  },
  {
    "path": "Linked List Cycle II.java",
    "content": "public class Solution {\n    public ListNode detectCycle(ListNode head) {\n        ListNode meet=detect(head);\n        if(meet==null)return meet;\n        ListNode temp=head;\n        while(temp!=meet){\n            temp=temp.next;\n            meet=meet.next;\n        }\n        return temp;\n    }\n    public ListNode detect(ListNode node){\n        ListNode slow=node;\n        ListNode fast=node;\n        while(fast!=null && fast.next!=null){\n            slow=slow.next;\n            fast=fast.next.next;\n            if(slow==fast)return fast;\n        }\n        return null;\n    }\n}\n"
  },
  {
    "path": "Linked List Cycle.java",
    "content": "public class Solution {\n    public boolean hasCycle(ListNode head) {\n        ListNode slow=head;\n        ListNode fast=head;\n        while(fast!=null && fast.next!=null){\n            slow=slow.next;\n            fast=fast.next.next;\n            if(slow==fast)return true;\n        }\n        return false;\n    }\n}\n"
  },
  {
    "path": "Longest Bitonic subsequence.cpp",
    "content": "class Solution{\n\tpublic:\n\tint LongestBitonicSequence(vectornums)\n\t{\n\t    vector Incre(nums.size(), 0 ), Dec(nums.size(), 0);\n\t    \n\t    Incre[0] = 1;\n\t    for(int i=1; i=0; i--){\n\t        int mx = 0;\n\t        for(int j=i+1;j a) {\n        String ans=a.get(0);\n        int index=0;\n        String s=\"\";\n        for(int i=1;isz){\n                    sz=j-i+1;\n                    asnI=i;\n                    ansJ=j+1;\n                }\n            }\n        }\n        return s.substring(asnI,ansJ);\n    }\n}\n"
  },
  {
    "path": "Longest Path in a matrix - GFG/README.md",
    "content": "# Longest Path in a matrix\n## Hard \n
\n                
Given a n*m matrix, find the maximum length path (starting from any cell) such that all cells along the path are in strictly increasing order.
\n\n
We can move in 4 directions from a given cell (i, j), i.e., we can move to (i+1, j) or (i, j+1) or (i-1, j) or (i, j-1).
\n 
\n\n
Example 1:
\n\n
Input: matrix = {{1,2,9},{5,3,8},{4,6,7}}\nOutput: 7\nExplanation: The longest increasing path is\n{1,2,3,6,7,8,9}.\n
\n\n
Example 2:
\n\n
Input: matrix = {{3,4,5},{3,2,6},{2,2,1}}\nOutput: 4\nExplanation: The longest increasing path is\n{3,4,5,6}.\n
\n\n
 
\n\n
Your Task:
\nYou don't need to read or print anyhting. Your task is to complete the function longestIncreasingPath() which takes matrix as input parameter and returns the length of the lonest increasing path.
\n
\nExpected Time Complexity: O(n*m)
\nExpected Space Comeplxity: O(n*m)
\n 
\n\n
Constraints:
\n1 <= n, m <= 100
\n1 <= matrix[i][j] <= 104
\n 
\n            
"
  },
  {
    "path": "Longest Path in a matrix - GFG/longest-path-in-a-matrix.java",
    "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n    public static void main(String[] args) throws IOException\n    {\n        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n        int T = Integer.parseInt(br.readLine().trim());\n        while(T-->0)\n        {\n            String[] S1 = br.readLine().trim().split(\" \");\n            int n  = Integer.parseInt(S1[0]);\n            int m = Integer.parseInt(S1[1]);\n            int[][] matrix = new int[n][m];\n            for(int i = 0; i < n; i++){\n                String[] S2 = br.readLine().trim().split(\" \");\n                for(int j = 0; j < m; j++){\n                    matrix[i][j] = Integer.parseInt(S2[j]);\n                }\n            }\n            Solution obj = new Solution();\n            int ans = obj.longestIncreasingPath(matrix);\n            System.out.println(ans);\n        }\n    }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n    int[][]dp;\n    int [][]arr;\n    public int longestIncreasingPath(int[][] matrix){\n        int n=matrix.length;\n        int m=matrix[0].length;\n        dp=new int[n][m];\n        arr=matrix;\n        int ans=Integer.MIN_VALUE;\n        for(int i=0;iarr[i][j]){\n                int curr=dfs(i+1,j);\n                ans=Math.max(ans,curr);\n            }\n            if(valid(i-1,j) && arr[i-1][j]>arr[i][j]){\n                int curr=dfs(i-1,j);\n                ans=Math.max(ans,curr);\n            }\n            if(valid(i,j+1) && arr[i][j+1]>arr[i][j]){\n                int curr=dfs(i,j+1);\n                ans=Math.max(ans,curr);\n            }\n            if(valid(i,j-1) && arr[i][j-1]>arr[i][j]){\n                int curr=dfs(i,j-1);\n                ans=Math.max(ans,curr);\n            }\n            dp[i][j]=ans+1;\n            return dp[i][j];\n        }else{\n            return 0;\n        }\n    }\n    public boolean valid(int i,int j){\n        int n=arr.length;\n        int m=arr[0].length;\n        if(i<0 || j<0 || i==n || j==m)return false;\n        return true;\n    }\n}"
  },
  {
    "path": "Longest Possible Route in a Matrix with Hurdles - GFG/README.md",
    "content": "# Longest Possible Route in a Matrix with Hurdles\n## Medium \n
\n                
Given an N x M matrix, with a few hurdles(denoted by 0) arbitrarily placed, calculate the length of the longest possible route possible from source(xs,ys) to a destination(xd,yd) within the matrix. We are allowed to move to only adjacent cells which are not hurdles. The route cannot contain any diagonal moves and a location once visited in a particular path cannot be visited again.If it is impossible to reach the destination from the source return -1.
\n\n
 
\n\n
Example 1:
\n\n
Input:\n{xs,ys} = {0,0}\n{xd,yd} = {1,8}\nmatrix = 1 1 1 1 1 1 1 1 1 1\n         1 1 0 1 1 0 1 1 0 1\n         1 1 1 1 1 1 1 1 1 1\nOutput: 24\nExplanation:\n\"\"
\n\n
 
\n\n
Example 2:
\n\n
Input: \n{xs,ys} = {0,3}\n{xd,yd} = {2,2}\nmatrix = 1 0 0 1 0\n         0 0 0 1 0\n         0 1 1 0 0\nOutput: -1\nExplanation:\nWe can see that it is impossible to\nreach the cell (2,2) from (0,3).\n
\n\n
Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function longestPath() which takes matrix ,source and destination as input parameters and returns an integer denoting the longest path.
\n\n

\nExpected Time Complexity: O(2^(N*M))
\nExpected Auxiliary Space: O(N*M)
\n\n

\nConstraints:
\n1 <= N,M <= 10
\n 
\n            
"
  },
  {
    "path": "Longest Possible Route in a Matrix with Hurdles - GFG/longest-possible-route-in-a-matrix-with-hurdles.java",
    "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\n\nclass IntArray\n{\n    public static int[] input(BufferedReader br, int n) throws IOException\n    {\n        String[] s = br.readLine().trim().split(\" \");\n        int[] a = new int[n];\n        for(int i = 0; i < n; i++)\n            a[i] = Integer.parseInt(s[i]);\n        \n        return a;\n    }\n    \n    public static void print(int[] a)\n    {\n        for(int e : a)\n            System.out.print(e + \" \");\n        System.out.println();\n    }\n    \n    public static void print(ArrayList a)\n    {\n        for(int e : a)\n            System.out.print(e + \" \");\n        System.out.println();\n    }\n}\n\n\nclass IntMatrix\n{\n    public static int[][] input(BufferedReader br, int n, int m) throws IOException\n    {\n        int[][] mat = new int[n][];\n        \n        for(int i = 0; i < n; i++)\n        {\n            String[] s = br.readLine().trim().split(\" \");\n            mat[i] = new int[s.length];\n            for(int j = 0; j < s.length; j++)\n                mat[i][j] = Integer.parseInt(s[j]);\n        }\n        \n        return mat;\n    }\n    \n    public static void print(int[][] m)\n    {\n        for(var a : m)\n        {\n            for(int e : a)\n                System.out.print(e + \" \");\n            System.out.println();\n        }\n    }\n    \n    public static void print(ArrayList> m)\n    {\n        for(var a : m)\n        {\n            for(int e : a)\n                System.out.print(e + \" \");\n            System.out.println();\n        }\n    }\n}\n\nclass GFG {\n    public static void main(String[] args) throws IOException {\n        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n        int t;\n        t = Integer.parseInt(br.readLine());\n        while(t-- > 0){\n            \n            int[] a = IntArray.input(br, 2);\n            \n            \n            int[] b = IntArray.input(br, 4);\n            \n            \n            int[][] mat = IntMatrix.input(br, a[0], a[1]);\n            \n            Solution obj = new Solution();\n            int res = obj.longestPath(mat,a[0],a[1],b[0],b[1],b[2],b[3]);\n            \n            System.out.println(res);\n            \n        }\n    }\n}\n// } Driver Code Ends\n\n\nclass Solution {\n    static int xd;\n    static int yd;\n    public static int longestPath(int[][] mat,int n,int m,int xs,int ys,int x,int y) {\n        xd=x;\n        yd=y;\n        boolean[][]vis=new boolean[n][m];\n        int ans=dfs(mat,xs,ys,vis);\n        return ans<0?-1:ans;\n    }\n    public static int dfs(int[][]mat,int x,int y,boolean[][]vis){\n        if(!valid(mat,x,y,vis))return Integer.MIN_VALUE;\n        if(x==xd && y==yd)return 0;\n        \n        vis[x][y]=true;\n        \n        int ans=Integer.MIN_VALUE;\n        \n        if(valid(mat,x+1,y,vis))\n            ans=Math.max(ans,1+dfs(mat,x+1,y,vis));\n        if(valid(mat,x,y+1,vis))\n            ans=Math.max(ans,1+dfs(mat,x,y+1,vis));\n        if(valid(mat,x-1,y,vis))\n            ans=Math.max(ans,1+dfs(mat,x-1,y,vis));\n        if(valid(mat,x,y-1,vis))\n            ans=Math.max(ans,1+dfs(mat,x,y-1,vis));\n            \n        vis[x][y]=false;\n        return ans;\n    }\n    \n    public static boolean valid(int[][]mat,int x,int y,boolean[][]vis){\n        if(x<0 || y<0 || x==mat.length || y==mat[0].length)return false;\n        if(mat[x][y]==0 || vis[x][y])return false;\n        return true;\n    }\n}\n"
  },
  {
    "path": "Longest Sub-Array with Sum K.cpp",
    "content": "class Solution{\n    public:\n    int lenOfLongSubarr(int A[],  int N, int K) \n    { \n        // Complete the function\n        map mp;\n        mp.insert({0,-1});\n      \n        int ans = 0, sum = 0;\n        \n        for(int i=0; i map=new HashMap<>();\n        int sum=0;\n        int length=0;\n        for(int i=0;i\n                
Given an array containing N integers and a positive integer K, find the length of the longest sub array with sum of the elements divisible by the given value K.
\n\n
Example 1:
\n\n
Input:\nA[] = {2, 7, 6, 1, 4, 5}\nK = 3\nOutput: 4\nExplanation:The subarray is {7, 6, 1, 4}\nwith sum 18, which is divisible by 3.
\n\n
Example 2:
\n\n
Input:\nA[] = {-2, 2, -5, 12, -11, -1, 7}\nK = 3\nOutput: 5\nExplanation:\nThe subarray is {2,-5,12,-11,-1} with\nsum -3, which is divisible by 3.
\n\n
 
\n\n
Your Task:
\nThe input is already taken care of by the driver code. You only need to complete the function longSubarrWthSumDivByK() that takes an array (arr), sizeOfArray (n), positive integer K, and return the length of the longest subarray which has sum divisible by K. The driver code takes care of the printing.
\n
\nExpected Time Complexity: O(N).
\nExpected Auxiliary Space: O(N).
\n\n
Constraints:
\n1<=N,K<=106
\n-105<=A[i]<=105
\n 
\n 
\n
" }, { "path": "Longest subarray with sum divisible by K - GFG/longest-subarray-with-sum-divisible-by-k.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\n // } Driver Code Ends\n//User function Template for Java\n\nclass Solution{\n int longSubarrWthSumDivByK(int a[], int n, int k){\n int prefixSum = 0;\n int maxResult = 0;\n HashMap map = new HashMap<>();\n for (int i = 0; i < a.length; i++) {\n prefixSum += a[i];\n int rem = ((prefixSum%k) + k) % k;\n if(rem == 0)maxResult = i + 1;\n if(map.containsKey(rem))\n maxResult = Math.max(maxResult,i-map.get(rem));\n else\n map.put(rem,i);\n }\n return maxResult;\n }\n}\n// { Driver Code Starts.\n\n// Driver class\nclass GFG {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t \n\t\t String line1 = br.readLine();\n\t\t String[] element = line1.trim().split(\"\\\\s+\");\n\t\t int sizeOfArray = Integer.parseInt(element[0]);\n\t\t int K = Integer.parseInt(element[1]);\n\t\t \n\t\t int arr [] = new int[sizeOfArray];\n\t\t \n\t\t String line = br.readLine();\n\t\t String[] elements = line.trim().split(\"\\\\s+\");\n\t\t \n\t\t for(int i = 0;i\n

Given a string S which only contains lowercase alphabets. Find the length of the longest substring of S such that the characters in it can be rearranged to form a palindrome.

\n\n


\nExample 1:

\n\n
Input:\nS = \"aabe\"\nOutput:\n3\nExplanation:\nThe substring \"aab\" can be rearranged to\n\"aba\" which is the longest palindrome\npossible for this String.\n
\n\n
Example 2:
\n\n
Input:\nS = \"adbabd\"\nOutput:\n6\nExplanation:\nThe whole string “adbabd” can be\nrearranged to form a palindromic substring.\nOne possible arrangement is \"abddba\".\nThus, output length of the string is 6. \n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function longestSubstring() which takes a String S as input and returns the length of largest possible Palindrome.

\n\n


\nExpected Time Complexity: O(|S|*26)
\nExpected Auxiliary Space: O(|S|*26)

\n\n


\nConstraints:
\n1 ≤ |S| ≤ 105

\n

\n " }, { "path": "Longest substring to form a Palindrome - GFG/longest-substring-to-form-a-palindrome.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n String S = read.readLine();\n \n Solution ob = new Solution();\n System.out.println(ob.longestSubstring(S));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution {\n static int longestSubstring(String S) {\n \n int n = S.length();\n Map index = new HashMap<>();\n \n // Initialize answer with 0 \n int answer = 0;\n \n int mask = 0;\n index.put(mask, -1);\n \n for(int i = 0; i < n; i++){\n int temp = (int)S.charAt(i) - 97;\n // Turn the temp-th bit on if \n // character occurs odd number \n // of times and turn off the temp-th \n // bit off if the character occurs \n // ever number of times \n mask ^= (1 << temp);\n // If a mask is present in the index \n // Therefore a palindrome is \n // found from index[mask] to i \n if (index.containsKey(mask)){ \n answer = Math.max(answer, i - index.get(mask)); \n }\n // If x is not found then add its \n // position in the index dict. \n else\n index.put(mask,i); \n \n // Check for the palindrome of \n // odd length \n for (int j = 0;j < 26; j++){\n // We cancel the occurrence \n // of a character if it occurs \n // odd number times \n int mask2 = mask ^ (1 << j);\n if (index.containsKey(mask2))\n { \n answer = Math.max(answer, \n i - index.get(mask2)); \n }\n }\n }\n return answer;\n }\n};" }, { "path": "Longest valid Parentheses.java", "content": "public class Solution {\n public int longestValidParentheses(String s) {\n int ans=0;\n int n=s.length();\n int open=0;\n int close=0;\n for(int i=0;iopen){\n open=close=0;\n }else if(open==close)\n ans=Math.max(ans,open*2);\n }\n open=close=0;\n for(int i=n-1;i>=0;i--){\n if(s.charAt(i)==')')\n close++;\n else\n open++;\n \n if(close> map=new HashMap<>();\n for(int i=0;i());\n for(int j=0;j> map,int currNode,int[]col,int n,int m){\n if(currNode==n)return true;\n for(int currColor=1;currColor<=m;currColor++){\n if(safe(currNode,currColor,map,col)){\n col[currNode]=currColor;\n if(dfs(map,currNode+1,col,n,m))return true;\n col[currNode]=0;//backtracking\n }\n }\n return false;\n }\n \n boolean safe(int currNode,int currColor,Map> map,int[]col){\n ArrayList arr=map.get(currNode);\n for(int neb:arr){\n if(col[neb]==currColor)return false;\n }\n return true;\n }\n}\n" }, { "path": "MInimum time to fulfil all orders.cpp", "content": "class Solution{\n public:\n \n // Function to return number of donuts prepared by R rank in T time\n int countDonut(int R, int T)\n {\n int cnt = 1;\n \n while(T-R*cnt >= 0)\n {\n T -= R*cnt;\n cnt++;\n }\n \n return cnt-1;\n }\n \n int findMinTime(int N, vector&A, int L){\n //write your code here\n int ans = INT_MAX;\n int low = 0, high = INT_MAX;\n \n while(low <= high)\n {\n int mid = low + (high-low)/2;\n int cnt = 0;\n \n for(auto it : A)\n cnt += countDonut(it, mid);\n \n if(cnt >= N)\n {\n ans = mid;\n high = mid-1;\n }\n else\n low = mid+1;\n }\n \n return ans;\n }\n};\n" }, { "path": "Magician and Chocolates.java", "content": "public class Solution {\n public int nchoc(int A, ArrayList B) {\n Queue pq=new PriorityQueue<>((a,b)->b-a);\n pq.addAll(B);\n int ans=0;\n int mod=1000000007;\n while(A-->0){\n int ele=pq.remove();\n ans=(ans%mod +ele%mod)%mod;\n pq.add(ele/2);\n }\n return ans;\n }\n}\n" }, { "path": "Magnet Array Problem - GFG/README.md", "content": "# Magnet Array Problem\n## Medium \n
\n

Given N Magnets which are placed linearly, with each magnet to be considered as of point object. Each magnet suffers force from its left sided magnets such that they repel it to the right and vice versa. All forces are repulsive. The force being equal to the distance (1/d , d being the distance). Now given the positions of the magnets, the task to find all the points along the linear line where net force is ZERO. 

\n\n

More Formally, Magnets are placed on X axis, the coordinates of which are given, you are asked to find out the X-co-ordinates of all the equilibrium points (i.e. the point where net force is zero). You notice the point each magnet repels each other, it means the polarity of the magnet is such that exerts +ve force in its right side and -ve force in left side, (here +ve is considered in +ve direction of x-axis). And that forces are inversely proportional to the distance, thus there lies an equilibrium point between every two magnetic points. Thus there will be total of N-1 equllibrium points. You have to find those N-1 points.
\nNote: Array M[] is sorted and distance have to be calculated with precision of 2 decimal places.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 2\nM[] = {1, 2}\nOutput:\n1.50\nExplanation:\nThe mid point of two points will have \nnet force zero, thus answer = 1.50\n
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 4\nM[] = {0, 10, 20, 30}\nOutput:\n3.82, 15.00, 26.18
\n\n

 

\n\n

Your Task:  
\nYou don't need to read input or print anything. Your task is to complete the function nullPoints() which takes the array M[], its size N as inputs and an answer array getAnswer[] to store the points having net force zero till precised two decimal places.

\n\n


\nExpected Time Complexity: O(N2 * Log(N))
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n2 ≤ N ≤ 105
\n0 ≤  M[1] < ....M[i] < M[i+1] < ....M[N] ≤ 106
\n 

\n\n

 

\n\n

 

\n\n

 

\n

\n
" }, { "path": "Magnet Array Problem - GFG/magnet-array-problem.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\n\nclass GFG {\n\tpublic static void main(String[] args) throws IOException\n\t{\n\t BufferedReader br =\n new BufferedReader(new InputStreamReader(System.in));\n int t =\n Integer.parseInt(br.readLine().trim()); // Inputting the testcases\n while(t-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n double a[] = new double[(int)(n)];\n double getAnswer[] = new double[(int)(n)];\n String inputLine[] = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) {\n a[i] = Double.parseDouble(inputLine[i]);\n }\n \n Solution obj = new Solution();\n obj.nullPoints(n, a, getAnswer); \n \n StringBuilder output = new StringBuilder();\n for(int i=0;i map=new HashMap<>();\n for(int i=0;i set=new HashSet<>();\n set.add(A[0]+B);\n set.add(A[0]-B);\n for(int i=1;i> &dp, int arr[] , int i , int j)\n {\n if(i == j)\n return dp[i][j] = 0;\n if(dp[i][j] != -1)\n return dp[i][j];\n \n int mn = INT_MAX; \n for(int k = i;k> dp(N-1 , vector(N-1 , -1));\n solve(dp , arr , 0 , N-2);\n return dp[0][N-2];\n // code here\n }\n};\n" }, { "path": "Matrix Exponentiation - GFG/README.md", "content": "# Matrix Exponentiation\n## Medium \n
\n

Given an equation of the form f(n) = f(n-1) + f(n-2) where f(0) = 1, F(1) = 1 , the task is to find the nth term of this sequence.
\n 

\n\n

Example 1:

\n\n
Input: n = 3\nOutput: 3\nExplanation: f(3) = f(2) + f(1) = 3\n\n
\n\n

Example 2:

\n\n
Input: n = 2\nOutput: 2\nExplanation: f(2) = f(1) + f(0) = 2\n
\n\n

 

\n\n

Yout Task:
\nYou don't need to read or print anything. Your task is to complete the function FindNthTerm() which takes n as input parameter and returns nth term mod 10^9+7 .

\n\n


\nExpected Time Compelxity: O(log(n))
\nExpected Space Complexity: O(K) where K is constant.
\n 

\n\n

Constraints:
\n1 <= n <= 109

\n

\n
" }, { "path": "Matrix Exponentiation - GFG/matrix-exponentiation.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n Solution ob = new Solution();\n int ans = ob.FindNthTerm(n);\n System.out.println(ans);\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n static long mod = 1000000007;\n \n long[][] multiply(long [][]m1, long[][]m2)\n {\n long ans[][] =new long[2][2];\n for(int i=0;i<2;i++)\n for(int j=0;j<2;j++)\n for(int k=0;k<2;k++)\n ans[i][j] += (m1[i][k]*m2[k][j])%mod;\n return ans;\n }\n \n \n long[][] matPow(long [][]mat,long n){\n if(n == 1)return mat;\n long[][] ans = matPow(mat,n/2);\n ans = multiply(ans,ans);\n if((n&1) == 1)ans = multiply(ans,mat);\n return ans;\n }\n \n public int FindNthTerm(int N){\n long n = N;\n if(n==1 || n==0)return 1;\n long mat[][] = {{1,1},{1,0}};\n mat = matPow(mat,n);\n return (int) (mat[0][0]%mod);\n }\n}" }, { "path": "Matrix Operations.java", "content": "class Solution{\n static int[]UP=new int[]{-1,0};\n static int[]RIGHT=new int[]{0,1};\n static int[]DOWN=new int[]{1,0};\n static int[]LEFT=new int[]{0,-1};\n static int [] endPoints(int [][]arr, int m, int n){\n char dir='R';\n int row=0;\n int col=0;\n while(true){\n if(arr[row][col]==1){\n arr[row][col]=0;\n dir=changeDir(dir);\n }\n int[]move=getDir(dir);\n if(outOfBounds(arr,row+move[0],col+move[1])){\n return new int[]{row,col};\n }else{\n row+=move[0];\n col+=move[1];\n }\n }\n }\n static boolean outOfBounds(int[][] arr,int row,int col){\n int a=arr.length;\n int b=arr[0].length;\n if(row>=a)return true;\n if(col>=b)return true;\n if(row<0 || col<0)return true;\n return false;\n }\n static int[] getDir(char c){\n if(c=='U'){\n return UP;\n }else if(c=='D'){\n return DOWN;\n }else if(c=='R'){\n return RIGHT;\n }else{\n return LEFT;\n }\n }\n static char changeDir(char c){\n if(c=='R'){\n return 'D';\n }else if(c=='D'){\n return 'L';\n }else if(c=='L'){\n return 'U';\n }else{\n return 'R';\n }\n }\n}\n" }, { "path": "Matrix Search.java", "content": "public class Solution {\n public int searchMatrix(ArrayList> A, int B) {\n return dfs(A,B,0,A.size()-1);\n }\n public int dfs(ArrayList> A, int B,int l,int h){\n if(l<=h){\n int mid=l+(h-l)/2;\n if(A.get(mid).get(0)>B){\n return dfs(A,B,l,mid-1);\n }else if(A.get(mid).get(A.get(mid).size()-1)=0;i--)\n rmax[i]=Math.max(rmax[i+1],arr[i]);\n int i=0,j=0;\n while(i maxset(ArrayList a) {\n long max=0;\n ArrayList ans=new ArrayList<>();\n int i=0;\n while(i maybe=new ArrayList<>();\n while(imax){\n max=curr;\n ans.clear();\n ans=maybe;\n }else if(curr==max){\n if(maybe.size()>ans.size()){\n ans.clear();\n ans=maybe;\n }\n }\n i++;\n }\n return ans;\n }\n}\n" }, { "path": "Max Product Subarray.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public int maxProduct(final int[] nums) {\n int length = nums.length;\n int result = nums[0];;\n int curr_max = nums[0];\n int curr_min = nums[0];\n for(int i =1; i < length; i++){\n int curr_max_prev= curr_max;\n curr_max = Math.max(nums[i], Math.max(curr_max*nums[i], curr_min*nums[i]));\n curr_min = Math.min(nums[i], Math.min(curr_max_prev*nums[i], curr_min*nums[i]));\n result = Math.max(result,curr_max); \n } \n return result; \n }\n}\n" }, { "path": "Max Rectangle in Binary Matrix.java", "content": "public class Solution {\n public int maximalRectangle(int[][] a) {\n int max=Integer.MIN_VALUE;\n for(int i=0;i s=new ArrayDeque<>();\n for(int i=0;i=a[i]){\n s.pop();\n }\n if(s.isEmpty()){\n ps[i]=-1;\n }else{\n ps[i]=s.peek();\n }\n s.push(i);\n }\n return ps;\n }\n public int[] nextSmallest(int[]a){\n int ns[]=new int[a.length];\n Deque s=new ArrayDeque<>();\n for(int i=a.length-1;i>=0;i--){\n while(!s.isEmpty() && a[s.peek()]>=a[i]){\n s.pop();\n }\n if(s.isEmpty()){\n ns[i]=a.length;\n }else{\n ns[i]=s.peek();\n }\n s.push(i);\n }\n return ns;\n }\n}\n" }, { "path": "Max Sum Path in Binary Tree.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n Map map;\n public int maxPathSum(TreeNode A) {\n if(A==null)return 0;\n map=new HashMap<>();\n return dfs(A);\n }\n int dfs(TreeNode A){\n if(A==null)\n return Integer.MIN_VALUE;\n int s=A.val;\n if(A.left!=null && sum(A.left)>0)\n s=s+sum(A.left);\n if(A.right!=null && sum(A.right)>0)\n s=s+sum(A.right);\n return max(s,dfs(A.left),dfs(A.right));\n }\n int max(int a,int b,int c){\n return (a>b&&a>c?a:(b>c?b:c));\n }\n int sum(TreeNode A){\n if(A==null)\n return 0;\n if(map.containsKey(A))return map.get(A);\n int ans=A.val+Math.max(sum(A.left),sum(A.right));\n map.put(A,ans);\n return ans;\n }\n}\n" }, { "path": "Max length chain.cpp", "content": "class Solution{\npublic:\n /*You are required to complete this method*/\n int maxChainLen(struct val p[],int n){\n //Your code here\n vector>ans;\n for(int i=0;ix)\n {\n x = ans[i+1].first;\n count++;\n }\n }\n return count;\n }\n};\n" }, { "path": "Max length chain.java", "content": "class GfG\n{\n int maxChainLength(Pair arr[], int n)\n {\n Arrays.sort(arr,(a,b)->a.y-b.y);\n int ans=1;\n int prev=arr[0].y;\n for(int i=1;iprev){\n prev=arr[i].y;\n ans++;\n }\n }\n return ans;\n }\n}\n" }, { "path": "Maximize Distance to Closest Person", "content": "class Solution {\n public int maxDistToClosest(int[] seats) {\n int max=Integer.MIN_VALUE;\n for(int i=0;i=0){\n leftClosest++;\n if(a[x]==1)break;\n x--;\n }\n int y=i+1;\n int rightClosest=0;\n while(y\n

Given two integer arrays Arr1 and Arr2 of size N. Use the greatest elements from the given arrays to create a new array of size N such that it consists of only unique elements and the sum of all its elements is maximum.
\nThe created elements should contain the elements of Arr2 followed by elements of Arr1 in order of their appearance.

\n\n


\nExample 1:

\n\n
Input:\nN = 5\nArr1 = {7, 4, 8, 0, 1}\nArr2 = {9, 7, 2, 3, 6}\nOutput: 9 7 6 4 8\nExplanation: 9, 7, 6 are from 2nd array\nand 4, 8 from 1st array.
\n\n


\nExample 2:

\n\n
Input: N = 4\nArr1 = {6, 7, 5, 3}\nArr2 = {5, 6, 2, 9} \nOutput: 5 6 9 7 \nExplanation: 5, 6, 9 are from 2nd array\nand 7 from 1st array.
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function maximizeArray() which takes the array arr1[], arr2[] and n as input parameters and returns the desired array of integers.

\n\n


\nExpected Time Complexity: O(NlogN)
\nExpected Auxiliary Space: O(N)

\n\n


\nConstraints:
\n1 <= N <= 105
\n0 <=| Arr1[i] |<= 109
\n0 <= |Arr2[i] |<= 109

\n

\n " }, { "path": "Maximize The Array - GFG/maximize-the-array.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nimport java.lang.*;\n\npublic class GFG {\n\n public static void main(String[] args) throws Exception {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int tc = Integer.parseInt(br.readLine().trim());\n while (tc-- > 0) {\n String[] inputLine;\n int n = Integer.parseInt(br.readLine().trim());\n int[] arr1 = new int[n], arr2 = new int[n];\n inputLine = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) {\n arr1[i] = Integer.parseInt(inputLine[i]);\n }\n inputLine = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) {\n arr2[i] = Integer.parseInt(inputLine[i]);\n }\n\n ArrayList ans = new Solution().maximizeArray(arr1, arr2, n);\n for (Integer x : ans) {\n System.out.print(x + \" \");\n }\n System.out.println();\n }\n }\n}\n// } Driver Code Ends\n\nclass Solution {\n ArrayList maximizeArray(int[] arr1, int[] arr2, int n) {\n ArrayList ans=new ArrayList<>();\n PriorityQueue pq=new PriorityQueue<>((a,b)->b-a);\n for(int i:arr1)pq.add(i);\n for(int i:arr2)pq.add(i);\n Set set=new HashSet();\n while(set.size()!=n && pq.size()>0){\n set.add(pq.remove());\n }\n for(int i:arr2){\n if(set.contains(i)){\n ans.add(i);\n set.remove(i);\n }\n }\n for(int i:arr1){\n if(set.contains(i)){\n ans.add(i);\n set.remove(i);\n }\n }\n return ans;\n }\n}" }, { "path": "Maximize the sum of selected numbers from an array to make it empty - GFG/README.md", "content": "# Maximize the sum of selected numbers from an array to make it empty\n## Medium\n

Given a array of N numbers, we need to maximize the sum of selected numbers. At each step, you need to select a number Ai, delete one occurrence of Ai-1 (if exists), and Ai each from the array. Repeat these steps until the array gets empty. The problem is to maximize the sum of the selected numbers.

\n\n

Example 1:

\n\n
Input : arr[ ] = {1, 2, 2, 2, 3, 4}\nOutput : 10\nExplanation:\nWe select 4, so 4 and 3 are deleted leaving us with {1,2,2,2}.\nThen we select 2, so 2 & 1 are deleted. We are left with{2,2}.\nWe select 2 in next two steps, thus the sum is 4+2+2+2=10.\n
\n\n


\nExample 2:

\n\n
Input : arr[ ] = {1, 2, 3} \nOutput :  4\nExplanation: We select 3, so 3 and 2 are deleted leaving us with {1}. Then we select 1, 0 doesn't exist so we delete 1. thus the sum is 3+1=4.\n
\n\n

 

\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function maximizeSum() that takes an array (arr), sizeOfArray (n), and return the maximum sum of the selected numbers. The driver code takes care of the printing.

\n\n

Expected Time Complexity: O(N).
\nExpected Auxiliary Space: O(N).

\n\n


\nConstraints:
\n1 ≤ N ≤ 105
\n1 ≤ A[i] ≤ 105
\nNote: Numbers need to be selected from maximum to minimum.

\n
" }, { "path": "Maximize the sum of selected numbers from an array to make it empty - GFG/maximize-the-sum-of-selected-numbers-from-an-array-to-make-it-empty.java", "content": "//{ Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t String line = br.readLine();\n\t\t String[] element = line.trim().split(\"\\\\s+\");\n\t\t int sizeOfArray = Integer.parseInt(element[0]);\n\t\t \n\t\t int arr [] = new int[sizeOfArray];\n\t\t \n\t\t line = br.readLine();\n\t\t String[] elements = line.trim().split(\"\\\\s+\");\n\t\t for(int i = 0;i=0;i--){\n int curr=arr[i];\n if(map[curr]!=0){\n sum+=curr;\n map[curr]--;\n if(map[curr-1]!=0){\n map[curr-1]--;\n }\n }\n \n }\n return sum;\n }\n \n \n}\n\n\n" }, { "path": "Maximum Depth of Binary Tree.java", "content": "class Solution {\n public int maxDepth(TreeNode root) {\n if(root==null){\n return 0;\n }\n return Math.max(maxDepth(root.right),maxDepth(root.left))+1;\n }\n}\n" }, { "path": "Maximum GCD of siblings of a binary tree - GFG/README.md", "content": "# Maximum GCD of siblings of a binary tree\n## Easy \n
\n

Given a 2d list that represents the nodes of a Binary tree with N nodes, the task is to find the maximum GCD of the siblings of this tree without actually constructing it.
\nNote: If there are no pairs of siblings in the given tree, print 0. Also, if given that there's an edge between a and b in the form of {a,b} in the list, then a is the parent node.

\n\n


\nExample 1:

\n\n
Input:\nN = 7\narr = {{4, 5}, {4, 2}, {2, 3}, {2, 1}, {3, 6}, {3, 12}}\nOutput:\n6\nExplanation:\n\"\"\nFor the above tree, the maximum GCD\nfor the sibilings is 6, formed for the\nnodes 6 and 12 for the children of node 3.\n
\n\n
Example 2:
\n\n
Input:\nN = 3\narr[] = {{1,2}, {1,4}} \nOutput :\n2\nExplanation:\n\"\"\nFor the above tree, the maximum GCD\nfor the sibilings is 2, formed for the\nnodes 2 and 4 for the children of node 1.\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function maxBinTreeGCD() which takes an integer N and a 2-d list denoting the edges as input and returns the maximum GCD of sibilings of the tree.

\n\n


\nExpected Time Complexity: O(E*logE), where E is the number of edges in the Tree.
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 ≤ N ≤ 105
\nThere might be edges with similar values

\n

\n
" }, { "path": "Maximum GCD of siblings of a binary tree - GFG/maximum-gcd-of-siblings-of-a-binary-tree.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n \n ArrayList> arr = new ArrayList<>();\n \n for(int i=0; i temp = new ArrayList<>();\n String S[] = read.readLine().split(\" \");\n temp.add(Integer.parseInt(S[0]));\n temp.add(Integer.parseInt(S[1]));\n arr.add(temp);\n }\n\n Solution ob = new Solution();\n System.out.println(ob.maxBinTreeGCD(arr,N));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution {\n static int getGCD(int a,int b){\n // Everything divides 0\n if (a == 0)\n return b;\n if (b == 0)\n return a;\n \n // base case\n if (a == b)\n return a;\n \n // a is greater\n if (a > b)\n return getGCD(a-b, b);\n return getGCD(a, b-a);\n }\n static int maxBinTreeGCD(ArrayList> arr, int N) {\n if(N==1)return 0;\n arr.sort((arr1,arr2)->arr1.get(0)-arr2.get(0));\n int ans=0;\n int i=1;\n while(i arr1=arr.get(i);\n ArrayList arr2=arr.get(i-1);\n if(arr1.get(0)!=arr2.get(0)) i++;\n else{\n ans=Math.max(ans,getGCD(arr1.get(1),arr2.get(1)));\n i+=2;\n }\n }\n return ans;\n }\n};" }, { "path": "Maximum Number of Words Found in Sentences.java", "content": "class Solution {\n public int mostWordsFound(String[] sentences) {\n int max=0;\n for(String s:sentences){\n int cur=1;\n for(int i=0;ileft && !root->right) return root->data;\n int l = maxSum(root->left,sum);\n int r = maxSum(root->right,sum);\n \n // cout<data<<\" \"<left && root->right) sum = max(l+r+root->data,sum);\n return max(l,r) + root->data;\n }\n int maxPathSum(Node* root)\n {\n int out = 0;\n Node* tmp = root;\n int Sum = INT_MIN;\n out = maxSum(root,Sum);\n if(root->left== NULL || root->right==NULL) Sum = max(Sum,out);\n return Sum;\n }\n};\n" }, { "path": "Maximum Path in Triangle.java", "content": "public class Solution {\n int[][]dp;\n public int solve(int[][] A) {\n int n=A.length;\n dp=new int[n][n];\n for(int i=0;i\n

Given a sequence of non-negative integers, find the subsequence of length 3 having maximum product, with the elements of the subsequence being in increasing order.

\n\n

 

\n\n

Example 1:

\n\n
​Input:\nn = 8\narr[ ] = {6, 7, 8, 1, 2, 3, 9, 10}\nOutput:\n8 9 10\nExplanation: 3 increasing elements of \nthe given arrays are 8,9 and 10 which \nforms the subsequence of size 3 with \nmaximum product.\n
\n\n


\n​Example 2:

\n\n
Input:\nn = 4\narr[ ] = {3, 4, 2, 1} \nOutput:\nNot Present
\n\n

 

\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function maxProductSubsequence() that takes an array arr, sizeOfArray n, and return the subsequence of size 3 having the maximum product, numbers of subsequence being in increasing order. If no such sequence exists, return \"-1\". The driver code takes care of the printing.

\n\n


\nExpected Time Complexity: O(N*LOG(N)).
\nExpected Auxiliary Space: O(N).

\n\n


\n
\nConstraints:
\n1 <= N <= 105
\n1 <= Arr[i] <= 105

\n

\n " }, { "path": "Maximum Product of Increasing Subsequence of Size 3 - GFG/maximum-product-of-increasing-subsequence-of-size-3.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n//Initial Template for Java\n\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t String line = br.readLine();\n\t\t String[] element = line.trim().split(\"\\\\s+\");\n\t\t int N = Integer.parseInt(element[0]);\n\t\t int arr [] = new int[N];\n\t\t line = br.readLine();\n\t\t String[] elements = line.trim().split(\"\\\\s+\");\n\t\t for(int i = 0;i ans;\n\t\t ans = obj.maxProductSubsequence(arr, N);\n \tif(ans.get(0) == -1)\n \t System.out.println(\"Not Present\");\n \telse{\n \t for(int i: ans)\n \t System.out.print(i + \" \");\n \t System.out.println();\n \t}\n \t\n\t\t}\n\t}\n}\n\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n \n \n public static ArrayList maxProductSubsequence (int arr[], int n) {\n long ans = 0; \n ArrayList list = new ArrayList<>();\n \n list.add(-1);\n \n TreeSet left = new TreeSet<>();\n left.add(arr[0]);\n \n int max[] = new int[n];\n max[n - 1] = arr[n - 1];\n for (int i = n - 2; i >= 0; i--) {\n max[i] = Math.max(arr[i], max[i + 1]);\n }\n \n for (int i = 1; i < n - 1; i++) {\n Integer l = left.floor(arr[i] - 1);\n int r = max[i + 1];\n \n if (l != null && r > arr[i] && ((long) arr[i]) * l * r > ans) {\n ans = ((long) arr[i]) * l * r;\n list.clear();\n list.add(l);\n list.add(arr[i]);\n list.add(r);\n }\n left.add(arr[i]);\n }\n \n return list;\n }\n}\n\n" }, { "path": "Maximum Split of Positive Even Integers.py", "content": "class Solution:\n def maximumEvenSplit(self, num: int) -> List[int]:\n if num&1==1:\n return []\n even=2\n a=[]\n while num>0:\n a.append(even)\n num-=even\n even+=2\n if -num in a:\n a.remove(-num)\n return a\n \n \n" }, { "path": "Maximum Twin Sum of a Linked List.java", "content": "class Solution {\n public int pairSum(ListNode head) {\n int length=1;\n ListNode temp=head;\n while(temp.next!=null){\n temp=temp.next;\n length++;\n }\n int dp[]=new int[length/2];\n temp=head;\n int index=0;\n while(temp!=null){\n if(index q=new LinkedList<>();\n root.val=0;\n q.add(root);\n return bfs(q);\n }\n \n public int bfs(Queue q){\n int maxWidth = 1;\n while(!q.isEmpty()){\n int sz=q.size();\n int left = q.peek().val;\n int right = left;\n for(int i=0;i set=new HashSet();\n int maxNum=0;\n for(int i:nums)\n maxNum=Math.max(maxNum,i);\n for(int i=31-Integer.numberOfLeadingZeros(maxNum);i>=0;i--){\n set.clear();\n int bit=1< children;\n Node() {\n this.children = new HashMap<>();\n }\n}\n\nclass Trie {\n Node root;\n \n Trie() {\n this.root = new Node();\n }\n \n public void insert(int[] A) {\n for(int num : A) {\n Node curr = this.root;\n for(int i=31;i>=0;i--) {\n int currBit = (num >> i) & 1;\n if(!curr.children.containsKey(currBit)) \n curr.children.put(currBit, new Node());\n curr = curr.children.get(currBit);\n }\n }\n }\n}\nclass Solution {\n public int findMaximumXOR(int[] nums) {\n Trie trie = new Trie();\n trie.insert(nums);\n \n int max = 0;\n\n for(int num : nums) {\n Node curr = trie.root;\n int currSum = 0;\n for(int i=31;i>=0;i--) {\n int requiredBit = 1-((num >> i) & 1); // if A[i] is 0, we need 1 and if A[i] is 1, we need 0. Thus, 1 - A[i]\n if(curr.children.containsKey(requiredBit)) {\n currSum |= (1<\n

Given an array Arr of size N and a positive integer K, find the sub-array of length K with the maximum average.

\n\n


\nExample 1:

\n\n
Input:\nK = 4, N = 6\nArr[] = {1, 12, -5, -6, 50, 3}\nOutput: 12 -5 -6 50\nExplanation: Maximum average is \n(12 - 5 - 6 + 50)/4 = 51/4.
\n\n


\nExample 2:

\n\n
Input:\nK = 3, N = 7\nArr[] = {3, -435, 335, 10, -50, 100, 20}\nOutput: 335 10 -50\nExplanation: Maximum average is \n(335 + 10 - 50)/3 = 295/3.\n
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function findMaxAverage() which takes the array of integers arr, its size n and integer k as input parameters and returns an integer denoting the starting index of the subarray.

\n\n


\nExpected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)
\n
\nConstraints
\n1 <= N <= 105
\n0 <= |Arr[i]| <= 103

\n

\n " }, { "path": "Maximum average subarray - GFG/maximum-average-subarray.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\npublic class GFG {\n public static void main(String[] args) throws Exception {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int tc = Integer.parseInt(br.readLine().trim());\n while (tc-- > 0) {\n String[] inputLine;\n inputLine = br.readLine().trim().split(\" \");\n int k = Integer.parseInt(inputLine[0]);\n inputLine = br.readLine().trim().split(\" \");\n int n = Integer.parseInt(inputLine[0]);\n int[] arr = new int[n];\n inputLine = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) {\n arr[i] = Integer.parseInt(inputLine[i]);\n }\n\n int ans = new Solution().findMaxAverage(arr, n, k);\n for(int i=ans; ians){\n index=i;\n ans=curr;\n }\n }\n return index;\n \n }\n}\n" }, { "path": "Maximum level sum.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n public int solve(TreeNode A) {\n int sum=A.val;\n Queue q=new LinkedList<>();\n q.add(A);\n while(!q.isEmpty()){\n int sz=q.size();\n int curr=0;\n for(int i=0;i\nusing namespace std;\n\n\n// } Driver Code Ends\n//User function Template for C++\n\nclass Solution\n{\n public:\n long long int numberOfSquares(long long int base)\n {\n //code here\n base/=2;\n\t return (base*(base-1))/2;\n }\n};\n\n//{ Driver Code Starts.\n\nint main()\n{\n\tint t;\n\tcin >> t;\n\n\twhile (t--)\n\t{\n\t\tlong long int base;\n\t\tcin >> base;\n\n Solution ob;\n\t\tcout << ob.numberOfSquares(base) << \"\\n\";\n\n\t}\n\n\treturn 0;\n}\n\n// } Driver Code Ends\n" }, { "path": "Maximum number of 2X2 squares.java", "content": "class Solution\n{\n public static long numberOfSquares(long n)\n {\n //code here\n if(n<=3)return 0;\n if(n%2==0){\n n-=2;\n }else{\n n-=3;\n }\n n/=2;\n return n*(n+1)/2;\n }\n}\n" }, { "path": "Maximum number of events that can be attended.java", "content": "class Solution {\n static int maxEvents(int[] start, int[] end, int N) {\n // code here\n int[][] arr = new int[N][2];\n \n for(int i=0; i Integer.compare(a[0], b[0]));\n PriorityQueue pq = new PriorityQueue();\n int i = 0, res = 0, d = 0;\n while (!pq.isEmpty() || i < N) {\n if (pq.isEmpty())\n d = arr[i][0];\n while (i < N && arr[i][0] <= d)\n pq.offer(arr[i++][1]);\n pq.poll();\n ++res; ++d;\n while (!pq.isEmpty() && pq.peek() < d)\n pq.poll();\n }\n return res;\n }\n};\n" }, { "path": "Maximum selections - GFG/README.md", "content": "# Maximum selections\n## Medium \n
\n

Note: This POTD is a part of Geek Summer Carnival. Solve all POTD consecutively from 5th to 10th April and get a chance to win exclusive discount vouchers on our GfG courses.

\n\n
\n

Geek wants to select the maximum number of course bundles at the Geek Summer Carnival. 

\n\n

You are given a finite number of courses and N range of numbers each depicting a bundle of courses. Select the maximum number of bundles such that no courses overlap in any of the bundle.

\n\n

Note: The ending of a range being the same as start of another isn't considered as an overlap.

\n\n


\nExample 1:

\n\n
Input:\nN = 4\nBundles = \n1 5\n2 3\n1 8\n3 5\n\nOutput:\n2\n\nExplanation: \n\"\"\nWe can select 2 bundles at max while \nstaying true to the condition. For this, \nwe can pick the ranges (2,3) and (3,5) \nwithout any overlap.
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 5\nBundles = \n7 9 \n2 8 \n1 3 \n10 11 \n10 16\n\nOutput:\n3\n\nExplanation: \n\"\"\nWe can pick the ranges (1,3), \n(7,9) and (10,11) without any overlap.
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Complete the function max_non_overlapping() that takes a 2D array representing N ranges as input parameter.  Return the maximum number of course bundles. 

\n\n


\nExpected time complexity: O(NlogN)
\nExpected space complexity: O(1)

\n\n


\nConstraints:
\n1 <= N <= 1000
\n0 <= range[i][j] <= 1000

\n

\n
" }, { "path": "Maximum selections - GFG/maximum-selections.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.util.*;\nimport java.lang.*; \n\nclass GFG{\n\tpublic static void main(String args[]) throws IOException { \n\t\t\n\t\tScanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n\n while(t > 0){\n \t\tint n = sc.nextInt();\n\t\t\t\n\t\t\tint arr[][] = new int[n][2];\n \n \tfor( int i=0 ; i{\n if(a[1]!=b[1]) return a[1]-b[1];\n else return b[0]-a[0];\n });\n int prevMax=Integer.MIN_VALUE;\n for(int a[]:ranges){\n if(a[0]>=prevMax){\n ans++;\n prevMax=a[1];\n }\n }\n return ans;\n }\n}" }, { "path": "Maximum sum Rectangle - GFG/README.md", "content": "# Maximum sum Rectangle\n## Medium \n
\n

Given a 2D matrix M of dimensions RxC. Find the maximum sum submatrix in it.

\n\n

Example 1:

\n\n
Input:\nR=4\nC=5\nM=[[1,2,-1,-4,-20],\n[-8,-3,4,2,1],\n[3,8,10,1,3],\n[-4,-1,1,7,-6]]\nOutput:\n29\nExplanation:\nThe matrix is as follows and the\nblue rectangle denotes the maximum sum\nrectangle.\n\"Thumbnail\"\n
\n\n

Example 2:

\n\n
Input:\nR=2\nC=2\nM=[[-1,-2],[-3,-4]]\nOutput:\n-1\nExplanation:\nTaking only the first cell is the \noptimal choice.
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function maximumSumRectangle() which takes the number R, C, and the 2D matrix M as input parameters and returns the maximum sum submatrix.

\n\n


\nExpected Time Complexity:O(R*R*C)
\nExpected Auxillary Space:O(R*C)
\n 

\n\n

Constraints:
\n1<=R,C<=500
\n-1000<=M[i][j]<=1000

\n

\n
" }, { "path": "Maximum sum Rectangle - GFG/maximum-sum-rectangle.java", "content": "// { Driver Code Starts\n// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N, M, x, y;\n String S[] = read.readLine().split(\" \");\n N = Integer.parseInt(S[0]);\n M = Integer.parseInt(S[1]);\n int a[][] = new int[N][M];\n for (int i = 0; i < N; i++) {\n String s[] = read.readLine().split(\" \");\n for (int j = 0; j < M; j++) a[i][j] = Integer.parseInt(s[j]);\n }\n Solution ob = new Solution();\n System.out.println(ob.maximumSumRectangle(N, M, a));\n }\n }\n}// } Driver Code Ends\n\n\n// User function Template for Java\n\nclass Solution {\n int kade(int[]sum){\n int max = Integer.MIN_VALUE;\n int cur=0;\n for(int i : sum){\n cur += i;\n if(cur > max){\n max = cur;\n }\n if(cur <0){\n cur = 0;\n }\n }\n return max;\n }\n \n int maximumSumRectangle(int r, int c, int mat[][]) {\n int max = Integer.MIN_VALUE;\n \n for(int i=0; i dp){\n if(root==null) return 0;\n if(canTake && dp.containsKey(path+'t')) return dp.get(path+'t');\n else if(!canTake && dp.containsKey(path+'f')) return dp.get(path+'f');\n if(canTake){\n int ans1 = root.data + solve(root.left,false,path+'l',dp) + solve(root.right,false, path+'r',dp);\n int ans2 = solve(root.left,true,path+'l',dp) + solve(root.right,true,path+'r',dp);\n int ans = Math.max(ans1,ans2);\n dp.put(path+'t',ans);\n return ans;\n }\n int ans = solve(root.left,true,path+'l',dp) + solve(root.right,true,path+'r',dp);\n dp.put(path+'f',ans);\n return ans;\n }\n \n //Function to return the maximum sum of non-adjacent nodes.\n static int getMaxSum(Node root){\n // add your code here\n Map dp = new HashMap<>();\n return Math.max(solve(root,true,\"\",dp),solve(root,false,\"\",dp));\n }\n}\n" }, { "path": "Maximum sum of increasing order elements from n arrays.java", "content": "class Complete{\n // Function for finding maximum and value pair\n public static int maximumSum (int n, int m, int arr[][]) {\n //Complete the function\n int sum=0;\n int lastMax=Integer.MAX_VALUE;\n for(int i=n-1;i>=0;i--){\n int[]a=arr[i];\n int val=limitMax(a,lastMax);\n if(val==0)return 0;\n sum+=val;\n lastMax=val;\n }\n return sum;\n }\n public static int limitMax(int[]a,int lastMax){\n Arrays.sort(a);\n for(int i=a.length-1;i>=0;i--){\n if(a[i]next){\n fast = fast->next->next;\n slow = slow->next;\n }\n // reverse half of linkedlist\n ListNode* nextNode, *prev = NULL;\n while(slow){\n nextNode = slow->next;\n slow->next = prev;\n prev = slow;\n slow = nextNode;\n } \n // get max sum of twins\n int ans = INT_MIN;\n while(prev){\n ans = max(ans, head->val + prev->val);\n head = head->next;\n prev = prev->next;\n }\n return ans;\n \n \n \n // //2. \n // stack st;\n // ListNode* temp = head;\n // while(head){\n // st.push(head);\n // head = head->next;\n // }\n // head = temp;\n // int n = st.size();\n // int ans = INT_MIN;\n // while(st.size() > n/2){\n // ans = max(ans, head->val + st.top()->val);\n // st.pop();\n // head = head->next;\n // }\n // return ans;\n }\n};\n" }, { "path": "Maximum-number-of-2X2-squares.cpp", "content": "class Solution\n{\n public:\n long long int numberOfSquares(long long int base)\n {\n long long int h=(base/2)-1;\n long long int ans=h*(h+1)/2;\n return ans;\n }\n};\n" }, { "path": "Merge Intervals", "content": "class Solution {\n public int[][] merge(int[][] intervals) {\n Arrays.sort(intervals,(a,b) ->Integer.compare(a[0],b[0]));\n LinkedList ans = new LinkedList<>();\n\n for(int[] tem:intervals){\n if(ans.isEmpty() || ans.getLast()[1]=tem[0])\n ans.getLast()[1] = Math.max(ans.getLast()[1],tem[1]);\n }\n return ans.toArray(new int[ans.size()][]);\n }\n}\n" }, { "path": "Merge K sorted linked lists.java", "content": "class Solution\n{\n Node mergeKList(Node[]arr,int K){\n PriorityQueue pq = new PriorityQueue<>((a,b) -> a.data - b.data);\n for(int i = 0 ; i < arr.length ; ++i){\n if(arr[i] != null){\n pq.add(arr[i]);\n }\n }\n Node head = null , curr = null ; \n while(!pq.isEmpty()){\n Node temp = pq.poll();\n if(head == null){\n head = curr = temp;\n }\n else{\n curr.next = temp;\n curr = curr.next;\n }\n if(temp.next != null){\n pq.add(temp.next);\n }\n }\n return head;\n }\n}\n" }, { "path": "Merge Nodes in Between Zeros.java", "content": "class Solution {\n public ListNode mergeNodes(ListNode head) {\n ListNode temp=head.next;\n ListNode start=head;\n ListNode end=new ListNode(-1);\n while(start.next!=null){\n int sum=0;\n while(temp.val!=0){\n sum+=temp.val;\n temp=temp.next;\n }\n end=temp;\n ListNode newNode=new ListNode(sum);\n start.next=newNode;\n newNode.next=end;\n start=end;\n temp=temp.next;\n }\n \n temp=head.next;\n while(temp!=null){\n temp.next=temp.next.next;\n temp=temp.next;\n }\n return head.next;\n }\n}\n" }, { "path": "Merge Overlapping Intervals.java", "content": "/**\n * Definition for an interval.\n * public class Interval {\n * int start;\n * int end;\n * Interval() { start = 0; end = 0; }\n * Interval(int s, int e) { start = s; end = e; }\n * }\n */\npublic class Solution {\n public ArrayList merge(ArrayList arr) {\n ArrayList ans=new ArrayList<>();\n Collections.sort(arr,(a,b)->a.start-b.start);\n ans.add(arr.get(0));\n int idx=0;\n for(int i=1;i=arr.get(i).start){\n ans.get(idx).end= Math.max(ans.get(idx).end,arr.get(i).end);\n }\n }\n return ans;\n }\n}\n" }, { "path": "Merge Two Sorted Array.py", "content": "class Solution:\n def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:\n \"\"\"\n Do not return anything, modify nums1 in-place instead.\n \"\"\" \n \n # Replace the n 0's of \"nums1\" with all n elements of \"nums2\"\n j = 0\n for i in range(m, m+n):\n nums1[i] = nums2[j] \n j+=1\n \n # Sort the list \"nums1\" in ASCENDING order\n for i in range(len(nums1)):\n for j in range(i+1, len(nums1)):\n if nums1[i] > nums1[j]:\n nums1[i], nums1[j] = nums1[j], nums1[i]\n" }, { "path": "Merge Two Sorted Lists", "content": "public class Solution {\n public ListNode mergeTwoLists(ListNode A, ListNode B) {\n ListNode head=new ListNode(-1);\n ListNode my=head;\n while(A!=null && B!=null){\n if(B.val=0 && r pq=new PriorityQueue<>();\n for(ListNode head:lists){\n ListNode temp=head;\n while(temp!=null){\n pq.offer(temp.val);\n temp=temp.next;\n }\n }\n ListNode ans=new ListNode(-1);\n ListNode temp=ans;\n while(!pq.isEmpty()){\n temp.next=new ListNode(pq.poll());\n temp=temp.next;\n }\n return ans.next;\n }\n}\n\n" }, { "path": "Merge new Interval.java", "content": "class Solution:\n def insert(self, intervals, newInterval):\n if len(intervals) == 0:\n return [newInterval]\n result = []\n result.append(newInterval)\n for i in range(0,len(intervals)):\n a = result.pop()\n b = intervals[i]\n if a.start > b.end:\n result.append(b)\n result.append(a)\n elif a.end < b.start:\n result.append(a)\n result.append(b)\n else:\n start = min(a.start, b.start)\n end = max(a.end, b.end)\n result.append(Interval(start, end))\n \n return result\n" }, { "path": "Merge two Binary Tree.java", "content": "public class Solution {\n public TreeNode solve(TreeNode A, TreeNode B) {\n if(A==null && B==null)return null;\n if(A==null){\n return B;\n }\n if(B==null){\n return A;\n }\n TreeNode node=new TreeNode(A.val+B.val);\n TreeNode lefty=solve(A.left,B.left);\n TreeNode righty=solve(A.right,B.right);\n node.left=lefty;\n node.right=righty;\n return node;\n }\n}\n" }, { "path": "Merge two binary Max heaps", "content": "class Solution{\n public int[] mergeHeaps(int[] a, int[] b, int n, int m) {\n // your code here\n int ans[]=new int[a.length+b.length];\n Arrays.sort(a);\n Arrays.sort(b);\n int i=a.length-1,j=b.length-1,index=0;\n while(i>=0 && j>=0){\n if(a[i]>b[j]){\n ans[index]=a[i];\n i--;\n index++;\n }else{\n ans[index]=b[j];\n j--;\n index++;\n }\n }\n if(i>=0){\n while(i>=0){\n ans[index]=a[i];\n index++;\n i--;\n }\n }\n if(j>=0){\n while(j>=0){\n ans[index]=b[j];\n j--;\n index++;\n }\n }\n return ans;\n \n }\n}\n" }, { "path": "Merge two sorted linked lists - GFG/README.md", "content": "# Merge two sorted linked lists\n## Medium \n
\n

Given two sorted linked lists consisting of N and M nodes respectively. The task is to merge both of the list (in-place) and return head of the merged list.
\n 

\n\n

Example 1:

\n\n
Input:\nN = 4, M = 3 \nvalueN[] = {5,10,15,40}\nvalueM[] = {2,3,20}\nOutput: 2 3 5 10 15 20 40\nExplanation: After merging the two linked\nlists, we have merged list as 2, 3, 5,\n10, 15, 20, 40.\n
\n\n

Example 2:

\n\n
Input:\nN = 2, M = 2\nvalueN[] = {1,1}\nvalueM[] = {2,4}\nOutput:1 1 2 4\nExplanation: After merging the given two\nlinked list , we have 1, 1, 2, 4 as\noutput.
\n\n

Your Task:
\nThe task is to complete the function sortedMerge() which takes references to the heads of two linked lists as the arguments and returns the head of merged linked list.

\n\n

Expected Time Complexity : O(n+m)
\nExpected Auxilliary Space : O(1)

\n\n

Constraints:
\n1 <= N, M <= 104
\n1 <= Node's data <= 105

\n

\n
" }, { "path": "Merge two sorted linked lists - GFG/merge-two-sorted-linked-lists.java", "content": "// { Driver Code Starts\nimport java.util.*;\n\nclass Node\n{\n int data;\n Node next;\n Node(int d) {\n data = d; \n next = null;\n }\n}\n\n\nclass MergeLists\n{\n Node head;\n\n\n\n /* Function to print linked list */\n public static void printList(Node head)\n {\n \n while (head!= null)\n {\n System.out.print(head.data+\" \");\n head = head.next;\n } \n System.out.println();\n }\n\t\n\t \n \n /* Driver program to test above functions */\n public static void main(String args[])\n {\n \n \n /* Constructed Linked List is 1->2->3->4->5->6->\n 7->8->8->9->null */\n Scanner sc = new Scanner(System.in);\n\t\t int t=sc.nextInt();\n\t\t \n\t\t while(t>0)\n {\n\t\t\tint n1 = sc.nextInt();\n\t\t\tint n2 = sc.nextInt();\n\t\t\tNode head1 = new Node(sc.nextInt());\n Node tail1 = head1;\n for(int i=0; ihead2.data){\n ans.next=head2;\n ans=ans.next;\n sortedMerge(head1, head2.next);\n }else{\n ans.next=head1;\n ans=ans.next;\n sortedMerge(head1.next, head2);\n }\n return node.next;\n } \n}" }, { "path": "Merging Details - GFG/Merging Details.cpp", "content": "class Solution {\r\n public:\r\n vector> mergeDetails(vector>& details) {\r\n vector>vv;\r\n for(int i=0;is;\r\n vectorv;\r\n for(int j=1;j> mergeDetails(vector>& details) {\n vector>vv;\n for(int i=0;is;\n vectorv;\n for(int j=1;j> mergeDetails(List> details) {\n // Your code here\n List> ans=new ArrayList<>();\n for(int i=0;i detail=details.get(i);\n if(detail.size()==0)continue;\n Set set=new TreeSet<>();\n String name=detail.get(0);\n for(int j=1;j curr=details.get(j);\n if(curr.size()==0)continue;\n for(int k=1;k merged=new ArrayList<>();\n merged.add(name);\n for(String s:set){\n merged.add(s);\n }\n ans.add(merged);\n }\n return ans;\n }\n}\n" }, { "path": "Min Coin - GFG/README.md", "content": "# Min Coin\n## Medium \n
\n

Given a list of coins of distinct denominations and total amount of money. Find the minimum number of coins required to make up that amount. Output -1 if that money cannot be made up using given coins.
\nYou may assume that there are infinite numbers of coins of each type.
\n 

\n\n

Example 1:

\n\n
Input: arr = [1, 2, 5], amount = 11\nOutput: 3\nExplanation: 2*5 + 1 = 11. So taking 2 \ndenominations of 5 and 1 denomination of  \n1, one can make 11.\n
\n\n

Example 2:

\n\n
Input: arr = [2, 6], amount = 7\nOutput: -1\nExplanation: Not possible to make 7 using \ndenominations 2 and 6.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function MinCoin() which takes list of denominations and amount as input parameter and returns miimum number of coins to make up amount. If not possible returns -1.
\n 

\n\n

Expected Time Complexity: O(n*amount)
\nExpected Space Complexity: O(amount)
\n 

\n\n

Contstraints:
\n1 <= number of distinct denominations <= 100
\n1 <= amount <= 104

\n

\n
" }, { "path": "Min Coin - GFG/min-coin.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String S = br.readLine().trim();\n String[] S1 = S.split(\" \");\n int n = Integer.parseInt(S1[0]);\n int amount = Integer.parseInt(S1[1]);\n String s = br.readLine().trim();\n String[] s1 = s.split(\" \");\n int[] nums = new int[n];\n for(int i = 0; i < s1.length; i++)\n nums[i] = Integer.parseInt(s1[i]);\n Solution ob = new Solution();\n int ans = ob.MinCoin(nums, amount);\n System.out.println(ans); \n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n public int MinCoin(int[] nums, int amount){\n \n int n = nums.length;\n \n int dp[] = new int[amount+1];\n \n for(int i=1; i<=amount; i++){\n dp[i] = 100000;\n for(int j=0; j=nums[j] && dp[i-nums[j]]!=-1){\n dp[i] = Math.min(dp[i], dp[i-nums[j]] + 1);\n }\n }\n if(dp[i]>=100000)dp[i]=-1;\n }\n return dp[amount];\n }\n}" }, { "path": "Min Depth of Binary Tree.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n public int minDepth(TreeNode A) {\n if(A==null)return Integer.MAX_VALUE;\n int x=Math.min(minDepth(A.left),minDepth(A.right));\n if(x==Integer.MAX_VALUE)return 1;\n return 1+x;\n }\n}\n" }, { "path": "Min Jumps Array.java", "content": "public class Solution {\n public int jump(int[] a) {\n if(a.length<=1) return 0;\n int farthest=0,current=0,jumps=0;\n for(int i=0;icurrent) return -1;\n }\n return jumps;\n }\n}\n" }, { "path": "Min Stack.java", "content": "class Solution {\n Stack st=new Stack();\n Stack mst=new Stack();\n public void push(int x) {\n if (st.empty() && mst.empty()){\n st.push(x);\n mst.push(x);\n }else{\n st.push(x);\n if(x> list) {\n int sz=list.size();\n if(sz==1)\n return list.get(0).get(0);\n int dp[]=new int[sz+1];\n for(int row=sz-1;row>=0;row--){\n int len=list.get(row).size();\n for(int col=0;col\n

Given an array of digits (values are from 0 to 9), find the minimum possible sum of two numbers formed from digits of the array. All digits of given array must be used to form the two numbers.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 6\narr[] = {6, 8, 4, 5, 2, 3}\nOutput:\n604\nExplanation:\nThe minimum sum is formed by numbers \n358 and 246
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 5\narr[] = {5, 3, 0, 7, 4}\nOutput:\n82\nExplanation:\nThe minimum sum is formed by numbers \n35 and 047\n
\n\n


\n
\nYour Task:
\nYou don't have to print anything, printing is done by the driver code itself. Your task is to complete the function minSum() which takes the array A[] and its size N as inputs and returns the required sum.
\n 

\n\n


\nExpected Time Complexity: O(N. log(N))
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 ≤ N ≤ 35
\n0 ≤ A[] ≤ 9

\n

\n " }, { "path": "Min sum formed by digits - GFG/min-sum-formed-by-digits.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nclass GFG {\n\tpublic static void main(String[] args) throws IOException\n\t{\n\t BufferedReader br =\n new BufferedReader(new InputStreamReader(System.in));\n int t =\n Integer.parseInt(br.readLine().trim()); // Inputting the testcases\n while(t-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n int a[] = new int[(int)(n)];\n String inputLine[] = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) {\n a[i] = Integer.parseInt(inputLine[i]);\n }\n \n Solution obj = new Solution();\n System.out.println(obj.minSum(a, n));\n \n }\n\t}\n}\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\n\n//2 3 4 5 6 \n//246\n//35\n\nclass Solution {\n \n public static long minSum(int arr[], int n)\n {\n // Your code goes here\n Arrays.sort(arr);\n long a=0;\n long b=0;\n int i=0;\n while(i maxHeap = new PriorityQueue<>((o1,o2)->o2-o1);\n int min = Integer.MAX_VALUE;\n int diff=min;\n for(int i=0;i99)\n {\n min--;\n sec+=60;\n }\n while(min>=0&&sec<=99)\n {\n tar=min*100+sec;\n char arr[]=(\"\"+tar).toCharArray();\n int mul=0;\n for(int i=0;i X, vector Y, int M, int N){\n //Write your code here\n \n int ans = 0;\n \n sort(X.begin(), X.end(), greater());\n sort(Y.begin(), Y.end(), greater());\n \n int i=0, j=0;\n \n while(i= Y[j])\n ans += (j+1)*X[i++];\n else\n ans += (i+1)*Y[j++];\n }\n \n while(i=0 || j>=0){\n int a=i>=0?X[i]:-1;\n int b=j>=0?Y[j]:-1;\n if(a>=b){\n ans+=(a*row);\n col++;\n i--;\n }else{\n ans+=(b*col);\n row++;\n j--;\n }\n }\n return ans;\n }\n}\n \n" }, { "path": "Minimum Cost to cut a board into squares.py", "content": "from typing import List\nclass Solution:\n def minimumCostOfBreaking(self, X, Y, M, N):\n X.sort()\n Y.sort()\n xCut = 1\n yCut = 1\n currPrice = 0\n i = len(X)-1\n j = len(Y)-1\n while i>=0 and j>=0:\n if X[i] > Y[j]:\n currPrice += X[i]*xCut\n yCut +=1\n i-=1\n elif X[i] < Y[j]:\n currPrice += Y[j]*yCut\n xCut +=1\n j -= 1\n elif X[i] == Y[j]:\n if xCut > yCut:\n currPrice += X[i]*xCut\n yCut +=1\n i-=1\n else:\n currPrice += Y[j]*yCut\n xCut +=1\n j-=1\n \n while i>=0:\n currPrice += X[i]*xCut\n yCut +=1\n i-=1\n while j>=0:\n currPrice += Y[j]*yCut\n xCut +=1\n j-=1\n \n return currPrice\n" }, { "path": "Minimum Exchange GFG/MinimumExchange.cpp", "content": "class Solution {\npublic:\nint MinimumExchange(vector>matrix){\n // Code here\n int ans1=0;\n int ans2=0;\n for(int i=0;i>matrix){\n// // Code here\n// int m = matrix.size(), n = matrix[0].size();\n// int cnt = 0;\n \n// for(int i=0; i\nusing namespace std;\n\nclass Solution {\npublic:\nint MinimumExchange(vector>matrix){\n // Code here\n int m = matrix.size(), n = matrix[0].size();\n int case1=0, case2 = 0;\n for(int i =0; i> tc;\n\twhile(tc--){\n\t\tint n, m;\n\t\tcin >> n >> m;\n\t\tvector>matrix(n, vector(m,'x'));\n\t\tfor(int i = 0; i < n; i++){\n\t\t\tfor(int j = 0; j < m; j++)\n\t\t\t\tcin >> matrix[i][j];\n\t\t}\n\t\tSolution obj;\n\t\tint ans = obj.MinimumExchange(matrix);\n\t\tcout << ans <<\"\\n\";\n\t}\n\treturn 0;\n}" }, { "path": "Minimum Exchange.java", "content": "class Solution\n{\n public int MinimumExchange(char[][] matrix) {\n int a = 0, b = 0;\n int m = matrix.length, n = matrix[0].length;\n for(int i = 0; i < m; ++i){\n for(int j = 0; j < n; ++j){\n if(matrix[i][j] == 'A'){\n a++;\n } else {\n b++;\n }\n }\n }\n if(a > b){\n return Count('A', 'B', matrix);\n } else if(a < b){\n return Count('B', 'A', matrix) ;\n } else {\n return Math.min(Count('A', 'B', matrix), Count('B', 'A', matrix));\n }\n }\n\n private int Count(char x, char y, char[][] matrix) {\n int m = matrix.length, n = matrix[0].length;\n int cnt = 0;\n for(int i = 0; i < m; ++i){\n char ch = x;\n if(i % 2 == 1){\n ch = y;\n }\n for(int j = 0; j < n; ++j){\n if(matrix[i][j] != ch){\n cnt++;\n }\n if(ch == x){\n ch = y;\n } else {\n ch = x;\n }\n }\n }\n return cnt / 2;\n }\n}\n" }, { "path": "Minimum Lights to Activate.java", "content": "public class Solution {\n public int solve(int[] a, int b) {\n int n=a.length;\n int i=0,curr=-1;\n int cnt=0;\n while(i\n

Given an array of distinct elements which was initially sorted. This array is rotated at some unknown point. The task is to find the minimum element in the given sorted and rotated array. 

\n\n

Example 1:

\n\n
Input:\nN = 10\narr[] = {2,3,4,5,6,7,8,9,10,1}\nOutput: 1\nExplanation: The array is rotated \nonce anti-clockwise. So minium \nelement is at last index (n-1) \nwhich is 1.
\n\n

Example 2:

\n\n
Input:\nN = 5\narr[] = {3,4,5,1,2}\nOutput: 1\nExplanation: The array is rotated \nand the minimum element present is\nat index (n-2) which is 1.\n
\n\n

Your Task:
\nThe task is to complete the function minNumber() which takes the array arr[] and its starting and ending indices (low and high) as inputs and returns the minimum element in the given sorted and rotated array.

\n\n

Expected Time Complexity: O(LogN).
\nExpected Auxiliary Space: O(LogN).

\n\n

Constraints:
\n1 <= N <= 107
\n1 <= arr[i] <= 107

\n

\n " }, { "path": "Minimum Number in a sorted rotated array - GFG/minimum-number-in-a-sorted-rotated-array.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass Array\n{\n public static void main(String args[])throws IOException\n {\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n \n while(t-- > 0)\n {\n int n = Integer.parseInt(read.readLine());\n String st[] = read.readLine().trim().split(\"\\\\s+\");\n \n int arr[] = new int[n];\n \n for(int i = 0; i < n; i++)\n arr[i] = Integer.parseInt(st[i]);\n \n System.out.println(new Solution().minNumber(arr,0,n-1));\n }\n }\n \n}// } Driver Code Ends\n\n\n\n\nclass Solution\n{\n //Function to find the minimum element in sorted and rotated array.\n static int minNumber(int arr[], int l, int h){\n while(l<=h){\n int m=(l+h)/2;\n if(m==0 || arr[m-1]>arr[m])\n return arr[m];\n if(arr[m]arr[h])\n l=m+1;\n }\n return -1;\n }\n}" }, { "path": "Minimum Number in a sorted rotated array - GFG/minimum-number-in-a-sorted-rotated-array.py", "content": "#User function Template for python3\n\n\nclass Solution:\n \n #Function to find the minimum element in sorted and rotated array.\n def minNumber(self, arr,low,high):\n return min(arr)\n\n#{ \n# Driver Code Starts\n#Initial Template for Python 3\n\nimport math\n\n\ndef main():\n T=int(input())\n while(T>0):\n \n N=int(input())\n\n A=[int(x) for x in input().strip().split()]\n obj = Solution()\n print(obj.minNumber(A,0,N-1))\n \n T-=1\n\n\nif __name__ == \"__main__\":\n main()\n# } Driver Code Ends" }, { "path": "Minimum Number of Arrows to Burst Balloons(Non Overlapping intervals)", "content": "class Solution {\n public int findMinArrowShots(int[][] points) {\n \n // This Problem is similar to Non Overlapping Interval Problem of Greedy Approach\n // Link for detiled discussion : http://www.leetcode-solution.com/2019/06/01/0452-minimum-number-of-arrows-to-burst-balloons.html\n \n // Base case\n if(points.length == 0)\n return 0;\n \n // Sort the point accroding to their end points i.e., a[1] - b[1]\n Arrays.sort(points, (a,b) -> a[1] - b[1]);\n \n // Position arrow at end (Extreme Right) as it has maximum chance of hittng there\n int arrPos = points[0][1];\n int count = 1; // Minimun 1 arrow is required to shoot any points\n \n for(int i = 1; i < points.length; i++ ) // start with 1 as 0th index end will be check for start of 1st \n {\n int left = points[i][0];\n int right = points[i][1];\n \n \n //check whether the arrowFired can burst other balloons.\n //if not fire arrow at the next point end value\n if (!(arrPos >= left && arrPos <= right)) \n {\n \n count++; // increase the arrowsFired by 1.\n arrPos = points[i][1]; // next point end value.\n \n }\n /* if(arrPos >= points[i][0]) // Since Current arrow position than start pos of array that means we can \n { // continue, but as soon as it not true we break as our current arrow pos\n continue; // cant handle beyond that point . so update its pos and count++\n }\n count++ ; // As we are done with current pos \n arrPos = points[i][1]; // Update as we already exhausted our option with previous position\n */\n \n }\n \n return count;\n }\n}\n" }, { "path": "Minimum Number of Vertices to Reach All Nodes.java", "content": "class Solution {\n public List findSmallestSetOfVertices(int n, List> edges) {\n List> adj=new ArrayList<>();\n List ansList=new ArrayList<>();\n \n for(int i=0;i l=new ArrayList<>();\n adj.add(l);\n }\n \n for(int i=0;i oddMap = new HashMap<>();\n Map evenMap = new HashMap<>();\n for(int i=0; i odd = new PriorityQueue<>((a, b) -> b.freq - a.freq);\n Queue even = new PriorityQueue<>((a, b) -> b.freq - a.freq);\n for(Map.Entry entry : oddMap.entrySet()){\n odd.offer(new Node(entry.getKey(), entry.getValue()));\n }\n for(Map.Entry entry : evenMap.entrySet()){\n even.offer(new Node(entry.getKey(), entry.getValue()));\n }\n \n while(!odd.isEmpty() && !even.isEmpty() && odd.peek().val == even.peek().val){\n if(odd.peek().freq < even.peek().freq){\n odd.poll();\n }else{\n even.poll();\n }\n }\n \n int n = nums.length;\n if(n % 2 == 0){\n return (odd.isEmpty() ? n / 2 : n / 2 - odd.poll().freq) + (even.isEmpty() ? n / 2 : n / 2 - even.poll().freq);\n }else{\n return (odd.isEmpty() ? n / 2 + 1 : n / 2 + 1 - odd.poll().freq) + (even.isEmpty() ? n / 2 : n / 2 - even.poll().freq);\n }\n }\n \n class Node {\n int freq;\n int val;\n public Node(int val, int freq){\n this.freq = freq;\n this.val = val;\n }\n public String toString(){\n return val + \": \" + freq;\n }\n }\n}\n" }, { "path": "Minimum Parantheses!.java", "content": "public class Solution {\n public int solve(String A) {\n int ans=0;\n Deque st=new ArrayDeque<>();\n for(int i=0;i0){\n st.pop();\n }else{\n ans++;\n }\n }\n }\n ans+=st.size();\n return ans;\n }\n}\n" }, { "path": "Minimum Platforms.java", "content": "class Solution\n{\n //Function to find the minimum number of platforms required at the\n //railway station such that no train waits.\n static int findPlatform(int arr[], int dep[], int n)\n {\n // add your code here\n Arrays.sort(arr);\n Arrays.sort(dep);\n int plat=1;\n int max=1;\n int i=1;\n int j=0;\n while(i st;\n int i = 0;\n // we are removing open bracket if extra and marking them with # and finally not including the character # in the ans string\n while(i < n){\n if(s[i] == '(') st.push(i);\n else if(s[i] == ')'){\n if(st.empty()){\n s[i] = '#';\n }else{\n st.pop(); // removing the relavent open bracket for closing bracket and finally we will be left with extra open brackets and we will mark them as #\n }\n }\n i++;\n }\n // here we are marking extra open brackets as #\n while(!st.empty()){\n s[st.top()] = '#';\n st.pop();\n }\n i = 0;\n while(i stack=new ArrayDeque<>();\n int[]dp=new int[s.length()];\n for(int i=0;i\nusing namespace std;\n\nclass Solution{\npublic:\n long long findMinSum(vector &A,vector &B,int N){\n long long res =0;\n sort(A.begin(), A.end());\n sort(B.begin(), B.end());\n for(int i =0; i\nusing namespace std;\n\n// } Driver Code Ends\n//User function Template for C++\n\nclass Solution {\npublic:\n int minimumSwaps(int c[],int v[],int n,int k,int b,int T)\n {\n // code here\n int good_sheep = 0; //to count how many sheeps can reach target\n int bad_sheep = 0; //to count how many sheeps can NOT reach target\n int swap = 0; //no. of sweeps\n \n for(int i=n-1;i>=0;i--){\n //check if it is able to reach destination\n \n if(v[i]*T + c[i] >= b){\n \n good_sheep++;\n \n //now check no of bad sheep infront of it and swap it with that\n swap+=bad_sheep;\n }\n else{\n bad_sheep++;\n }\n \n //check whether atleast k sheep reach the barn\n //if YES then break\n \n if(good_sheep>=k) break;\n }\n if(good_sheep>=k)\n return swap;\n \n return -1;\n }\n};\n\n//{ Driver Code Starts.\nint main(){\n int t=1,testcases=1;\n cin>>t;\n while(t>=testcases)\n {\n int n,k,b,T;\n cin>>n>>k>>b>>T;\n int c[n];\n int v[n];\n for(auto &j:c)\n cin>>j;\n for(auto &j:v)\n cin>>j;\n Solution s;\n int ans=s.minimumSwaps(c,v,n,k,b,T);\n cout<& nums) \n {\n int n = nums.size();\n int k = 0 , ans = n;\n for(int i = 0;i map=new HashMap<>();\n for(int i=0;i=0;i--){\n int pos=c[i]+(v[i]*t);\n if(pos>=b){\n k--;\n totalSwaps+=slow;\n if(k==0)return totalSwaps;\n }else{\n slow++;\n }\n }\n \n return -1;\n }\n}\n" }, { "path": "Minimum Time To Fulfill All Orders Using BinarySearch And ApSeries Formula.java", "content": "class Solution {\n public static int findMinTime(int n, int l, int[] arr) {\n int start=1;\n int end=Integer.MAX_VALUE;\n int ans=0;\n while(start<=end) {\n int mid=start +(end-start)/2;\n if(isAnswer(arr, mid, n)) {\n ans=mid;\n end=mid-1;\n }\n else {\n start=mid+1;\n }\n }\n return ans;\n }\n \n public static boolean isAnswer(int arr[], int mid, int n) {\n int curAns=0;\n for(int i=0;iarr[i], Sn->mid found n using binary search\n if(curAns>=n) return true;\n }\n // System.out.println(curAns+\" \"+n+\" \"+mid);\n return curAns>=n;\n }\n \n public static int getNumber(int a, int sum) {\n int start=1;\n int end=sum;\n int n=0;\n if(sum=sum) {\n n=(int)mid;\n end=(int)mid-1;\n }\n else {\n start=(int)mid+1;\n }\n }\n if(n*(2*a+(n-1)*a)/2==sum) \n return n;\n else \n return n-1>=0?n-1:0;\n \n }\n}\n" }, { "path": "Minimum Time to Remove All Cars Containing Illegal Goods.java", "content": "class Solution {\n public int minimumTime(String s) {\n int n = s.length();\n int min = s.length();\n int[] nums = new int[n];\n for (int i = 0; i < n; i++)\n nums[i] = s.charAt(i) - '0';\n\n\t\t// step1\n int[] leftOptimized = new int[n + 2];\n for (int i = 1; i <= n; i++) {\n leftOptimized[i] = Math.min(i, leftOptimized[i - 1] + (nums[i - 1] == 1? 2: 0));\n }\n\n\t\t// step2\n int[] rightOptimized = new int[n + 2];\n for (int i = n; i > 0; i--) {\n rightOptimized[i] = Math.min(n - i + 1, rightOptimized[i + 1] + (nums[i - 1] == 1? 2: 0));\n }\n\n\t\t// step3\n for (int p = 0; p <= n; p++) {\n min = Math.min(min, leftOptimized[p] + rightOptimized[p + 1]);\n }\n\n return min;\n }\n}\n" }, { "path": "Minimum X (xor) A - GFG/README.md", "content": "# Minimum X (xor) A\n## Hard \n
\n

Given two integers A and B, the task is to find an integer X such that (X XOR A) is minimum possible and the count of set bit in X is equal to the count of set bits in B.

\n\n

Example 1:

\n\n
Input: \nA = 3, B = 5\nOutput: 3\nExplanation:\nBinary(A) = Binary(3) = 011\nBinary(B) = Binary(5) = 101\nThe XOR will be minimum when x = 3\ni.e. (3 XOR 3) = 0 and the number\nof set bits in 3 is equal\nto the number of set bits in 5.
\n\n

Example 2:

\n\n
Input: \nA = 7, B = 12\nOutput: 6\nExplanation:\n(7)2= 111\n(12)2= 1100\nThe XOR will be minimum when x = 6 \ni.e. (6 XOR 7) = 1 and the number \nof set bits in 6 is equal to the \nnumber of set bits in 12.
\n\n
Your task :
\n\n
You don't need to read input or print anything. Your task is to complete the function minVal() that takes integer A and B as input and returns the value of X according to the question.
\n\n
 
\n\n
Expected Time Complexity : O(log N)
\n\n
Expected Auxiliary Space : O(1)
\n\n
 
\n\n
Constraints :
\n\n
1 <= A, B <= 109
\n\n
 
\n

\n
" }, { "path": "Minimum X (xor) A - GFG/minimum-x-xor-a.java", "content": "// { Driver Code Starts\n// Initial Template for Java\n\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass GFG {\n public static void main(String[] args) throws IOException {\n BufferedReader br =\n new BufferedReader(new InputStreamReader(System.in));\n int t =\n Integer.parseInt(br.readLine().trim()); // Inputting the testcases\n while (t-- > 0) {\n\n int a = Integer.parseInt(br.readLine().trim());\n int b = Integer.parseInt(br.readLine().trim());\n\n Solution ob = new Solution();\n System.out.println(ob.minVal(a, b));\n }\n }\n}// } Driver Code Ends\n\n\n// User function Template for Java\n//1001\n//1011\n//bitsA=2\n//bitsB=3\n\n//1101\n//1001\n//0100\n\n\n\nclass Solution {\n public static int minVal(int a, int b) {\n int bitsA=Integer.bitCount(a);\n int bitsB=Integer.bitCount(b);\n int diff=Math.abs(bitsA-bitsB);\n \n if(diff==0)return a;\n else if(bitsA>bitsB){\n while(diff>0){\n a = a&(a-1);\n diff--;\n }\n }else{\n while(diff>0){\n a = a|(a+1);\n diff--;\n }\n }\n return a;\n }\n}" }, { "path": "Minimum increment/decrement to make array non-Increasing - GFG/README.md", "content": "# Minimum increment/decrement to make array non-Increasing\n## Medium \n
\n

Note: This POTD is a part of Geek Summer Carnival. Solve all POTD consecutively from 5th to 10th April and get a chance to win exclusive discount vouchers on our GfG courses.

\n\n
\n

Given an array a of length n, find the minimum number of operations required to make it non-increasing. You can select any one of the following operations and preform it any number of times on an array element.

\n\n
    \n\t
  • increment the array element by 1.
    • \n\t
  • decrement the array element by 1. 
    • \n
\n\n

Example 1:

\n\n
Input:\nN = 4 \narray = {3, 1, 2, 1}\nOutput: 1\nExplanation: \nDecrement array[2] by 1. \nNew array becomes {3,1,1,1} which is non-increasing. \nTherefore, only 1 step is required.
\n\n


\nExample 2:

\n\n
Input:\nN = 4 \narray = {3, 1, 5, 1}\nOutput: 4
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Complete the function minOperations() that takes n and array a as input parameters and returns the minimum number of operations required. 

\n\n

Expected time complexity: O(nlogn)
\nExpected space complexity: O(n)

\n\n


\nConstraints:
\n1 <= n <= 10^4
\n1 <= a[i] <= 10^4

\n

\n
" }, { "path": "Minimum increment/decrement to make array non-Increasing - GFG/minimum-incrementdecrement-to-make-array-non-increasing.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nimport java.util.PriorityQueue; \n\n // } Driver Code Ends\n//User function Template for Java\n\nclass Solution \n{ \n\tpublic static int minOperations(int a[], int n){ \n\t int ans=0;\n\t PriorityQueue pq = new PriorityQueue<>();\n\t for(int i=0;i 0) {\n\t int n;\n\t n = sc.nextInt();\n\t int[] a = new int[n];\n\t for (int i = 0; i < n; i++) \n\t \ta[i] = sc.nextInt();\n\t Solution ob = new Solution();\n\t System.out.println(ob.minOperations(a,n));\n\t t--;\n\t }\n\t}\n}\n\n // } Driver Code Ends" }, { "path": "Minimum sum of absolute difference of pairs.cpp", "content": "\n#include \nusing namespace std;\n\n\n// } Driver Code Ends\n//User function Template for C++\n\nclass Solution{\npublic:\n long long findMinSum(vector &A,vector &B,int N){\n \n \n \n sort(A.begin(),A.end());\n sort(B.begin(),B.end());\n \n long long res = 0;\n \n for(int i=0;i>t;\n while(t--){\n int N;\n cin>>N;\n vector A(N),B(N);\n for(int i=0;i>A[i];\n }\n for(int i=0;i>B[i];\n }\n Solution ob;\n cout<= time) return true;\n return false;\n }\n}\n" }, { "path": "Minimum time to fulfil all orders gfg hard.cpp", "content": "#include\nusing namespace std;\nclass Solution{\n public:\n int getDonuts(int rank, int time){\n int i =1, currSum =1, numDonuts =0;\n while((rank*currSum) <= time){\n numDonuts++; i++;\n currSum+=i;\n }\n return numDonuts;\n }\n bool isPossible(vector&A, int time, int donuts){\n int currSum =0;\n for(int i=0;i=donuts;\n }\n int findMinTime(int N, vector&A, int L){\n //write your code here\n int start =0, maxi =0;\n for(int i =0; i=n;\n }\n}\n \n" }, { "path": "Minimum time to fulfill all orders.java", "content": "class Solution {\n public static int donutCount(int min,int rank[])\n {\n int dCount = 0;\n for(int i = 0;i < rank.length;i++)\n {\n int chefRank = rank[i];\n if(chefRank > min) continue;\n int curDount = 1;\n int curTime = chefRank;\n \n while(curTime <= min)\n {\n dCount++;\n curDount++;\n curTime += curDount*chefRank;\n }\n }\n return dCount;\n }\n public static int findMinTime(int n, int arrLength, int[] arr) {\n int l = 1, h = 10000000;\n while(l <= h)\n {\n int mid = (l+h)/2;\n int midRes = donutCount(mid,arr);\n if(n <= midRes) h = mid-1;\n else l = mid+1;\n }\n return l;\n }\n}\n" }, { "path": "Minimum times A has to be repeated such that B is a substring of it - GFG/README.md", "content": "# Minimum times A has to be repeated such that B is a substring of it\n## Medium \n
\n

Given two strings A and B. Find minimum number of times A has to be repeated such that B is a Substring of it. If B can never be a substring then return -1.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nA = \"abcd\"\nB = \"cdabcdab\"\nOutput:\n3\nExplanation:\nRepeating A three times (“abcdabcdabcd”),\nB is a substring of it. B is not a substring\nof A when it is repeated less than 3 times.\n
\n\n
Example 2:
\n\n
Input:\nA = \"ab\"\nB = \"cab\"\nOutput :\n-1\nExplanation:\nNo matter how many times we repeat A, we can't\nget a string such that B is a substring of it.\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function minRepeats() which takes 2 strings A, and B respectively and returns the minimum number of times A has to be repeated such that B is a substring of it. Return -1 if it's not possible.

\n\n


\nExpected Time Complexity: O(|A| * |B|)
\nExpected Auxiliary Space: O(|B|)

\n\n

\nConstraints:
\n1 ≤ |A|, |B| ≤ 103
\n\n
String A and B consists of lower case alphabets
\n

\n
" }, { "path": "Minimum times A has to be repeated such that B is a substring of it - GFG/minimum-times-a-has-to-be-repeated-such-that-b-is-a-substring-of-it.py", "content": "#User function Template for python3\n\nclass Solution:\n def minRepeats(self, A, B):\n parent=str(A)\n ans=1\n while(len(parent)= 0; i--){\n if(v[i]*T+c[i] >= b){ //Distance = speed*time so a sheep can reach to barn if its postion*time+cost is greater than equal to barn position\n g++; // If yes then we will not swap that sheep\n s += bad; \n }else\n bad++; // If not than that sheep can exploit other sheeps also which have higher\n //cost and are on left side of bad sheep so we increase count of bad sheeps\n if(g >= k) break; // number of good sheeps is equal to k we will break and return no. of swap required\n }\n if(g >= k) return s;\n return -1; // else return -1;\n }\n};\n" }, { "path": "Minimum_Cost_to_cut_a_board_into_squares_gfg_greedy.cpp", "content": "#include\nusing namespace std;\nclass Solution {\npublic:\n int minimumCostOfBreaking(vector X, vector Y, int M, int N){\n //Write your code here\n sort(X.begin(), X.end(), greater());\n sort(Y.begin(), Y.end(), greater());\n \n int i =0,j =0, cost =0, hor=1, ver =1;\n while(i

You are given the head of a Linked List. You have to move the last element to the front of the Linked List and return the list.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 5\nList = {2,5,6,2,1}\nOutput:\n{1,2,5,6,2}\nExplanation:\nIn the given linked list, the last element is 1,\nafter moving the last element to the front the\nlinked list will be {1,2,5,6,2}.
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 1\nList = {2}\nOutput:\n{2}\nExplanation:\nHere 2 is the only element so, the linked list\nwill remain the same.
\n\n

 

\n\n

Your Task:

\n\n

You don't need to read input or print anything. Your task is to complete the function moveToFront() which takes the address of the head of the linked list and returns the modified linked list.

\n\n

 

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n1 <= N <= 105
\n0 <= Elements of List <= 109
\nSum of N over all test cases doesn't exceeds 106

\n" }, { "path": "Move Last Element to Front of a Linked List - GFG/move-last-element-to-front-of-a-linked-list.java", "content": "//{ Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\n\nclass Node\n{\n int data;\n Node next;\n \n Node(int x)\n {\n data = x;\n next = null;\n }\n \n public static Node inputList(BufferedReader br) throws IOException\n {\n int n = Integer.parseInt(br.readLine().trim()); // Length of Linked List\n \n String[] s = br.readLine().trim().split(\" \");\n Node head = new Node(Integer.parseInt(s[0])), tail = head;\n for(int i = 1; i < s.length; i++)\n tail = tail.next = new Node(Integer.parseInt(s[i]));\n \n return head;\n }\n \n public static void printList(Node node)\n {\n while (true)\n { \n \t\tSystem.out.print(node.data);\n \t\tnode = node.next; \n \t\tif(node == null)\n \t\t break;\n \t\tSystem.out.print(\" \");\n \t} \n \tSystem.out.println();\n }\n}\n\nclass GFG {\n public static void main(String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t;\n t = Integer.parseInt(br.readLine());\n while(t-- > 0){\n \n Node head = Node.inputList(br);\n \n Solution obj = new Solution();\n Node res = obj.moveToFront(head);\n \n Node.printList(res);\n \n }\n }\n}\n\n// } Driver Code Ends\n\n\n/*\n\nDefinition for singly Link List Node\nclass Node\n{\n int data;\n Node next;\n \n Node(int x){\n data = x;\n next = null;\n }\n}\n\nYou can also use the following for printing the link list.\nNode.printList(Node node);\n*/\n\nclass Solution {\n public static Node moveToFront(Node head) {\n // code here\n if(head.next==null)return head;\n Node temp=head;\n while(temp.next.next!=null){\n temp=temp.next;\n }\n Node last=temp.next;\n temp.next=null;\n last.next=head;\n return last;\n }\n}\n \n" }, { "path": "Move Zeroes.java", "content": "public class Solution {\n public int[] solve(int[] A) {\n int cnt=0;\n for(int i:A){\n if(i==0)cnt++;\n }\n int pos=0;\n int i=0;\n while(i0){\n A[i--]=0;\n }\n return A;\n }\n}\n" }, { "path": "Move all zeroes to end of the array.java", "content": "public class Solution {\n public ArrayList solve(ArrayList A) {\n ArrayList ans=new ArrayList<>();\n for(int i:A){\n if(i!=0){\n ans.add(i);\n }\n }\n int diff=A.size()-ans.size();\n while(diff!=0){\n ans.add(0);\n diff--;\n }\n return ans;\n }\n}\n" }, { "path": "Move all zeros to the front of the linked list - GFG/README.md", "content": "# Move all zeros to the front of the linked list\n## Easy \n
\n

Given a linked list, the task is to move all 0s to the front of the linked list. The order of all another element except 0 should be same after rearrangement.

\n\n

Example 1:

\n\n
Input:  0 -> 4 -> 0 -> 5 -> 0\nOutput: 0 -> 0 -> 0 -> 4 -> 5\nExplanation: After moving all 0s of the given\nlist to the front, the list is:\n0 -> 0 -> 0 -> 4 -> 5
\n\n

Example 2:

\n\n
Input: 0 -> 1 -> 0 -> 1 -> 2\nOutput: 0 -> 0 -> 1 -> 1 -> 2
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function moveZeroes() which takes head node of the linked list as input parameter.

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)

\n\n

Constraints:
\n1 <= N <= 50
\n
\n 

\n

\n
" }, { "path": "Move all zeros to the front of the linked list - GFG/move-all-zeros-to-the-front-of-the-linked-list.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nclass Node{\n int data;\n Node next;\n Node(int d){\n data=d;\n next=null;\n }\n}\nclass Zeroes{\n public static void main(String[] args){\n Scanner sc=new Scanner(System.in);\n int t=sc.nextInt();\n while(t-->0){\n int n=sc.nextInt();\n Node head=null;\n while(n-->0){\n int a=sc.nextInt();\n if(head==null){\n head=new Node(a);\n }\n else{\n Node temp=new Node(a);\n temp.next=head;\n head=temp;\n }\n }\n GfG g=new GfG();\n head = g.moveZeroes(head);\n while(head!=null){\n System.out.print(head.data+\" \");\n head=head.next;\n }\n System.out.println();\n }\n }\n}\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\n/*\nclass Node{\n int data;\n Node next;\n Node(int d){\n data=d;\n next=null;\n }\n}\n*/\n\nclass GfG{\n public Node moveZeroes(Node head){\n Node temp=head;\n while(temp.next!=null){\n if(temp.next.data==0){\n Node zero=temp.next;\n temp.next=temp.next.next;\n zero.next=head;\n head=zero;\n }else{\n temp=temp.next;\n }\n }\n return head;\n }\n}" }, { "path": "Moving on grid - GFG/README.md", "content": "# Moving on grid\n## Easy \n
\n

Given a grid with dimensions r x c, the two players (say JON and ARYA ) can move the coin over the grid satisfying the following rules:

\n\n
    \n\t
  • There is a coin on (1,1) cell initially.
    • \n\t
  • JON will move first.
    • \n\t
  • Both will play on alternate moves.
    • \n\t
  • In each move they can place coin on following positions if current position of coin is x,y
    \n\t(x+1,y), (x+2,y), (x+3,y), (x,y+1), (x,y+2), (x,y+3), (x,y+4), (x,y+5), (x,y+6)
    • \n\t
  • They can't go outside the grid.
    • \n\t
  • Player who cannot make any move will lose this game.
    • \n\t
  • Both play optimally.
    • \n
\n\n


\nExample 1:

\n\n
Input: r = 1, c = 2\nOutput: JON \nExplanation: ARYA lost the game because\nhe won't able to move after JON's move.  \n
\n\n


\nExample 2:

\n\n
Input: r = 2, c = 2\nOutput: ARYA\nExplanation: After first move by JON(1,2 or 2,1)\nand second move by ARYA(2,2) JON won't able to\nmove so ARYA wins.   \n
\n\n


\nYour Task:  
\nYou dont need to read input or print anything. Complete the function movOnGrid() which takes r and c as input parameter and returns the name of the winner ( either JON or ARYA).
\n
\nExpected Time Complexity: O(1)
\nExpected Auxiliary Space: O(1)
\n
\nConstraints:
\n1 <= r, c <=105

\n

\n
" }, { "path": "Moving on grid - GFG/moving-on-grid.java", "content": "// { Driver Code Starts\n//Initial Template for Java\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String[] input = new String[2]; \n input = br.readLine().split(\" \"); \n int r = Integer.parseInt(input[0]); \n int c = Integer.parseInt(input[1]); \n Solution ob = new Solution();\n System.out.println(ob.movOnGrid(r,c));\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution\n{\n public String movOnGrid(int r, int c){\n r=(r-1)%7;\n c=(c-1)%4;\n return(r==c?\"ARYA\":\"JON\");\n }\n}" }, { "path": "Multiple left rotations of the array.java", "content": "public class Solution {\n Map map=new HashMap<>();\n public int[][] solve(int[] A, int[] B) {\n int[][]ans=new int[B.length][A.length];\n for(int i=0;i increasingNumbers(int n){\n // code here\n ArrayList list=new ArrayList();\n if(n==1){\n for(int i=0;i<10;i++){\n list.add(i); \n }\n \n return list;\n }else if(n==9){\n list.add(123456789);\n return list;\n }else if(n==8){\n list.add(12345678);\n list.add(12345679);\n list.add(12345689);\n list.add(12345789);\n list.add(12346789);\n list.add(12356789);\n list.add(12456789);\n list.add(13456789);\n list.add(23456789);\n return list;\n }else{\n int start=(int)Math.pow(10,n-1);\n int end=(int)Math.pow(10,n);\n while(start a) {\n int n = a.size();\n HashMap h = new HashMap();\n for(int i = 0; i < n; i++){\n int x = a.get(i), times = 0;\n if(h.containsKey(x)){\n times = h.get(x);\n h.put(x, times + 1);\n times++;\n \n }else{\n h.put(x, 1);\n times = 1;\n }\n if(times > n / 3){\n return x;\n }\n }\n return -1;\n }\n}\n\n" }, { "path": "N-th_Tribonacci_Number_leetcode1137.cpp", "content": "class Solution {\npublic:\n int tribonacci(int n) {\n if (n < 2) return n;\n int a = 0, b = 1, c = 1, d = a + b + c;\n while (n-- > 2) {\n d = a + b + c, a = b, b = c, c = d;\n }\n return c;\n }\n};\n" }, { "path": "Nearest Smaller Element.java", "content": "public class Solution {\n public int[] prevSmaller(int[] A) {\n int n=A.length;\n int[]ans=new int[n];\n for(int i=0;i=0){\n if(a[i] prevSmaller(ArrayList A) {\n ArrayList result=new ArrayList<>();\n result.add(-1);\n Stack stack=new Stack<>();\n stack.push(A.get(0));\n for(int i=1;i=A.get(i))\n stack.pop();\n result.add(stack.isEmpty()?-1:stack.peek());\n stack.add(A.get(i));\n }\n return result;\n}\n}\n" }, { "path": "Nearly sorted - GFG/README.md", "content": "# Nearly sorted\n## Medium \n
\n

Given an array of n elements, where each element is at most k away from its target position, you need to sort the array optimally.

\n\n

Example 1:

\n\n
Input:\nn = 7, k = 3\narr[] = {6,5,3,2,8,10,9}\nOutput: 2 3 5 6 8 9 10\nExplanation: The sorted array will be\n2 3 5 6 8 9 10\n
\n\n

Example 2:

\n\n
Input:\nn = 5, k = 2\narr[] = {3,1,4,2,5}\nOutput: 1 2 3 4 5 \n
\n\n

Note: DO NOT use STL sort() function for this question.

\n\n

Your Task:
\nYou are required to complete the method nearlySorted() which takes 3 arguments and returns the sorted array.

\n\n

Expected Time Complexity : O(nlogk)
\nExpected Auxilliary Space : O(n)

\n\n

Constraints:
\n1 ≤ n ≤ 106
\n1 ≤ k < n
\n1 ≤ arri ≤ 107

\n

\n
" }, { "path": "Nearly sorted - GFG/nearly-sorted.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass gfg\n{\n public static void main(String args[])\n {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n int num = sc.nextInt();\n int k = sc.nextInt();\n \n int arr[] = new int[num];\n for(int i = 0; i < num; i++)\n arr[i] = sc.nextInt();\n \n ArrayList res = new Solution().nearlySorted(arr, num, k);\n for (int i = 0; i < res.size (); i++)\n System.out.print (res.get (i) + \" \");\n System.out.println();\n }\n }\n}\n\n// } Driver Code Ends\n\n\nclass Solution\n{\n //Function to return the sorted array.\n ArrayList nearlySorted(int arr[], int num, int k)\n {\n ArrayList ans=new ArrayList<>();\n PriorityQueue pq=new PriorityQueue<>();\n int i=0;\n while(i<=k){\n pq.add(arr[i]);\n i++;\n }\n while(!pq.isEmpty()){\n int ele=pq.remove();\n ans.add(ele);\n if(i\n

Given a weighted directed graph with n nodes and m edges. Nodes are labeled from 0 to n-1, the task is to check if it contains a negative weight cycle or not.
\nNote: edges[i] is defined as u, v and weight.
\n 

\n\n

Example 1:

\n\n
Input: n = 3, edges = {{0,1,-1},{1,2,-2},\n{2,0,-3}}\nOutput: 1\nExplanation: The graph contains negative weight\ncycle as 0->1->2->0 with weight -1,-2,-3.\n
\n\n

Example 2:

\n\n
Input: n = 3, edges = {{0,1,-1},{1,2,-2},\n{2,0,3}}\nOutput: 0\nExplanation: The graph does not contain any\nnegative weight cycle.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anyhting. Your task is to complete the function isNegativeWeightCycle() which takes n and edges as input paramater and returns 1 if graph contains negative weight cycle otherwise returns 0.
\n 

\n\n

Expected Time Complexity: O(n*m)
\nExpected Space Compelxity: O(n)
\n 

\n\n

Constraints:
\n1 <= n <= 100
\n1 <= m <= n*(n-1), where m is the total number of Edges in the directed graph.

\n

\n " }, { "path": "Negative weight cycle - GFG/negative-weight-cycle.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String[] S1 = br.readLine().trim().split(\" \");\n int n = Integer.parseInt(S1[0]);\n int m = Integer.parseInt(S1[1]);\n int[][] edges = new int[m][3];\n for(int i = 0; i < m; i++){\n String S2[] = br.readLine().trim().split(\" \");\n for(int j = 0; j < 3; j++)\n edges[i][j] = Integer.parseInt(S2[j]);\n }\n Solution obj = new Solution();\n int ans = obj.isNegativeWeightCycle(n, edges);\n System.out.println(ans);\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n public int isNegativeWeightCycle(int n, int[][] edges){\n if (edges == null || n == 0) {\n return 0;\n }\n int [] distance = new int [n];\n Arrays.fill(distance, Integer.MAX_VALUE);\n distance[0] = 0;\n // n - 1 number of relaxation steps\n for (int i = 1; i <= n - 1; i++) {\n for (int [] edge : edges) {\n int source = edge[0];\n int destination = edge[1];\n int weight = edge[2];\n // condition\n if (distance[source] != Integer.MAX_VALUE) {\n distance[destination] =Math.min(distance[destination], distance[source] + weight);\n }\n }\n }\n // relaxation step once more to make sure about the negative cycle\n for (int [] edge : edges) {\n int source = edge[0];\n int destination = edge[1];\n int weight = edge[2];\n if (distance[source] != Integer.MAX_VALUE && distance[source] + \n weight < distance[destination]) {\n // there is a negative cycle as distance will get updated\n return 1;\n }\n }\n return 0;\n }\n}" }, { "path": "Next Permutation", "content": "class Solution{\n static List nextPermutation(int N, int a[]){\n // code here\n int k=-1;\n for(int i=0;i list=new ArrayList<>();\n for(int i=N-1;i>=0;i--){\n list.add(a[i]);\n }\n return list;\n }\n int l=k+1;\n for(int i=k+1;ia[k]){\n l=i;\n }\n }\n int temp=a[k];\n a[k]=a[l];\n a[l]=temp;\n List list=new ArrayList<>();\n for(int i=0;i<=k;i++){\n list.add(a[i]);\n }\n for(int i=N-1;i>k;i--){\n list.add(a[i]);\n }\n return list;\n \n }\n}\n\n//=============================================================\npublic class Solution {\n public ArrayList nextPermutation(ArrayList a) {\n // code here\n int k=-1;\n int N=a.size();\n for(int i=0;i list=new ArrayList<>();\n for(int i=N-1;i>=0;i--){\n list.add(a.get(i));\n }\n return list;\n }\n \n int l=k+1;\n \n for(int i=k+1;ia.get(k)){\n l=i;\n }\n }\n \n int temp=a.get(k);\n a.set(k,a.get(l));\n a.set(l,temp);\n ArrayList list=new ArrayList<>();\n for(int i=0;i<=k;i++){\n list.add(a.get(i));\n }\n for(int i=N-1;i>k;i--){\n list.add(a.get(i));\n }\n return list;\n }\n}\n" }, { "path": "Next Pointer Binary Tree.java", "content": "public class Solution {\n public void connect(TreeLinkNode root) {\n TreeLinkNode prev=null;\n Queue q=new LinkedList<>();\n q.add(root);\n while(q.size()>0){\n int sz=q.size();\n prev=null;\n for(int i=0;idata) return new Node(-1);\n queue q;\n q.push(root);\n while(!q.empty()){\n int n = q.size();\n vector v;\n for(int i=0;ileft) q.push(node->left);\n if(node->right) q.push(node->right);\n v.push_back(node);\n q.pop();\n }\n for(int i=0;idata == key) return v[i+1];\n }\n if(v[v.size()-1]->data == key) return new Node(-1);\n }\n return new Node(-1);\n }\n};\n\n// Another approach\n\n// class Solution\n// {\n// public:\n// Node *nextRight(Node *root, int key)\n// {\n// //code here\n// queue Q;\n// Q.push(root);\n \n// while(!Q.empty())\n// {\n// int sz = Q.size();\n \n// while(sz--)\n// {\n// Node* cur = Q.front();\n// Q.pop();\n \n// if(cur->data == key)\n// {\n// if(sz == 0)\n// return new Node(-1);\n// else\n// return Q.front();\n// }\n \n// if(cur->left)\n// Q.push(cur->left);\n \n// if(cur->right)\n// Q.push(cur->right);\n// }\n// }\n \n// return new Node(-1);\n// }\n// };\n" }, { "path": "Next Right Node.java", "content": "class Solution{\n\tNode nextRight(Node root, int key)\n {\n\t\t//Write your code here\n\t\tQueue q=new LinkedList<>();\n\t\tq.add(root);\n\t\tboolean found=false;\n\t\twhile(q.size()>0){\n\t\t int sz=q.size();\n\t\t //level\n\t\t while(sz-->0){\n\t\t Node node=q.remove();\n\t\t if(found)return node;\n\t\t if(node.data==key)found=true;\n\t\t if(node.left!=null)q.add(node.left);\n\t\t if(node.right!=null)q.add(node.right);\n\t\t }\n\t\t if(found)return new Node(-1);\n\t\t}\n\t\treturn null;\n }\n}\n\n" }, { "path": "Next element with greater frequency - GFG/README.md", "content": "# Next element with greater frequency\n## Medium \n
\n

Given an array arr[ ] of n integers, for every element, find the closest element on it's right that has a greater frequency than its own frequency.

\n\n
\n

Frequency is the number of times the element appears in the array.

\n
\n\n

 

\n\n

Example 1:

\n\n
Input:\nn = 6\narr[] = {2 1 1 3 2 1}\nOutput:\n1 -1 -1 2 1 -1 \nExplanation:\n1 appears 3 times.\n2 appears 2 times.\n3 appears 1 time. \n\nFor arr[0] ie, 2\narr[1] ie 1 is the closest element on its \nright which has greater frequency than the \nfrequency of 2. For the arr[1] and arr[2] no element \non the right has greater frequency than 1, \nso -1 will be printed. and so on.
\n\n

Example 2:

\n\n
Input:\nn = 10\narr[] = {5 1 2 3 2 5 5 4 5 2}\nOutput:\n-1 2 5 2 5 -1 -1 5 -1 -1
\n\n

 

\n\n

Your task:
\nYour task is to complete the function print_next_greater_freq() which take two parameters arr and n.This function returns answer(as a list of integers) as explained above.

\n\n


\nExpected time complexity: O(n)
\nExpected space complexity: O(n)

\n\n


\nConstraints:
\n1 <= n <= 104
\n1 <= arr[i] <= 104

\n

\n
" }, { "path": "Next element with greater frequency - GFG/next-element-with-greater-frequency.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.io.*;\n\nclass GFG\n{\n public static void main (String[] args)\n {\n Scanner sc = new Scanner(System.in);\n // int arr[] = new int[10000];\n \n int t = sc.nextInt();\n \n while(t-->0)\n {\n int n = sc.nextInt();\n int arr[]=new int[n];\n for(int i=0; ifreq[arr[i]]){\n ans[i]=arr[j];\n got=true;\n break;\n }\n }\n if(!got){\n ans[i]=-1;\n }\n }\n return ans;\n }\n}\n\n" }, { "path": "Noble Integer.java", "content": "public class Solution {\n public int solve(ArrayList A) {\n Collections.sort(A);\n for(int i=1;i& e) {\n int n = e.size();\n vector v(n);\n for(int i =0;isum){\n sum = v[i];\n index = i;\n }\n }\n return index;\n }\n};\n" }, { "path": "Nodes at even distance - GFG/README.md", "content": "# Nodes at even distance\n## Medium \n
\n

Given a connected acyclic graph with n nodes and n-1 edges, count the pair of nodes that are at even distance(number of edges) from each other.

\n\n


\nExample 1:

\n\n
Input:\nn = 3\ngraph = {{}, {2}, {1, 3}, {2}}\nOutput: 1\nExplaination: Here there are three pairs {1,2},{1,3}\nand {2,3} and only {1,3} has even distance between them.\ni.e           1\n             /\n            2\n           /\n          3
\n\n


\nExample 2:

\n\n
Input:\nn = 5\ngraph = {{}, {2,4}, {1,3}, {2}, {1,5}, {4}}\nOutput: 4\nExplaination: There are four pairs {1,3},{1,5},{2,4}\nand {3,5} which has even distance.\n
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function countOfNodes() which takes the array graph[] (given as Adjacency list) and its size n as input parameters and returns the count of pair of nodes that are at even distance from each other

\n\n


\nExpected Time Complexity: O(V+E)
\nExpected Auxiliary Space: O(V)

\n\n


\nConstraints:
\n1 ≤ n ≤ 104

\n

\n
" }, { "path": "Nodes at even distance - GFG/nodes-at-even-distance.java", "content": "// { Driver Code Starts\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass GFG{\n\tpublic static void main(String [] args) throws IOException{\n\t\tScanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while(t-- > 0)\n {\n int n = sc.nextInt();\n ArrayList> graph = new ArrayList<>();\n\n for(int i = 0; i <= n; i++) {\n \tgraph.add(new ArrayList<>());\n }\n \n int temp = n;\n while(temp-- > 1){\n int u = sc.nextInt();\n int v = sc.nextInt();\n graph.get(u).add(v);\n graph.get(v).add(u);\n }\n Solution ob = new Solution();\n System.out.println(ob.countOfNodes(graph, n));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n int countOfNodes(ArrayList> graph, int n) \n {\n // Write your code here\n Integer[] arr=new Integer[n+1];\n dfs(1,graph,arr,0);\n int ev=0,od=0;\n for(Integer i:arr)\n {\n if(i!=null)\n if(i%2==0)\n ev++;\n else\n od++;\n }\n return ev*(ev-1)/2+od*(od-1)/2;\n }\n static void dfs(int src,ArrayList> adj,Integer[] arr,int di)\n {\n arr[src]=di;\n for(int i:adj.get(src))\n if(arr[i]==null)\n dfs(i,adj,arr,di+1);\n }\n}\n\n" }, { "path": "Nth item through sum - GFG/README.md", "content": "# Nth item through sum\n## Easy \n
\n

Given two sorted arrays A and B of length L1 and L2, we can get a set of sums(add one element from the first and one from second). Find the Nth element in the set considered in sorted order.
\nNote: Set of sums should have unique elements.

\n\n

Example 1:

\n\n
Input: L1 = 2, L2 = 2\nA = {1, 2}\nB = {3, 4}\nN = 3\nOutput: 6\nExplaination: The set of sums are in \nthe order 4, 5, 6.
\n\n

Example 2:

\n\n
Input: L1 = 5, L2 = 4\nA = {1, 3, 4, 8, 10}\nB = {20, 22, 30, 40}\nN = 4\nOutput: 25\nExplaination: The numbers before it \nare 21, 23 and 24.
\n\n

Your Task:
\nYou do not need to read input or print anything. Your task is to complete the function nthItem() which takes L1, L2, A, B, and the value N as input parameters and returns the Nth value of the set. If N is greater than the size of the set then it returns -1.

\n\n

Expected Time Complexity: O((L1*L2)*log(L1*L2))
\nExpected Auxiliary Space: O(L1*L2)

\n\n

Constraints:
\n1 ≤ L1, L2 ≤ 500
\n1 ≤ A[i], B[i] ≤ 10000
\n1 ≤ N ≤ L1*L2

\n

\n
" }, { "path": "Nth item through sum - GFG/nth-item-through-sum.py", "content": "#User function Template for python3\n\nclass Solution:\n def nthItem(self, L1, L2, A, B, N):\n s = sorted({i+j for j in B for i in A})\n if N > len(s) : return -1 \n else : return s[N-1]\n\n#{ \n# Driver Code Starts\n#Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n L1, L2 = [int(x) for x in input().split()]\n A = input().split()\n for itr in range(L1):\n A[itr] = int(A[itr])\n B = input().split()\n for it in range(L2):\n B[it] = int(B[it])\n N = int(input())\n \n ob = Solution()\n print(ob.nthItem(L1, L2, A, B, N))\n# } Driver Code Ends" }, { "path": "Number Formation - GFG/README.md", "content": "# Number Formation\n## Hard\n

Given three integers x, y, and z, the task is to find the sum of all the numbers formed by 
\nhaving 4 at most x times, having 5 at most y times, and having 6 at most z times as a digit.

\n\n

Note: Output the sum modulo 109+7.

\n\n

Example 1:

\n\n
Input: X = 1, Y = 1, Z = 1 \nOutput: 3675\nExplanation: 4 + 5 + 6 + 45 + 54 + 56 \n+ 65 + 46 + 64 + 456 + 465 \n+ 546 + 564 + 645 + 654 = 3675
\n\n
Example 2:
\n\n
Input: X = 0, Y = 0, Z = 0\nOutput: 0\nExplanation: No number can be formed
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Complete the function getSum() which takes X, Y and Z as input parameters and returns the integer value
\n
\nExpected Time Complexity: O(X*Y*Z)
\nExpected Auxiliary Space: O(X*Y*Z)
\n
\nConstraints:
\n0 ≤ X, Y, Z ≤ 60

\n
" }, { "path": "Number Formation - GFG/number-formation.java", "content": "//{ Driver Code Starts\n// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nclass GfG {\n public static void main(String args[]) {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while (t-- > 0) {\n int x = sc.nextInt();\n int y = sc.nextInt();\n int z = sc.nextInt();\n\n Solution ob = new Solution();\n System.out.println(ob.getSum(x, y, z));\n }\n }\n}\n// } Driver Code Ends\n\n\n// User Function template for JAVA\n\nclass Solution {\n\n public int getSum(int X, int Y, int Z) {\n // Your code goes here\n int mod=1000000007;\n long[][][] exactSum=new long[X+1][Y+1][Z+1];\n long[][][] num=new long[X+1][Y+1][Z+1];\n num[0][0][0]=1L;\n \n long ans=0L;\n for(int i=0;i<=X;i++){\n for(int j=0;j<=Y;j++){\n for(int k=0;k<=Z;k++){\n if(i>0){\n exactSum[i][j][k]+=(exactSum[i-1][j][k]*10 +4*num[i-1][j][k])%mod;\n num[i][j][k]+=num[i-1][j][k]%mod;\n }\n if(j>0){\n exactSum[i][j][k]+=(exactSum[i][j-1][k]*10 +5*num[i][j-1][k])%mod;\n num[i][j][k]+=num[i][j-1][k]%mod;\n }\n if(k>0){\n exactSum[i][j][k]+=(exactSum[i][j][k-1]*10 +6*num[i][j][k-1])%mod;\n num[i][j][k]+=num[i][j][k-1]%mod;\n }\n ans+=exactSum[i][j][k]%mod;\n ans%=mod;\n }\n }\n }\n return (int)ans;\n }\n}" }, { "path": "Number of 1 Bits.java", "content": "public class Solution {\n\tpublic int numSetBits(long a) {\n int ans=0;\n while(a!=0){\n ans+=(a&1);\n a=a>>1;\n }\n return ans;\n\t}\n}\n" }, { "path": "Number of Provinces.java", "content": "class Solution {\n static int numProvinces(ArrayList> adj, int V) {\n // code here\n boolean[]vis=new boolean[V];\n int count=0;\n for(int i=0;i> adj,int curr,int V){\n vis[curr]=true;\n \n for(int i=0;iB)return 0;\n ans++;\n ans+=(B-num)/7;\n return ans;\n }\n}\n" }, { "path": "Number of Ways to Arrive at Destination gfg med sep16.cpp", "content": "#include \nusing namespace std;\n\nclass Solution {\n public:\n int countPaths(int n, vector>& roads) {\n // code here\n vector>> adj(n);\n for(auto road : roads){\n int u = road[0], v = road[1], t = road[2];\n adj[u].push_back({v, t});\n adj[v].push_back({u, t});\n }\n priority_queue, vector>, greater>> pq;\n pq.push({0, 0});\n vector dist(n, 1e18);\n dist[0] = 0;\n long long ans = 0, mod = 1000000007;\n while(!pq.empty()){\n long long node = pq.top().second, d = pq.top().first; \n pq.pop();\n if(node == n - 1 && d == dist[n - 1]){\n ans = (ans + 1) % mod;\n continue;\n } \n for(auto child : adj[node]){\n if(d + child.second <= dist[child.first]){\n dist[child.first] = d + child.second;\n pq.push({dist[child.first], child.first});\n } \n } \n }\n return ans;\n }\n};\nint main() {\n int T;\n cin >> T;\n while (T--) {\n int n, m;\n cin >> n >> m;\n int u, v;\n\n vector> adj;\n\n for (int i = 0; i < m; ++i) {\n vector temp;\n for (int j = 0; j < 3; ++j) {\n int x;\n cin >> x;\n temp.push_back(x);\n }\n adj.push_back(temp);\n }\n\n Solution obj;\n cout << obj.countPaths(n, adj) << \"\\n\";\n }\n\n return 0;\n}" }, { "path": "Number of Ways to Arrive at Destination.cpp", "content": "class Solution {\n public:\n int countPaths(int n, vector>& roads) {\n \n long long mod = 1e9+7;\n long long ans = 0;\n vector>> adj(n);\n vector dist(n,INT_MAX);\npriority_queue,vector>,greater>> pq;\n for(int i=0;i wtwithadj) {\n dist[u] = wtwithadj;\n ans = 0;\n }\n if(dist[u] == wtwithadj) ans =(ans+1)%mod;\n continue;\n }\n if(dist[u] >= wtwithadj) {\n dist[u] = wtwithadj;\n pq.push({dist[u], u});\n }\n }\n }\n return ans;\n }\n};\n\n" }, { "path": "Number of Ways to Arrive at Destination.java", "content": "class Solution {\n static int minTime;\n static int noOfRoads;\n static int countPaths(int n, List> roads) {\n // Your code here\n minTime=Integer.MAX_VALUE;\n noOfRoads=0;\n Map> map=new HashMap<>();// node -> list({des,time})\n for(List curr:roads){\n int src=curr.get(0);\n int des=curr.get(1);\n int time=curr.get(2);\n map.putIfAbsent(src,new ArrayList<>());\n map.putIfAbsent(des,new ArrayList<>());\n map.get(src).add(new int[]{des,time});\n map.get(des).add(new int[]{src,time});\n }\n boolean[]vis=new boolean[n];\n dfs(0,map,vis,0);\n return noOfRoads;\n }\n static void dfs(int node,Map> map,boolean[]vis,int currTime){\n if(node==vis.length-1){\n if(currTimeminTime)return;\n vis[node]=true;\n //find in nebs\n List nebList=map.get(node);\n if(nebList!=null){\n for(int[] neb:nebList){\n int des=neb[0];\n int time=neb[1];\n if(!vis[des]){\n dfs(des,map,vis,currTime+time);\n }\n }\n }\n vis[node]=false;\n }\n}\n" }, { "path": "Number of distict Words with k maximum contiguous vowels.java", "content": "class Solution{\n private static final int mod = 1000000007;\n private static int reset;\n private static Integer[][] dp;\n \n private static int find(int N, int K){\n if(N == 0){\n return 1;\n }\n if(dp[N][K] != null) return dp[N][K];\n \n int count = 0;\n \n for(char c = 'a'; c <= 'z'; c++){\n if(c=='a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'){\n if(K > 0){\n count = (count + find(N-1, K-1)) % mod;\n }\n }\n else{\n count = (count + find(N-1, reset)) % mod;\n }\n }\n \n return dp[N][K] = count;\n }\n \n \n \n public int kvowelwords(int N,int K){\n dp = new Integer[N+1][K+1];\n reset = K;\n return find(N, K);\n }\n}\n" }, { "path": "Number of distinct Words with k maximum contiguous vowels - GFG/README.md", "content": "# Number of distinct Words with k maximum contiguous vowels\n## Hard \n
\n

Find the number of unique words consisting of lowercase alphabets only of length N that can be formed with at-most K contiguous vowels. 

\n\n


\nExample 1:

\n\n
Input:\nN = 2\nK = 0\nOutput:\n441\nExplanation:\nTotal of 441 unique words are possible\nof length 2 that will have K( =0) vowels\ntogether, e.g. \"bc\", \"cd\", \"df\", etc are\nvalid words while \"ab\" (with 1 vowel) is\nnot a valid word.\n\n
\n\n

Example 2:

\n\n
Input:\nN = 1\nK = 1\nOutput:\n26\nExplanation:\nAll the english alphabets including\nvowels and consonants; as atmost K( =1)\nvowel can be taken.\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function kvowelwords() which takes an Integer N, an intege K and returns the total number of words of size N with atmost K vowels. As the answer maybe to large please return answer modulo 1000000007.

\n\n


\nExpected Time Complexity: O(N*K)
\nExpected Auxiliary Space: O(N*K)

\n\n


\nConstraints:
\n1 ≤ N ≤ 1000
\n0 ≤ K ≤ N

\n

\n
" }, { "path": "Number of distinct Words with k maximum contiguous vowels - GFG/number-of-distinct-words-with-k-maximum-contiguous-vowels.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while(t-- > 0)\n {\n int N = sc.nextInt();\n int K = sc.nextInt();\n\n Solution ob = new Solution();\n int ans = ob.kvowelwords(N,K);\n System.out.println(ans);\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n private static final int mod = 1000000007;\n private static int reset;\n private static Integer[][] dp;\n private static int find(int N, int K){\n if(N == 0){\n return 1;\n }\n if(dp[N][K] != null) return dp[N][K];\n \n int count = 0;\n \n for(char c = 'a'; c <= 'z'; c++){\n if(c=='a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'){\n if(K > 0){\n count = (count + find(N-1, K-1)) % mod;\n }\n }\n else{\n count = (count + find(N-1, reset)) % mod;\n }\n }\n \n return dp[N][K] = count;\n }\n \n \n \n public int kvowelwords(int N,int K){\n dp = new Integer[N+1][K+1];\n reset = K;\n return find(N, K);\n }\n}\n" }, { "path": "Number of positive integral solutions - GFG/README.md", "content": "# Number of positive integral solutions\n## Medium \n
\n

You are given an equation of the form x1+x2+...+xN=K. You need to find the total number of positive integral solutions of this equation.
\n 

\n\n

Example 1:

\n\n
Input: s = a+b=5\nOutput: 4\nExplanation: (4,1) , (1,4) , (2,3) , (3,2)\n
\n\n


\nExample 2:

\n\n
Input: s = a+b=1\nOutput: 0\nExplanation: No solution exist.
\n\n

 

\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function posIntSol() which takes a string as input and returns number of solutions.
\n 

\n\n

Expected Time Complexity : O(Length of given string)
\nExpected Auxiliary Space : O(1)
\n 

\n\n

Constraints:
\n1 <= K <= 25
\n2 <= N <= 10

\n\n

 

\n

\n
" }, { "path": "Number of positive integral solutions - GFG/number-of-positive-integral-solutions.py", "content": "#User function Template for python3\nfrom math import factorial as fact\nclass Solution:\n\n def posIntSol(self,s):\n #code here\n r=1\n n=\"\"\n for i in range(len(s)):\n if(s[i]==\"+\"):\n r+=1\n if(s[i]==\"=\"):\n n=s[i+1:]\n break;\n n=int(n)\n \n if(n-1>=r-1):\n return fact(n-1)//(fact(n-r)*fact(r-1))\n else:\n return 0\n#{ \n# Driver Code Starts\n#Initial Template for Python 3\n\nif __name__ == '__main__':\n\n t = int(input())\n\n for _ in range(t):\n s = input()\n\n solObj = Solution()\n\n print(solObj.posIntSol(s))\n# } Driver Code Ends" }, { "path": "Number of ways - GFG/README.md", "content": "# Number of ways\n## Medium \n
\n

Given a value N. In how many ways you can construct a grid of size N x 4 using tiles of size 1 x 4.

\n\n


\nExample 1:

\n\n
Input: N = 1\nOutput: 1\nExplaination: We can arrange the tiles horizontally \nand this is the only way.
\n\n


\nExample 2:

\n\n
Input: N = 4\nOutput: 2\nExplaination: The first way can be when all \nthe 1 x 4 tiles are arranged horizontally. \nSecond way can be when all the 1 x 4 tiles \nare arranged vertically.
\n\n


\nYour Task:
\nYou do not need to read input or print anything. Your task is to complete the function arrangeTiles() which takes the value N as input parameter and returns the number of ways to make N x 4 grid using 1 x 4 tiles.

\n\n


\nExpected Time Complexity: O(N)
\nExpected Auxiliary Space: O(N)

\n\n


\nConstraints:
\n1 ≤ N ≤ 80

\n

\n
" }, { "path": "Number of ways - GFG/number-of-ways.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n int N = Integer.parseInt(in.readLine().trim());\n \n Solution ob = new Solution();\n System.out.println(ob.arrangeTiles(N));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static long arrangeTiles(int n){\n // code here\n if(n<4)return 1;\n int four=n/4;\n long sum=0;\n for(int i=1;i<=four;i++){\n int rem=n-4*i;\n sum=sum+nCr(rem+i,i);\n }\n\n return sum+1;\n }\n \n static long nCr(int n,int r){\n long sum=1;\n int max=Math.max(r,n-r);\n int min=Math.min(r,n-r);\n int st=1;\n for(int i=n;i>max;i--){\n sum= sum*i;\n sum/=st;\n st++;\n }\n return sum;\n }\n}" }, { "path": "Number-of-ways-to-arrive-destination/Solution.cpp", "content": "typedef pair ip;\nlong long int M=1e9+7;\nclass Solution {\n public:\n int countPaths(int n, vector>& roads) {\n int ans=0;\n vector dis(n,INT_MAX);\n vector adj[n];\n for(auto it: roads)\n adj[it[0]].push_back({it[1],it[2]}),adj[it[1]].push_back({it[0],it[2]});\n \n priority_queue,greater > pq;\n dis[0]=0;\n pq.push({dis[0],0});\n while(!pq.empty()){\n int src=pq.top().second,wt=pq.top().first;\n pq.pop();\n for(auto it: adj[src]){\n int v=it.first,nw=wt+it.second;\n if(v==n-1){\n if(dis[v]==nw)\n ans=(ans+1ll)%M;\n else if(dis[v]>nw)\n dis[v]=nw,ans=1;\n }\n else{\n if(dis[v]>=nw)\n dis[v]=nw,pq.push({dis[v],v});\n }\n }\n }\n return ans;\n }\n};" }, { "path": "Number-of-ways-to-arrive-destination/question.md", "content": "### Number of Ways to Arrive at Destination\n\n**Medium**Accuracy: **48.81%**Submissions: **127**Points: **4**\n\nYou are in a city that consists of `n` intersections numbered from `0` to `n - 1` with **bi-directional** roads between some intersections. The inputs are generated such that you can reach any intersection from any other intersection and that there is at most one road between any two intersections.\n\nYou are given an integer `n` and a 2D integer array `roads` where `roads[i] = [ui, vi, timei]` means that there is a road between intersections `ui` and `vi` that takes `timei` minutes to travel. You want to know in how many ways you can travel from intersection `0` to intersection `n - 1` in the **shortest amount of time** .\n\nReturn *the **number of ways** you can arrive at your destination in the **shortest amount of time*** . Since the answer may be large, return it **modulo** `109 + 7`.\n\n```\nExample:\nInput:\nn=7, m=10\nedges= [[0,6,7],[0,1,2],[1,2,3],[1,3,3],[6,3,3],[3,5,1],[6,5,1],[2,5,1],[0,4,5],[4,6,2]]\n\nOutput:\n4\nExplaination:\n\nThe four ways to get there in 7 minutes are:\n- 0 6\n- 0 4 6\n- 0 1 2 5 6\n- 0 1 3 5 6\n\n\n```\n\n**Constraints:**\n`1 <= n <= 200
n - 1 <= roads.length <= n * (n - 1) / 2
roads[i].length == 3
0 <= ui, vi <= n - 1
1 <= timei <= 109
ui != vi`\nThere is at most one road connecting any two intersections.\nYou can reach any intersection from any other intersection.\n\nExpected Time Complexity: O(M * logN + N)\nExpected Space Complexity: O(M+N)\n" }, { "path": "Numbers-With-Same-Consecutive-Differences.cpp", "content": "class Solution {\npublic:\n vector ans;\n \n void solve(int idx, int n, int k, int num){\n if(idx == n){\n if(ans.empty() || ans.back() != num)\n ans.push_back(num);\n return;\n }\n \n int lastDigit = num % 10;\n \n if(lastDigit+k < 10){ \n solve(idx+1,n,k, num*10 + (lastDigit+k)); \n }\n if(lastDigit-k >= 0){ \n solve(idx+1,n,k, num*10 + (lastDigit-k));\n }\n return;\n }\n \n vector numsSameConsecDiff(int n, int k) {\n \n for(int i = 1; i < 10; i++){\n solve(1,n,k,i);\n }\n return ans;\n }\n};\n" }, { "path": "Occurence of Each Number.java", "content": "public class Solution {\n public ArrayList findOccurences(ArrayList A) {\n ArrayList ans=new ArrayList<>();\n Collections.sort(A);\n int cnt=1;\n int prev=A.get(0);\n for(int i=1;i B){\n low++;\n } else high++;\n }\n return 0;\n }\n}\n" }, { "path": "Pairs With Given Xor.java", "content": "public class Solution {\n public int solve(int[] A, int B) {\n Set set = new HashSet<>();\n int count = 0;\n for(int i : A){\n if(set.contains(i)){\n count++;\n }else{\n set.add(i^B);\n }\n }\n return count;\n }\n}\n\n" }, { "path": "Pairs of Non Coinciding Points - GFG/README.md", "content": "# Pairs of Non Coinciding Points\n## Medium \n
\n

In a given cartesian plane, there are N points. We need to find the Number of Pairs of  points(A, B) such that

\n\n
    \n\t
  • Point A and Point B do not coincide.
    • \n\t
  • Manhattan Distance and the Euclidean Distance between the points should be equal.
    • \n
\n\n

Note: Pair of 2 points(A,B) is considered same as Pair of 2 points(B ,A).
\nManhattan Distance = |x2-x1|+|y2-y1|
\nEuclidean Distance   = ((x2-x1)^2 + (y2-y1)^2)^0.5, where points are (x1,y1) and (x2,y2).

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 2\nX = {1, 7}\nY = {1, 5}\nOutput:\n0\nExplanation:\nNone of the pairs of points have\nequal Manhatten and Euclidean distance.
\n\n

Example 2:

\n\n
Input:\nN = 3\nX = {1, 2, 1}\nY = {2, 3, 3}\nOutput:\n2\nExplanation:\nThe pairs {(1,2), (1,3)}, and {(1,3), (2,3)}\nhave equal Manhatten and Euclidean distance.
\n\n

 

\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function numOfPairs() which takes an Integer N and two arrays X, and Y of length N as input and returns the number of pairs with equal Manhattan and Euclidean Distance. (X[i], Y[i]) denotes a point.

\n\n

 

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(N)

\n\n

 

\n\n

Constraints:
\n1 <= N <= 105
\n -10^9 <= X[i], Y[i] <= 10^9

\n

\n
" }, { "path": "Pairs of Non Coinciding Points - GFG/pairs-of-non-coinciding-points.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N = Integer.parseInt(read.readLine());\n \n String S1[] = read.readLine().split(\" \");\n String S2[] = read.readLine().split(\" \");\n \n int[] X = new int[N];\n int[] Y = new int[N];\n \n for(int i=0; i xCount = new HashMap<>();\n HashMap yCount = new HashMap<>();\n HashMap, Integer> visited = new HashMap<>();\n int ans = 0;\n int count1 = 0;\n int count2 = 0;\n int count3 = 0;\n\n for (int i = 0; i < n; ++i) {\n count1 += xCount.getOrDefault(x[i], 0);\n xCount.put(x[i], xCount.getOrDefault(x[i], 0) + 1);\n }\n \n for (int i = 0; i < n; ++i) {\n count2 += yCount.getOrDefault(y[i], 0);\n yCount.put(y[i], yCount.getOrDefault(y[i], 0) + 1);\n }\n \n for (int i = 0; i < n; ++i) {\n ArrayList current = new ArrayList<>(Arrays.asList(x[i], y[i]));\n count3 += visited.getOrDefault(current, 0);\n visited.put(current, visited.getOrDefault(current, 0) + 1);\n }\n \n ans = count1 + count2 - 2 * count3;\n \n return ans;\n }\n};" }, { "path": "Palindrome List.java", "content": "public class Solution {\n public int lPalin(ListNode A) {\n if(A==null || A.next==null)return 1;\n int sz=0;\n ListNode temp=A;\n while(temp!=null){\n temp=temp.next;\n sz++;\n }\n ListNode prev=null;\n ListNode curr=A;\n for(int i=0;i pal=new ArrayList<>();\n for(i=A;i<=B;i++)\n {\n if(check(Integer.toString(i)))pal.add(i);\n }\n // int ans=0;/\n int l=0;\n int n=pal.size();\n int ans=0;\n i=0;\n while(iC)l++;\n }\n return ans;\n }\n boolean check(String s)\n{\n int n=s.length();\n int i;\n for(i=0;i=j)\n return dp[i][j] = 0;\n if(dp[i][j] != -1)\n return dp[i][j];\n if(isPalindrome(str,i,j))\n return 0;\n int min = Integer.MAX_VALUE; \n for(int k=i;k<=j-1;k++){\n int left = 0,right = 0;\n if(dp[i][k] != -1)\n left = dp[i][k];\n else{\n left = solve(str,i,k);\n dp[i][k] = left;\n }\n if(dp[k+1][j] != -1)\n right = dp[k+1][j];\n else{\n right = solve(str,k+1,j);\n dp[k+1][j] = right;\n }\n int temp = right + left + 1;\n min = Math.min(min,temp);\n }\n return dp[i][j] = min;\n }\n static boolean isPalindrome(String str,int i,int j){\n String x = str.substring(i,j+1);\n int k=0,l=x.length()-1;\n while(k> partition(String a) {\n ArrayList> ans=new ArrayList<>();\n ArrayList path=new ArrayList<>();\n helper(a,0,path,ans);\n return ans;\n\t}\n void helper(String s,int index,ArrayList path,ArrayList> ans){\n if(index==s.length()){\n ans.add(new ArrayList<>(path));\n return;\n }\n for(int i=index;i=m && r<60) return r-m;\n else{\n h=(h+1)%24;\n ans+=60-m;\n if(h>=10 && (h<16 || h>=20)){\n r=(h%10)*10 + h/10;\n if(r==10)\n r=1;\n }else if(h>=16){\n ans+=(20-h)*60;\n r=2;\n }\n\n else if(h<6)\n\n r=h*10;\n\n else\n\n {\n\n ans+=(10-h)*60;\n\n r=1;\n\n }\n\n \n\n }\n\n return ans+r;\n\n\n}\n}\n" }, { "path": "Palindromic Words.java", "content": "public class Solution {\n public int solve(String A) {\n int ans=0;\n String[]arr=A.split(\" \");\n for(String a:arr){\n if(isPalindrome(a))ans++;\n }\n return ans;\n }\n boolean isPalindrome(String str){\n \n // Pointers pointing to the beginning\n // and the end of the string\n int i = 0, j = str.length() - 1;\n \n // While there are characters to compare\n while (i < j) {\n \n // If there is a mismatch\n if (str.charAt(i) != str.charAt(j))\n return false;\n \n // Increment first pointer and\n // decrement the other\n i++;\n j--;\n }\n \n // Given string is a palindrome\n return true;\n }\n}\n" }, { "path": "Partition Array According to Given Pivot.java", "content": "class Solution {\n public int[] pivotArray(int[] nums, int pivot) {\n List small=new ArrayList<>();\n List large=new ArrayList<>();\n int pivs=0;\n int n=nums.length;\n for(int i=0;ipivot){\n large.add(nums[i]);\n }else{\n pivs++;\n }\n }\n int index=0;\n for(int i=0;i partitionLabels(string s) {\n unordered_map mp;\n for(int i=0;i ans;\n int prev=-1,mx=0;\n for(int i=0;i\n

Given a linked list and a value x, partition it such that all nodes less than x come first, then all nodes with value equal to x and finally nodes with value greater than or equal to x. The original relative order of the nodes in each of the three partitions should be preserved. The partition must work in-place.
\n\n
 
\n\n
Example 1:
\n\n
Input:\n1->4->3->2->5->2->3,\nx = 3\nOutput:\n1->2->2->3->3->4->5\nExplanation: \nNodes with value less than 3 come first, \nthen equal to 3 and then greater than 3.\n
\n\n
Example 2:
\n\n
Input:\n1->4->2->10 \nx = 3\nOutput: \n1->2->4->10\nExplanation:\nNodes with value less than 3 come first,\nthen equal to 3 and then greater than 3.\n
\n\n
Your task:
\n\n
You don't need to read input or print anything. Your task is to complete the function partition() which takes the head of the inked list and an integer x as input, and returns the head of the modified linked list after arranging the values according to x.
\n\n
 
\n\n
Expected time complexity : O(n)
\n\n
Expected Auxiliary Space: O(n)
\n\n
 
\n\n
Constraints:
\n\n
1 <= N <= 105
\n\n
1 <= k <= 105
\n

\n " }, { "path": "Partition a Linked List around a given value - GFG/partition-a-linked-list-around-a-given-value.java", "content": "// { Driver Code Starts\n//Initial Template for Java\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass Node {\n int data;\n Node next;\n Node(int key) {\n data = key;\n next = null;\n }\n}\n\nclass Partition {\n static Node head;\n\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n\n while (t-- > 0) {\n int n = sc.nextInt();\n int a1 = sc.nextInt();\n Node head = new Node(a1);\n Node tail = head;\n for (int i = 1; i < n; i++) {\n int a = sc.nextInt();\n // addToTheLast(new Node(a));\n tail.next = new Node(a);\n tail = tail.next;\n }\n\n int k = sc.nextInt();\n Solution ob = new Solution();\n Node res = ob.partition(head, k);\n printList(res);\n System.out.println();\n }\n }\n\n public static void printList(Node node) {\n while (node != null) {\n System.out.print(node.data + \" \");\n node = node.next;\n }\n }\n}// } Driver Code Ends\n\n\n// User function Template for Java\n\n/*class Node\n{\n int data;\n Node next;\n Node(int key)\n {\n data = key;\n next = null;\n }\n}\n\n*/\n\nclass Solution {\n public static Node partition(Node node, int x) {\n Queue fis=new LinkedList<>();\n Queue sec=new LinkedList<>();\n Queue thir=new LinkedList<>();\n Node temp=node;\n while(temp!=null){\n if(temp.data0){\n temp.next=fis.remove();\n temp=temp.next;\n }\n while(sec.size()>0){\n temp.next=sec.remove();\n temp=temp.next;\n }\n while(thir.size()>0){\n temp.next=thir.remove();\n temp=temp.next;\n }\n return head.next;\n }\n}" }, { "path": "Partition a number into two divisible parts - GFG/README.md", "content": "# Partition a number into two divisible parts\n## Medium \n
\n

Given a number (as string) and two integers a and b, divide the string in two non-empty parts such that the first part is divisible by a and the second part is divisible by b. In case multiple answers exist, return the string such that the first non-empty part has minimum length.

\n\n

 

\n\n

Example 1:

\n\n
Input:\n1200 4 3\nOutput:\n12 00\nExplanation:\n12 is divisible by 4, and\n00 is divisible by 3.
\n\n

 

\n\n

Example 2:

\n\n
Input: \n125 12 5\nOutput: \n12 5\nExplanation: \n12 is divisible by 12, and \n5 is divisible by 5.
\n\n

 

\n\n

Your Task:

\n\n

You don't need to read input or print anything. Your task is to complete the function stringPartition() which takes the string S and returns a string which will be in the form of first sub-string + \" \" (Single Space) + second sub-string. If not found return -1 as a string.

\n\n

 

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(N)
\n 

\n\n

Constraints:

\n\n

1<=N<=106

\n\n

1<=a,b<=N

\n

\n
" }, { "path": "Partition a number into two divisible parts - GFG/partition-a-number-into-two-divisible-parts.java", "content": "// { Driver Code Starts\n//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String str[] = read.readLine().split(\" \");\n String S= str[0];\n int a = Integer.parseInt(str[1]);\n int b = Integer.parseInt(str[2]);\n Solution ob = new Solution();\n System.out.println(ob.stringPartition(S,a,b));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution{\n static String stringPartition(String S, int a, int b){\n int n=S.length();\n String[]pre=new String[n-1];\n String[]post=new String[n-1];\n for(int i=0;i\n

Given an integer array a[ ] of N elements and an integer K, the task is to check if the array a[ ] could be divided into K non-empty subsets with equal sum of elements.
\nNote: All elements of this array should be part of exactly one partition.

\n\n

Example 1:

\n\n
Input: \nN = 5\na[] = {2,1,4,5,6}\nK = 3\nOutput: \n1\nExplanation: we can divide above array \ninto 3 parts with equal sum as (2, 4), \n(1, 5), (6)\n
\n\n

Example 2:

\n\n
Input: \nN = 5 \na[] = {2,1,5,5,6}\nK = 3\nOutput: \n0\nExplanation: It is not possible to divide\nabove array into 3 parts with equal sum.\n
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function isKPartitionPossible() which takes the array a[], the size of the array N, and the value of K as inputs and returns true(same as 1) if possible, otherwise false(same as 0).

\n\n

Expected Time Complexity: O(N*2N).
\nExpected Auxiliary Space: O(2N).

\n\n

Constraints:
\n1 ≤ K ≤ N ≤ 10
\n1 ≤ a[i] ≤ 100

\n

\n " }, { "path": "Partition array to K subsets - GFG/partition-array-to-k-subsets.java", "content": "// { Driver Code Starts\nimport java.util.*;\n\nclass Partition_Arr_To_K_Subsets\n{\n\tpublic static void main(String args[])\n\t{\n\t\tScanner sc = new Scanner(System.in);\n\t\tint t = sc.nextInt();\n\t\twhile(t>0)\n\t\t{\n\t\t\tint n = sc.nextInt();\n\t\t\tint a[] = new int[n];\n\t\t\tfor(int i=0;itarget) || (i>0 && sum[i] == sum[i-1]))continue;\n \n sum[i]+=arr[ind];\n \n if(dfs(ind-1,arr,sum,k,target))return true;\n sum[i]-= arr[ind];\n }\n return false;\n }\n}\n" }, { "path": "Partition array to K subsets - GFG/partition-array-to-k-subsets.py", "content": "#User function Template for python3\n\nfrom functools import lru_cache\nclass Solution:\n def isKPartitionPossible(self, nums, k):\n #code here\n if sum(nums)%k:\n return False\n visited=[False]*len(nums)\n nums.sort(reverse=True)\n \n target=sum(nums)/k\n \n @lru_cache(None)\n def solve(i,k,ans):\n if k==0:\n return True\n if ans==target:\n return solve(0,k-1,0)\n for j in range(i,len(nums)):\n if visited[j] or ans+nums[j]>target:\n continue\n visited[j]=True\n if solve(j+1,k,ans+nums[j]):\n return True\n visited[j]=False\n return False\n return solve(0,k,0)\n \n#{ \n# Driver Code Starts\n\n\nif __name__ == '__main__':\n tcs = int(input())\n for _ in range(tcs):\n N=int(input())\n arr=[int(x) for x in input().split()]\n k=int(input())\n if Solution().isKPartitionPossible(arr, k):\n print(1)\n else:\n print(0)\n# } Driver Code Ends" }, { "path": "Partition array to K subsets.java", "content": "class Solution\n{\n public boolean isKPartitionPossible(int a[], int n, int k)\n {\n\t// Your code here\t\n\t int sum=0;\n\t for(int i:a)sum+=i;\n\t \n\t if(sum%k != 0)return false;\n\t \n\t int target=sum/k;\n\t int[] subsets=new int[k];\n\t Arrays.sort(a);\n\t \n\t return dfs(a,subsets,n-1,target);\n }\n \n boolean dfs(int[]a,int[]subsets,int ind,int target){\n if(ind==-1)return true;\n \n for(int i=0;itarget)continue;\n subsets[i]+=a[ind];\n if(dfs(a,subsets,ind-1,target)){\n return true;\n }\n subsets[i]-=a[ind];\n }\n return false;\n }\n}\n" }, { "path": "Party in Town - GFG/README.md", "content": "# Party in Town\n## Medium \n
\n

Geek town has N Houses numbered from 1 to N. They are connected with each other via N-1 bidirectional roads and an adjacency list is used to represent the connections. Find the house from which the distance to the farthest house is the minimum to host the optimal party.

\n\n


\nExample 1:

\n\n
Input: \nN = 4\nRoads = {{1,2},{2,3},{2,4}} \nadj = {{2},{1,3,4},{2},{2}} \n\nOutput: 1\n\nExplaination: Maximum distance from house number 2 is 1.
\n\n


\nYour Task:
\nYou do not need to read input or print anything. Your task is to complete the function partyHouse() which takes N and adj as input parameters and returns the minimum possible distance to the farthest house from the house where the party is happening.

\n\n


\nExpected Time Complexity: O(N*N)
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 ≤ N ≤ 1000

\n

\n
" }, { "path": "Party in Town - GFG/party-in-town.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n int N = Integer.parseInt(in.readLine());\n ArrayList> adj = new ArrayList>();\n \t\tfor(int i = 0;i < N+1;i++){\n \t ArrayList arr = new ArrayList();\n \t adj.add(arr);\n \t\t}\n \t\tfor(int i = 0;i < N-1;i++){\n \t\t String a[] = in.readLine().trim().split(\"\\\\s+\");\n \t\t int x = Integer.parseInt(a[0]);\n \t\t int y = Integer.parseInt(a[1]);\n \t\t adj.get(x).add(y);\n \t\t adj.get(y).add(x);\n \t\t}\n \t\t\n \t\tSolution ob = new Solution();\n \t\tSystem.out.println(ob.partyHouse(N, adj));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution{\n static int dfs(ArrayList> adj, int start, boolean[]visited){\n Queue q = new LinkedList<>();\n q.add(start);\n int level = 0;\n while(!q.isEmpty()){\n int size = q.size();\n while(size-->0){\n int val = q.remove();\n visited[val] = true;\n for(int i : adj.get(val)){\n if(visited[i]==false){\n q.add(i);\n }\n }\n }\n level++;\n }\n return level-1;\n }\n static int partyHouse(int N, ArrayList> adj)\n {\n int ans = Integer.MAX_VALUE;\n for(int i=1; i<=N;i++){\n boolean[]visited = new boolean[N+1];\n ans = Math.min(ans, dfs(adj, i,visited)); \n } \n return ans;\n }\n}" }, { "path": "Pascal's Triangle.java", "content": "class Solution {\n public List> generate(int numRows) {\n List> triangle=new ArrayList<>();\n triangle.add(new ArrayList<>());\n triangle.get(0).add(1);\n for(int i = 1; i < numRows; i++){\n\t\t List row = new ArrayList<>();\n\t\t List prevRow = triangle.get(i-1);\n\t\t\n\t\t row.add(1);\n\t\t\n\t\t for(int j = 1; j < i; j++){\n\t\t\t row.add(prevRow.get(j-1) + prevRow.get(j));\n\t\t }\n\t\t\n\t\t row.add(1);\n\t\t triangle.add(row);\n\t }\n\t return triangle; \n } \n}\n" }, { "path": "Path in Directed Graph.java", "content": "public class Solution {\n public int solve(int A, int[][] B) {\n Map>map=new HashMap<>();\n for(int i=0;i());\n }\n for(int i=0;i arr=map.get(B[i][0]);\n arr.add(B[i][1]);\n map.put(B[i][0],arr);\n }\n Queue q=new LinkedList<>();\n q.add(1);\n boolean[]vis=new boolean[A+1];\n while(!q.isEmpty()){\n int sz=q.size();\n for(int i=0;i>map=new HashMap<>();\n for(int i=0;i());\n }\n for(int i=0;i arr=map.get(B[i][0]);\n arr.add(B[i][1]);\n map.put(B[i][0],arr);\n }\n Queue q=new LinkedList<>();\n q.add(1);\n boolean[]vis=new boolean[A+1];\n while(!q.isEmpty()){\n int sz=q.size();\n for(int i=0;i ans=new ArrayList<>();\n public ArrayList solve(TreeNode A, int B) {\n target=B;\n solve(A,new ArrayList());\n return ans;\n }\n public void solve(TreeNode curr,ArrayList arr){\n if(curr==null)return;\n arr.add(curr.val);\n if(curr.val==target){\n ans=arr;\n return;\n }else{\n if(curr.left!=null){\n solve(curr.left,(ArrayList)arr.clone());\n }\n if(curr.right!=null){\n solve(curr.right,(ArrayList)arr.clone());\n }\n }\n }\n}\n" }, { "path": "Path with good nodes!.java", "content": "public class Solution {\n public int solve(int[] type, int[][] B, int C) {\n int n = type.length;\n ArrayList> adj = new ArrayList<>();\n for(int i = 0; i < n; i++) adj.add(new ArrayList<>());\n\n for(int[] edge : B){\n adj.get(edge[0] - 1).add(edge[1] - 1);\n adj.get(edge[1] - 1).add(edge[0] - 1);\n }\n return dfs(0, type, C - type[0], -1, adj);\n }\n private int dfs(int root,int[] type, int goodNodes, int par, ArrayList> adj){\n if(goodNodes < 0) return 0;\n int cnt = 0;\n // we are at leaf node\n if(adj.get(root).size() == 1) {\n return 1;\n }\n\n for(int child :adj.get(root)){\n if(child == par)continue;\n cnt += dfs(child, type, goodNodes - type[child], root, adj);\n }\n return cnt;\n }\n}\n" }, { "path": "Perfect Peak of Array.java", "content": "public class Solution {\n public int perfectPeak(int[] A) {\n int n=A.length;\n int[] maxArr=new int[n];\n int[] minArr=new int[n];\n maxArr[0]=A[0];\n for(int i=1;i=0;i--){\n minArr[i]=Math.min(A[i],minArr[i+1]);\n }\n for(int i=1;imaxArr[i-1] && A[i] len_s2) return false;\n \n int[] count = new int[26];\n for (int i = 0; i < len_s1; i++) {\n count[s1.charAt(i) - 'a']++;\n count[s2.charAt(i) - 'a']--;\n }\n if (zeroCount(count)) return true;\n \n for (int i = len_s1; i < len_s2; i++) {\n count[s2.charAt(i) - 'a']--;\n count[s2.charAt(i - len_s1) - 'a']++;\n if (zeroCount(count)) return true;\n }\n \n return false;\n }\n \n private boolean zeroCount(int[] count) {\n for (int i = 0; i < 26; i++) {\n if (count[i] != 0) \n return false;\n }\n return true;\n }\n}\n\n==================================================================================================\n \n class Solution {\n public boolean checkInclusion(String s1, String s2) {\n int[] arr=new int[26];\n for(char c:s1.toCharArray()){\n arr[(int)c-97]++;\n }\n \n int[] a=new int[26];\n for(int i=0;i<=s2.length()-s1.length();i++){\n a=arr.clone();\n boolean present=false;\n for(int j=i;j\n

Given a string you need to print all possible strings that can be made by placing spaces (zero or one) in between them. The output should be printed in sorted increasing order of strings

\n\n

Example 1:

\n\n
Input:\nS = \"ABC\"\nOutput: (A B C)(A BC)(AB C)(ABC)\nExplanation:\nABC\nAB C\nA BC\nA B C\nThese are the possible combination of \"ABC\".
\n\n

 

\n\n

Example 2:

\n\n
Input:\nS = \"AB\"\nOutput: (A B)(AB)\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function permutation() which takes the string S as input parameters and returns the sorted array of the string denoting the different permutation (DON'T ADD '(' and ')' it will be handled by the driver code only).
\n
\nExpected Time Complexity: O(2^n)
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

CONSTRAINTS:
\n1 < |S| < 10
\nS only contains lowercase and Uppercase English letters.

\n

\n " }, { "path": "Permutation with Spaces - GFG/permutation-with-spaces.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String S = read.readLine().trim();\n Solution ob = new Solution();\n ArrayList ans = new ArrayList();\n ans = ob.permutation(S);\n \n for(int i=0;i ans;\n ArrayList permutation(String S){\n ans=new ArrayList<>();\n helper(\"\",S);\n return ans;\n }\n public void helper(String curr,String s){\n if(s.length()==0){\n ans.add(curr);\n return;\n }\n if(curr.length()==0){\n helper(s.charAt(0)+\"\",s.substring(1)); \n return;\n }\n helper(curr+\" \"+s.charAt(0),s.substring(1));\n helper(curr+s.charAt(0),s.substring(1));\n }\n \n}" }, { "path": "Permutations.java", "content": "public class Solution {\n ArrayList> ans;\n public ArrayList> permute(ArrayList A) {\n int n=A.size();\n ans=new ArrayList<>();\n boolean[] vis=new boolean[n];\n dfs(new ArrayList<>(),A,vis);\n return ans;\n }\n public void dfs(ArrayList curr,ArrayList A,boolean[]vis){\n if(curr.size()==A.size()){\n if(!ans.contains(curr)){\n ans.add(new ArrayList(curr));\n }\n return;\n }\n for(int i=0;i\n

Given two polynomial numbers represented by a linked list. The task is to complete the function addPolynomial() that adds these lists meaning adds the coefficients who have the same variable powers.
\nNote:  Given polynomials are sorted in decreasing order of power.

\n\n

Example 1:

\n\n
Input:\nLinkedList1:  (1,x2) \nLinkedList2:  (1,x3)\nOutput:\n1x^3 + 1x^2\nExplanation: Since, x2 and x3 both have\ndifferent powers as 2 and 3. So, their\ncoefficient can't be added up.\n
\n\n

Example 2:

\n\n
Input:\nLinkedList1:  (1,x3) -> (2,x2)\nLinkedList2:  (3,x3) -> (4,x2)\nOutput:\n4x^3 + 6x^2\nExplanation: Since, x3 has two different\ncoefficients as 3 and 1. Adding them up\nwill lead to 4x3. Also, x2 has two\ncoefficients as 4 and 2. So, adding them\nup will give 6x2.
\n\n

Your Task:
\nThe task is to complete the function addPolynomial() which should add the polynomial with same powers return the required polynomial in decreasing order of the power in the form of a linked list.
\nNote: Try to solve the question without using any extra space.

\n\n

Expected Time Complexity: O(N+M)
\nExpected Auxiliary Space: O(1)

\n\n

Constraints:
\n1 <= N, M <= 105
\n1 <= x, y <= 106

\n

\n " }, { "path": "Polynomial Addition - GFG/polynomial-addition.java", "content": "// { Driver Code Starts\nimport java.util.Scanner;\nimport java.io.*;\nclass Node{\n int coeff;\n int pow;\n Node next;\n Node(int a,int b)\n {\n coeff=a;\n pow=b;\n next=null;\n }\n}\nclass GFG2\n{\n public static void main(String args[])\n {\n Scanner sc=new Scanner(System.in);\n int t=sc.nextInt();\n while(t-->0)\n {\n int n=sc.nextInt();\n Node start1=null,cur1=null,start2=null,cur2=null;\n while(n-->0)\n {\n int a=sc.nextInt();\n int b=sc.nextInt();\n Node ptr=new Node(a,b);\n if(start1==null)\n {\n start1=ptr;\n cur1=ptr;\n }\n else{\n cur1.next=ptr;\n cur1=ptr;\n }\n }\n n=sc.nextInt();\n while(n-->0)\n {\n int a=sc.nextInt();\n int b=sc.nextInt();\n Node ptr=new Node(a,b);\n if(start2==null)\n {\n start2=ptr;\n cur2=ptr;\n }\n else{\n cur2.next=ptr;\n cur2=ptr;\n }\n }\n Solution obj=new Solution();\n Node sum = obj.addPolynomial(start1,start2);\n for(Node ptr=sum ; ptr != null; ptr=ptr.next )\n {\n // printing polynomial\n System.out.print(ptr.coeff + \"x^\" + ptr.pow);\n if(ptr.next != null)\n System.out.print(\" + \");\n }\n System.out.println();\n }\n }\n}// } Driver Code Ends\n\n\n/*class Node{\n int coeff;\n int pow;\n Node next;\n Node(int a,int b)\n {\n coeff=a;\n pow=b;\n next=null;\n }\n}*/\n\n//Print the polynomial formed by adding both LL in the function itself.\nclass Solution\n{\n public static Node addPolynomial(Node p1,Node p2)\n {\n //Add your code here.\n Node ans =new Node(-1,-1);\n Node curr=ans;\n Node temp1=p1;\n Node temp2=p2;\n while(temp1!=null && temp2!=null){\n if(temp1.pow==temp2.pow){\n temp1.coeff=temp1.coeff+temp2.coeff;\n curr.next=temp1;\n curr=curr.next;\n temp1=temp1.next;\n temp2=temp2.next;\n }else if(temp2.powfindPairs(int arr[], int n) \n { \n \tArrayList< Integer > results = new ArrayList<>();\n Set< Integer > set = new HashSet<>();\n for (int a : arr) {\n if (set.contains(-a)) {\n int x = Math.abs(a);\n results.add(-x);\n results.add(x);\n }\n set.add(a);\n }\n return results;\n }\n}\n" }, { "path": "Postorder Traversal (Iterative).java", "content": "class Tree {\n ArrayList postOrder(Node node) {\n // code here\n Map map=new HashMap<>();\n Deque s=new ArrayDeque<>();\n ArrayList ans=new ArrayList<>();\n if(node!=null){\n s.push(node);\n map.put(node,true);\n }\n if(node.right!=null){\n s.push(node.right);\n map.put(node.right,false);\n }\n if(node.left!=null){\n s.push(node.left);\n map.put(node.left,false);\n }\n while(!s.isEmpty()){\n Node cur=s.pop();\n if(map.get(cur)){\n ans.add(cur.data);\n }else{\n s.push(cur);\n if(cur.right!=null){\n s.push(cur.right);\n map.put(cur.right,false);\n }\n if(cur.left!=null){\n s.push(cur.left);\n map.put(cur.left,false);\n }\n map.put(cur,true);\n }\n }\n return ans;\n \n }\n}\n" }, { "path": "Postorder Traversal.py", "content": "class Solution:\n\t# @param A : root node of tree\n\t# @return a list of integers\n\tdef postorderTraversal(self, A):\n\t\tans=[]\n\t\tif A==None:\n\t\t\treturn ans\n\t\tstack=[(A,0)]\n\t\twhile len(stack)>0:\n\t\t\t(curr,vis)=stack.pop()\n\t\t\tif vis==1:\n\t\t\t\tans.append(curr.val)\n\t\t\telse:\n\t\t\t\tstack.append((curr,1))\n\t\t\t\tif curr.right!=None:\n\t\t\t\t\tstack.append((curr.right,0))\n\t\t\t\tif curr.left!=None:\n\t\t\t\t\tstack.append((curr.left,0))\n\t\treturn ans\n" }, { "path": "Pots of Gold Game.java", "content": "class GfG\n{\n\tpublic static int maxCoins(int A[],int n)\n\t{\n //add code here.\n int[][]dp=new int[n+1][n+1];\n return dfs(A,0,n-1,dp);\n }\n static int dfs(int[]A,int i,int j,int[][]dp){\n if(i==j)return A[i];\n if(i+1==j)return Math.max(A[i],A[j]);\n if(dp[i][j]==0){\n int start=A[i]+Math.min(dfs(A,i+2,j,dp),dfs(A,i+1,j-1,dp));\n int end=A[j]+Math.min(dfs(A,i+1,j-1,dp),dfs(A,i,j-2,dp));\n dp[i][j]=Math.max(start,end);\n }\n return dp[i][j];\n }\n}\n" }, { "path": "Power Of 2 and Subsequences GFG/powerOf2Sub.cpp", "content": "long long numberOfSubsequences(int N, long long A[]){\n int mod=1e9+7;\n long long count=0;\n for(int i=0;i A){\n // code here\n int cnt=0;\n long mod=1000000007l;\n for(Long i:A){\n if((i&(i-1))==0){\n cnt++;\n }\n }\n return (long)(Math.pow(2,cnt)%mod-1)%mod;\n }\n}\n" }, { "path": "Power Of 2 and Subsequences.py", "content": "class Solution:\n def numberOfSubsequences (ob,N,A):\n import math\n A2 = []\n for i in A:\n if math.ceil((math.log(i, 2) )) == math.floor((math.log(i, 2))):\n A2.append(i)\n n = len(A2)\n return (2**n - 1) % (10**9+7)\n" }, { "path": "Power of 2 and Subsequences.cpp", "content": "class Solution{ \npublic:\n \n long long numberOfSubsequences(int N, long long A[]){\n // code here \n long long ans = 0, MOD = 1e9+7;\n \n for(int i=0; i 1)\n {\n if(temp%2)\n {\n f = false;\n break;\n }\n \n temp /= 2;\n }\n \n if(f)\n {\n ans *= 2;\n ans++;\n \n ans %= MOD;\n }\n }\n \n return ans;\n }\n};\n" }, { "path": "Power of 2 and Subsequences.java", "content": "class Solution{\n static Long numberOfSubsequences(int N, ArrayList A){\n // code here\n long m=(long)1e9+7;\n long count=0;\n for(int i=0;iInput:\nN = 3\nA[] = {1, 6, 2}\nOutput:\n3\nExplanation:\nThe subsequence that \ncan be chosen is {1},\n{2} and {1,2}.\n\n**Example 2:**\n\n
Input:\nN = 3\nA[] = {3, 5, 7}\nOutput:\n0\nExplanation:\nNo subsequences exist.\n
\n\n**Your Task:**\n\nYou don't need to read input or print anything. Your task is to complete the function numberOfSubsequences() which takes an integer N and an array A and returns the number of subsequences that exist. As this number can be very large return the result under modulo 10 ^9^ +7.\n\n**Expected Time Complexity:** O(N)\n**Expected Auxiliary Space:** O(1)\n\n**Constraints:**\n1 <= N <= 10^5^\n1 <= A[i] <= 10^9^\n" }, { "path": "Preorder Traversal.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n ArrayList ans;\n public ArrayList preorderTraversal(TreeNode A) {\n ans=new ArrayList<>();\n pre(A);\n return ans;\n }\n void pre(TreeNode root){\n if(root==null)return;\n ans.add(root.val);\n pre(root.left);\n pre(root.right);\n }\n \n}\n" }, { "path": "Preorder to BST.java", "content": "public static Node post_order(int pre[], int size) \n{\n //Your code here\n Node root=new Node(pre[0]);\n for(int i=1;i\n

Given a non-negative number N in the form of string. The task is to apply at most one swap operation on the number N so that the result is just a previous possible number.

\n\n

Note:  Leading zeros are not allowed.

\n\n

 

\n\n

Example 1:

\n\n
Input :\nS = \"12435\"\nOutput: \n12345\nExplanation:\nAlthough the number 12354 \nwill be the largest smaller \nnumber from 12435. But it is \nnot possible to make it using \nonly one swap. So swap \n4 and 3 and get 12345.
\n\n

 

\n\n

Example 2:

\n\n
Input: \nS = \" 12345\"\nOutput: \n-1\nExplanation:\nDigits are in increasing order. \nSo it is not possible to \nmake a smaller number from it.
\n\n

 

\n\n

Your Task:

\n\n

You don't need to read input or print anything. Your task is to complete the function previousNumber() which takes the string S and returns the previous number of S. If no such number exists return -1;

\n\n

 

\n\n

Expected Time Complexity: O(N)
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n2<=|Number length |<=105

\n\n

 

\n

\n " }, { "path": "Previous number in one swap - GFG/previous-number-in-one-swap.py", "content": "#User function Template for python3\nclass Solution:\n def previousNumber (ob,S):\n i=len(S)-2\n while i>=0 and S[i]<=S[i+1]:\n i-=1\n if i<0:\n return '-1'\n j=len(S)-1\n while j>i and S[i]<=S[j]:\n j-=1\n while j>0 and S[j-1]==S[j]:\n j-=1\n S=list(S)\n S[i],S[j]=S[j],S[i]\n if S[0]=='0':\n return '-1';\n return ''.join(S)\n \n \n\n#{ \n# Driver Code Starts\n#Initial Template for Python 3\nif __name__ == '__main__': \n t = int (input ())\n for _ in range (t):\n \n S=str(input())\n\n ob = Solution()\n print(ob.previousNumber(S))\n# } Driver Code Ends" }, { "path": "Prim's_Algorithm.cpp", "content": "#include\nusing namespace std;\nint main(){\n int m,n;\n cin>>m>>n;\n vector> adj[m];\n for(int i =0;i>x>>y>>w;\n adj[x].push_back({y,w});\n adj[y].push_back({x,w});\n }\n\n vector key(m,INT_MAX),parent(m,-1),mst(m,false);\n key[0]=0;\n parent[0]=-1;\n\n for(int i =0;i \"< primesum(int A) {\n ArrayList al=new ArrayList<>();\n boolean a[]=prime(A);\n for(int i=2;i<=A;i++){\n if(a[i]==false && a[A-i]==false){\n al.add(i);\n al.add(A-i);\n break;\n } \n }\n return al;\n }\n}\n" }, { "path": "Print Diagonally - GFG/README.md", "content": "# Print Diagonally\n## Easy\n

Give a N * N square matrix A, return all the elements of its anti-diagonals from top to bottom.

\n\n

Example 1:

\n\n
Input: \nN = 2\nA = [[1, 2],\n     [3, 4]]\nOutput:\n1 2 3 4\nExplanation: \n\"\"\nHence, elements will be returned in the \norder {1, 2, 3, 4}.\n
\n\n

Example 2:

\n\n
Input: \nN = 3 \nA = [[1, 2, 3],\n     [4, 5, 6],\n     [7, 8, 9]]\nOutput: \n1 2 4 3 5 7 6 8 9\nExplanation: \n\"\"\nHence, elements will be returned in \nthe order {1, 2, 4, 3, 5, 7, 6, 8, 9}.\n\n
\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function downwardDigonal() which takes an integer N and a 2D matrix A[ ][ ] as input parameters and returns the list of all elements of its anti-diagonals from top to bottom.

\n\n

Expected Time Complexity: O(N*N)
\nExpected Auxillary Space: O(N*N)

\n\n

Constraints:
\n1 ≤ N, M ≤ 103
\n0 ≤ A[i][j] ≤ 106

\n
" }, { "path": "Print Diagonally - GFG/print-diagonally.java", "content": "//{ Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n int n = sc.nextInt();\n \n int matrix[][] = new int[n][n];\n \n for(int i = 0; i < n; i++)\n {\n for(int j = 0; j < n; j++)\n matrix[i][j] = sc.nextInt();\n }\n Solution ob = new Solution();\n ArrayList ans = ob.downwardDigonal(n, matrix);\n for (Integer val: ans) \n System.out.print(val+\" \"); \n System.out.println();\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static ArrayList downwardDigonal(int N, int A[][])\n {\n // code here \n ArrayList ans=new ArrayList<>();\n int row=0;\n int col=0;\n while(col=0){\n ans.add(A[r][c]);\n r++;\n c--;\n }\n col++;\n }\n col=N-1;\n row=1;\n while(row=0){\n ans.add(A[r][c]);\n r++;\n c--;\n }\n row++;\n }\n return ans;\n }\n}\n" }, { "path": "Print Pattern using String.java", "content": "class Solution{\n static List pattern(int n){\n // code here\n List r=new ArrayList<>();\n int first=1;\n int end=n*(n+1);\n int spaces=0;\n for(int i=0;i\nusing namespace std;\nclass Solution{\n public:\n vector pattern(int n){\n // code here\n vector res;\n int cnt=1;\n for(int i=0;i=0;i--){\n string t=\"\";\n for(int j=n-1;j>=i;j--){\n t+= to_string(cnt++)+\"*\";\n }\n t.pop_back();\n res[i]+= t;\n }\n \n return res;\n }\n};\n\n\n// 2.\nclass Solution{\npublic:\n vector pattern(int n){\n // code here\n vector v;\n int curr=n, next=n*n+1;\n for(int i=0;i pattern(int n){\n // code here\n int num=1;\n List ans=new ArrayList<>();\n for(int row=0;row=0;row--){\n StringBuilder sb=new StringBuilder(ans.get(row));\n for(int times=0;times\n

Given an NxN chessboard and a Knight at position (x, y). The Knight has to take exactly K steps, where at each step it chooses any of the 8 directions uniformly at random. Find the probability that the Knight remains in the chessboard after taking K steps, with the condition that it cant enter the board again once it leaves it.
\n 

\n\n

Example 1:

\n\n
Input : N = 8, x = 0, y = 0, K = 3\nOutput: 0.125000\n
\n\n

Example 2:

\n\n
Input: N = 4, x = 1, y = 2, k = 4\nOutput: 0.024414\n
\n\n

 

\n\n

Your Task: 
\nYou don't need to read or print anything. Your task is to complete the function findProb() which takes N, x, y and K as input parameter and returns the probability.
\n 

\n\n

Expected Time Complexity : O(N 3)
\nExpected Space Complexity: O(N3)
\n 

\n\n

Constraints:
\n1 <= N <= 100
\n0 <= x, y <= N

\n\n

0 <= K <= N

\n

\n " }, { "path": "Probability of Knight - GFG/probability-of-knight.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String s = br.readLine().trim();\n String []S = s.split(\" \");\n int N = Integer.parseInt(S[0]);\n int start_x = Integer.parseInt(S[1]);\n int start_y = Integer.parseInt(S[2]);\n int step = Integer.parseInt(S[3]);\n Solution ob = new Solution();\n double ans = ob.findProb(N, start_x, start_y, step);\n System.out.println(String.format(\"%.6f\", ans)); \n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n// code starts\n\nclass Solution\n{\n public static boolean isValid(int ni, int nj, int n){\n \n if(ni>=0 && nj>=0 && ni\n

Given two numbers L and R (inclusive) find the product of primes within this range. Print the product modulo 109+7. If there are no primes in that range you must print 1.

\n\n

Example 1:

\n\n
Input: L = 1, R = 10\nOutput: 210\nExplaination: The prime numbers are \n2, 3, 5 and 7.
\n\n

Example 2:

\n\n
Input: L = 1, R = 20\nOutput: 9699690\nExplaination: The primes are 2, 3, \n5, 7, 11, 13, 17 and 19.
\n\n

Your Task:
\nYou do not need to read input or print anything. Your task is to complete the function primeProduct() which takes L and R and returns the product of the primes within the range. If there are no primes in that range then return 1.

\n\n

Expected Time Complexity: O((R-L)*(logR))
\nExpected Auxiliary Space: O(sqrt(R))

\n\n

Constraints:
\n1 ≤ L ≤ R ≤ 109
\n0 ≤ L - R ≤ 106  

\n

\n " }, { "path": "Product of Primes - GFG/product-of-primes.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n long L = Long.parseLong(a[0]);\n long R = Long.parseLong(a[1]);\n \n Solution ob = new Solution();\n System.out.println(ob.primeProduct(L, R));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static int mod=1000000007;\n static long primeProduct(long L, long R){\n // code here\n long ans=1;\n for(long i=L;i<=R;i++){\n if(isPrime(i)){\n ans=(ans%mod*i)%mod;\n }\n }\n return ans;\n }\n static boolean isPrime(long n){\n if(n<=1)\n return false;\n if(n==2)\n return true;\n for(long i=2;i<=Math.sqrt(n);i++){\n if(n%i==0)\n return false;\n }\n return true;\n }\n}" }, { "path": "Profit Maximisation.java", "content": "public class Solution {\n public int solve(int[] A, int B) {\n PriorityQueue pq=new PriorityQueue<>(Collections.reverseOrder());\n for(int i:A){\n pq.add(i);\n }\n int ans=0;\n while(B>0){\n int val=pq.remove();\n ans+=val;\n val--;\n pq.add(val);\n B--;\n }\n return ans;\n }\n}\n" }, { "path": "Pythagorean Triplets.java", "content": "public class Solution {\n public int solve(int n) {\n int ans=0;\n for(int i=3;i<=n-2;i++){\n for(int j=i+1;j<=n-1;j++){\n for(int k=j+1;k<=n;k++){\n if(isTriplet(i,j,k))ans++;\n }\n }\n }\n return ans;\n }\n\n public boolean isTriplet(int a,int b,int c){\n return (a*a)+(b*b)==c*c;\n }\n}\n" }, { "path": "Queries on Strings - GFG/README.md", "content": "# Queries on Strings\n## Medium \n
\n

Given a string str you have to answer several queries on that string. In each query you will be provided two values L and R and you have to find the number of distinct characters in the sub string from index L to index R (inclusive) of the original string.
\n 

\n\n

Example 1:

\n\n
Input: str = \"abcbaed\",\nQuery = {{1,4},{2,4},{1,7}}\nOutput: {3,2,5}\nExplanation: For the first query distinct \ncharacters from [1, 4] are a, b and c.\nFor the second query distinct characters from\n[2, 4] are b and c.\nFor the third query distinct characters from\n[1, 7] are a, b, c, d and e.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anyhting. Your task is to complete the function SolveQueries() which takes str and Query as input parameter and returns a list containing answer for each query.
\n 

\n\n

Expected Time Complexity: O(max(26*length of str, 26 * No of queries))
\nExpected Space Complexity: O(26 * length of str)
\n 

\n\n

Constraints:
\n1 <= |str| <= 105
\n1 <= No of Queries <= 104
\n1 <= Li <= Ri <= |str|

\n

\n
" }, { "path": "Queries on Strings - GFG/queries-on-strings.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String str = br.readLine().trim();\n int q = Integer.parseInt(br.readLine().trim());\n int[][] Query = new int[q][2];\n for(int i = 0; i < q; i++){\n String[] s = br.readLine().trim().split(\" \");\n for(int j = 0; j < 2; j++){\n Query[i][j] = Integer.parseInt(s[j]);\n }\n }\n Solution obj = new Solution();\n int[] ans = obj.SolveQueris(str, Query);\n for(int i = 0; i < ans.length; i++)\n System.out.print(ans[i] + \" \");\n System.out.println();\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n public int[] SolveQueris(String str, int[][] Query)\n {\n Set set = new HashSet<>();\n int a[]= new int[Query.length];\n for(int i=0;i s1 = new Stack();\n Stack s2 = new Stack();\n\n //Function to push an element in queue by using 2 stacks.\n void Push(int x)\n {\n\t // Your code here\n\t s1.push(x);\n }\n\t\n \n //Function to pop an element from queue by using 2 stacks.\n int Pop()\n {\n\t // Your code here\n\t while(s1.size()>0){\n\t s2.push(s1.pop());\n\t }\n\t int num=-1;\n\t if(s2.size()>0){\n\t num=s2.pop();\n\t }\n\t while(s2.size()>0){\n\t s1.push(s2.pop());\n\t }\n\t return num;\n }\n}\n" }, { "path": "QuickSort on Doubly Linked List.java", "content": "class GfG\n{\n public static Node partition(Node l, Node h)\n {\n //code here.\n Node pivot=l;\n Node left=l;\n Node right=h;\n boolean flag=false;\n while(!flag){ \n while(left!=null && left.data<=pivot.data){\n if(left==right)flag=true;\n left=left.next;\n }\n while(right!=null && right.data>pivot.data){\n if(right==left)flag=true;\n right=right.prev;\n }\n if(!flag)swap(left,right);\n }\n swap(pivot,right);\n return right;\n }\n static void swap(Node a,Node b){\n int temp=a.data;\n a.data=b.data;\n b.data=temp;\n }\n}\n" }, { "path": "README.md", "content": "# DSA\n> Building the largest DSA solutions repository TOGETHER.\n\n# Note:\n> All DsA repositories are excluded from Hacktoberfest\n\n# Beginner's Guide\n\n\n---\n# 🔥Find your solution\n- Press \"T\" in windows/mac/linux to open the file finder.\n- Enter your problem name. We support only following naming formats to find files! Note: We are slowly migrating to normal word spacing format for new files, see [Contributing.md](https://github.com/Sagar0-0/DsA/blob/main/CONTRIBUTING.md).\n - ### Old questions finding\n - PascalCase (ThisIsTheExampleOfPascalCaseWritingWriting)\n - Snake case (this_is_the_example_of_snake_case_writing)\n - Caterpillar case (this-is-the-example-of-catarpillar-case-writing)\n - Normal (A question name with proper words and spacings)\n - Most of Leetcode Questions also have question numbers. Eg. 1007-minimum-domino-rotations-f...\n - ### New questions finding\n - Normal (A question name with proper words and spacings)\n - Proper structure with folders/directories according to coding platforms.\n- If exists, select your solution file according to your programming language.\n- If your problem's solution doesn't exist\n - Either create an new [Issue](https://github.com/Sagar0-0/DsA/issues) and request public to solve it for you.(Coming soon...)\n - Or [Contribute](https://github.com/Sagar0-0/DsA/pulls) it by yourself🔥\n\n---\n\n# ✅Open To Contribute \n- Start your open source journey with us🚀\n- Share your code with the world✨\n- Become an active member🔥\n- Contribute and get Appreciated🤝\n- Must read [CONTRIBUTING.md](https://github.com/Sagar0-0/DsA/blob/main/CONTRIBUTING.md) before contributing.\n\n> *No more DSA contributions from my side.*\n---\n\n# ➡️Platforms covered:\n\n\n\n\n
\n
\n
\n\n\n\n\n\n
\n
\n
\n\n\n\n\n\n
\n
\n
\n\n---\n\n# ✅Contributors\n> Thanks to these amazing contributors who helps us in building the LARGEST DSA SOLUTIONS REPOSITORY\n\n\n \n\n\n---\n\n## Love my work?\n\n\n\n\n\n# ☕My Coding Profiles:\n\n\n\n\n
\n
\n\n\n\n\n\n
\n
\n\n\n\n\n" }, { "path": "Rank The Permutations - GFG/README.md", "content": "# Rank The Permutations\n## Medium \n
\n

Given a string, find the rank of the string amongst its permutations sorted lexicographically. 
\n
\nExample 1:

\n\n
Input:\nS = \"abc\"\nOutput:\n1\nExplanation:\nThe order permutations with letters \n'a', 'c', and 'b' : \nabc\nacb\nbac\nbca\ncab\ncba
\n\n

Example 2:

\n\n
Input:\nS = \"acb\"\nOutput:\n2\n
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function findRank() which takes the string S as input parameter and returns the rank of the string amongst its permutations.
\nIt is guaranteed no characters are repeated in the string.

\n\n


\nExpected Time Complexity: O(|S|*26)
\nExpected Auxiliary Space: O(|S|)
\nNote: |S| represents the length of string S.

\n\n


\nConstraints:
\n1 ≤ |S| ≤ 18

\n

\n
" }, { "path": "Rank The Permutations - GFG/rank-the-permutations.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String str = br.readLine().trim();\n Solution obj = new Solution();\n long ans = obj.findRank(str);\n System.out.println(ans);\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n public long findRank(String s){\n // Code here\n if(s.length()==0){\n return 0;\n }\n long res=1;\n for(int i=0; i s.charAt(j)){\n cou++;\n }\n }\n res += cou * fact(s.length()-1-i);\n }\n return res;\n }\n long fact(int n){\n if(n<=1){\n return 1;\n }\n return n * fact(n-1);\n }\n}" }, { "path": "Rat Maze With Multiple Jumps - GFG/README.md", "content": "# Rat Maze With Multiple Jumps\n## Medium \n
\n

A Maze is given as n*n matrix of blocks where source block is the upper left most block i.e., matrix[0][0] and destination block is lower rightmost block i.e., matrix[n-1][n-1]. A rat starts from source and has to reach the destination. The rat can move in only two directions: first forward if possible or down. If multiple solutions exist, the shortest earliest hop will be accepted. For the same hop distance at any point, forward will be preferred over downward. In the maze matrix, 0 means the block is the dead end and non-zero number means the block can be used in the path from source to destination. The non-zero value of mat[i][j] indicates number of maximum jumps rat can make from cell mat[i][j]. In this variation, Rat is allowed to jump multiple steps at a time instead of 1. Find a matrix which describes the position the rat to reach at the destination.
\n 

\n\n

Example:

\n\n
Input: {{2,1,0,0},{3,0,0,1},{0,1,0,1},\n{0,0,0,1}}\nOutput: {{1,0,0,0},{1,0,0,1},{0,0,0,1},\n{0,0,0,1}}\nExplanation: Rat started with matrix[0][0] and \ncan jump up to 2 steps right/down. First check \nmatrix[0][1] as it is 1, next check \nmatrix[0][2] ,this won't lead to the solution. \nThen check matrix[1][0], as this is 3(non-zero)\n,so we can make 3 jumps to reach matrix[1][3]. \nFrom matrix[1][3] we can move downwards taking \n1 jump each time to reach destination at \nmatrix[3][3].\n
\n\n

Example 2:

\n\n
Input: {{2,1,0,0},{2,0,0,1},{0,1,0,1},\n{0,0,0,1}}\nOutput: {{-1}}\nExplanation: As no path exists so, -1.\n
\n\n

 

\n\n

Your Task:
\nYou don't need to read or print anyhting, Your task is to complete the function ShortestDistance() which takes the matrix as input parameter and returns a matrix of size n if path exists otherwise returns a matrix of 1x1 which contains -1. In output matrix, 1 at (i, j) represents the cell is taken into the path otherwise 0 if any path exists.
\n 

\n\n

Expected Time Complexity: O(n*n*k) where k is max(matrix[i][j])
\nExpected Space Complexity: O(1)
\n 

\n\n

Constraints:
\n1 <= n <= 50
\n1 <= matrix[i][j] <= 20

\n

\n
" }, { "path": "Rat Maze With Multiple Jumps - GFG/rat-maze-with-multiple-jumps.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n int[][] matrix = new int[n][n];\n for(int i = 0; i < n; i++){\n String[] S = br.readLine().trim().split(\" \");\n for(int j = 0; j < n; j++)\n matrix[i][j] = Integer.parseInt(S[j]);\n }\n Solution ob = new Solution();\n int[][] ans = ob.ShortestDistance(matrix);\n for(int i = 0; i < ans.length; i++){\n for(int j = 0; j < ans[i].length; j++){\n System.out.print(ans[i][j] + \" \");\n }\n System.out.println();\n }\n }\n }\n}\n// } Driver Code Ends\n\n\nclass Solution\n{\n public int[][] ShortestDistance(int[][] matrix){\n // Code here\n int m= matrix.length;\n int n= matrix[0].length;\n \n if(matrix[0][0]==0 && n!=1){\n\t int ans[][]={{-1}};\n return ans;\n\t }\n\t int ans[][] = new int[m][n];\n if(solver(matrix, ans,0,0)==false){\n ans[0][0]=-1;\n return ans;\n }\n return ans;\n }\n \n public boolean solver(int[][] matrix,int[][] ans,int i,int j){\n if(i==matrix.length-1 && j==matrix[0].length-1){\n ans[i][j]=1;\n return true;\n }\n if(isValid(i,j,matrix)){\n ans[i][j] = 1;\n for(int k=1;k<=matrix[i][j] && k=matrix.length || y>=matrix[0].length||matrix[x][y]==0){\n return false;\n }\n return true;\n }\n}" }, { "path": "Reaching the heights - GFG/README.md", "content": "# Reaching the heights\n## Medium \n
\n

The teacher gives a mental ability question to Raju. The question is as follows:-

\n\n

Raju is in an elevator. Given by his teacher is an array of size N which denotes the number of floors and has a 1 based indexing. The elevator starts from the ground and moves up and down, X and Y floors respectively. There is a code used in the elevator according to which it moves up X floors given at odd indexes of the array and moves down Y floors given at even indexes of the array. He is asked to go to the highest floor possible. Help him to sort the array such that he reaches the highest floor after traversing the whole array from starting till the end, without skipping any index.

\n\n

He always prefers to move more number of floors up and less number of floors down. Once he gets into the elevator, the elevator should not reach the ground again, if it does print Not Possible.

\n\n

Example 1:

\n\n
Input : arr[ ] = {2, 3, 4, 5}\nOutput : 5 2 4 3\nExplanation:\nArray can be arranged as {5,3,4,2} or \n{4,3,5,2} or {4,2,5,3} but it will get \narranged as {5,2,4,3} because he always \nprefer to move more number of floors up \nand less number of floors down.\n
\n\n


\nExample 2:

\n\n
Input : arr[ ] = {1, 1} \nOutput :  Not Possible
\n\n

 

\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function game_with_number() that takes sizeOfArray (n), an array (arr), and return the sorted array or if it is Not Possible return -1. The driver code takes care of the printing.

\n\n

Expected Time Complexity: O(N*LOG(N)).
\nExpected Auxiliary Space: O(1).

\n\n

 

\n\n


\nConstraints:

\n\n

1 ≤ N ≤ 105
\n1 ≤ arr[i] ≤ 103

\n

\n
" }, { "path": "Reaching the heights - GFG/reaching-the-heights.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t String line = br.readLine();\n\t\t String[] element = line.trim().split(\"\\\\s+\");\n\t\t int N = Integer.parseInt(element[0]);\n\t\t int arr [] = new int[N];\n\t\t line = br.readLine();\n\t\t String[] elements = line.trim().split(\"\\\\s+\");\n\t\t for(int i = 0;i ans;\n\t\t ans = obj.reaching_height(N, arr);\n \t\n \tif(ans.size() == 1 && ans.get(0) == -1){\n \t System.out.println(\"Not Possible\");\n \t continue;\n \t}\n \t\n \tfor(int i: ans)\n \t System.out.print(i + \" \");\n \tSystem.out.println();\n\t\t}\n\t}\n}\n\n\n\n\n\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n//2 4 10\n//10 2 4\n\n\n\nclass Complete{\n \n \n // Function for finding maximum and value pair\n public static ArrayList reaching_height (int n, int arr[]) {\n //Complete the function\n ArrayList ans=new ArrayList<>();\n Arrays.sort(arr);\n int flag=0;\n \n int end=arr.length-1;\n int start=0;\n while(end>=start){\n ans.add(arr[end]);\n flag+=arr[end];\n if(end!=start){\n ans.add(arr[start]);\n flag-=arr[start];\n }\n end--;\n start++;\n }\n if(flag==0){\n ans.clear();\n ans.add(-1);\n }\n \n return ans;\n }\n \n \n}\n" }, { "path": "Rearrange Geek and his Classmates.java", "content": "class Solution \n{ \n void prank(long[] a, int n) \n { \n for(int i=0;i\n

Given a string s, remove all its adjacent duplicate characters recursively. 

\n\n

Example 1:

\n\n
Input:\nS = \"geeksforgeek\"\nOutput: \"gksforgk\"\nExplanation: \ng(ee)ksforg(ee)k -> gksforgk
\n\n


\nExample 2:

\n\n
Input: \nS = \"abccbccba\"\nOutput: \"\"\nExplanation: \nab(cc)b(cc)ba->abbba->a(bbb)a->aa->(aa)->\"\"(empty string)
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function remove() which takes the string S as input parameter and returns the resultant string.
\nNote: For some test cases, the resultant string would be an empty string. For that case, the function should return the empty string only.

\n\n


\nExpected Time Complexity: O(|S|)
\nExpected Auxiliary Space: O(|S|)

\n\n


\nConstraints:
\n1<=|S|<=105

\n

\n " }, { "path": "Recursively remove all adjacent duplicates - GFG/recursively-remove-all-adjacent-duplicates.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main (String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine().trim()); //Inputting the testcases\n while(t-->0){\n String S = br.readLine();\n Solution ob = new Solution();\n System.out.println(ob.remove(S));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n String remove(String s) {\n if(s.length()<=1) return s;\n StringBuilder str = new StringBuilder();\n for(int i =0;i stack=new ArrayDeque<>();\n int n=s.length();\n for(int i=0;i0){\n char ch=stack.pop();\n if(ch=='(')break;\n if(ch=='+' || ch=='-' || ch=='*' || ch=='/'){\n count++;\n }\n }\n if(count==0)return 1;\n }\n }\n return 0;\n }\n}\n" }, { "path": "Region in BinaryMatrix.java", "content": "public class Solution {\n int[][]arr;\n boolean[][]vis;\n public int solve(int[][] A) {\n arr=A;\n int n=A.length;\n int m=A[0].length;\n vis=new boolean[n][m];\n int ans=0;\n for(int i=0;iB)\n res += A.charAt(A.length()-1);\n return res; \n }\n}\n" }, { "path": "Remove Covered Intervals.java", "content": "class Solution {\n public int removeCoveredIntervals(int[][] nums) {\n Arrays.sort(nums, new Comparator() {\n public int compare(int[] o1, int[] o2){\n if(o1[0]==o2[0])return o2[1]-o1[1];\n return o1[0]-o2[0];\n }});\n int count = 0, cur = 0;\n for(int interval[] : nums){\n if(cur < interval[1]){\n cur = interval[1];\n count++;\n }\n }\n return count;\n }\n}\n" }, { "path": "Remove Duplicates from Sorted Array II.java", "content": "class Solution {\n public int removeDuplicates(int[] nums) {\n int count=1;\n int i=0;\n int j=1;\n while(j a) {\n int extras=0;\n int i=0;\n int x=0;\n while(i1){\n a.set(x,a.get(i));\n x++;\n a.set(x,a.get(i));\n x++;\n i=j;\n extras+=cnt-2;\n }else{\n a.set(x,a.get(i));\n x++;\n i=j;\n }\n }\n return a.size()-extras;\n\t}\n}\n" }, { "path": "Remove Duplicates from Sorted List II.java", "content": "class Solution {\n public ListNode deleteDuplicates(ListNode head) {\n // sentinel\n ListNode sentinel = new ListNode(0, head);\n\n // predecessor = the last node \n // before the sublist of duplicates\n ListNode pred = sentinel;\n \n while (head != null) {\n if (head.next != null && head.val == head.next.val) {\n while (head.next != null && head.val == head.next.val) {\n head = head.next; \n }\n pred.next = head.next; \n } else {\n pred = pred.next; \n }\n head = head.next; \n } \n return sentinel.next;\n }\n}\n" }, { "path": "Remove Duplicates from Sorted List.java", "content": "public class Solution {\n public ListNode deleteDuplicates(ListNode A) {\n ListNode temp=A;\n while(temp.next!=null){\n if(temp.val==temp.next.val){\n temp.next=temp.next.next;\n }else{\n temp=temp.next;\n }\n }\n return A;\n }\n}\n" }, { "path": "Remove Half Nodes.java", "content": "public class Solution {\n public TreeNode solve(TreeNode A) {\n if(A==null)return A;\n if(A.left!=null && A.right!=null){\n A.left=solve(A.left);\n A.right=solve(A.right);\n }else if(A.left!=null){\n A=solve(A.left);\n }else if(A.right!=null){\n A=solve(A.right);\n }\n return A;\n }\n}\n" }, { "path": "Remove K Digits.java", "content": "class Solution {\n public String removeKdigits(String num, int k) {\n Deque stack = new ArrayDeque<>();\n for(char c : num.toCharArray()){\n while(!stack.isEmpty() && k > 0 && stack.peek() > c) {\n stack.pop();\n k--;\n } \n stack.push(c); \n }\n while(!stack.isEmpty() && k > 0){\n stack.pop();\n k--;\n }\n StringBuilder sb = new StringBuilder();\n while(!stack.isEmpty()){\n sb.append(stack.pop());\n }\n sb.reverse();\n while(sb.length() > 1 && sb.charAt(0) == '0'){\n sb.deleteCharAt(0);\n }\n return sb.length() > 0 ? sb.toString() : \"0\";\n }\n}\n" }, { "path": "Remove Nth Node from List End.java", "content": "public class Solution {\n public ListNode removeNthFromEnd(ListNode A, int B) {\n int size=0;\n ListNode temp=A;\n while(temp!=null){\n size++;\n temp=temp.next;\n }\n if(B>=size)return A.next;\n int toGo=size-B;\n temp=A;\n for(int i=1;i map=new HasMap<>();\n for(char c:S.toCharArray())map.put(c,map.getOrDefault(c,0)+1);\n \n for(int i=0;i1)return c;\n }\n return '#';\n \n }\n}\n\n//O(n)\n//O(1)\nclass Solution\n{\n char firstRep(String S)\n {\n \n for(int i=0;i

Given an array arr[] of N integers and replace every element with the least greater element on its right side in the array. If there are no greater elements on the right side, replace it with -1. 

\n\n

Example 1:

\n\n
Input:\narr[] = {8, 58, 71, 18, 31, 32, 63, 92, 43, 3, 91, 93, 25, 80, 28}\nOutput: {18, 63, 80, 25, 32, 43, 80, 93, 80, 25, 93, -1, 28, -1, -1}\nExplanation: \nThe least next greater element of 8 is 18.\nThe least next greater element of 58 is 63 and so on.\n\n
\n\n

Example 2:

\n\n
Input:\narr[] = {2, 6, 9, 1, 3, 2}\nOutput: {3, 9, -1, 2, -1, -1}\nExplanation: \nThe least next greater element of 2 is 3. \nThe least next greater element of 6 is 9.\nleast next greater element for 9 does not\nexist and so on.\n\n
\n\n

Your Task:  
\nYou don't need to read input or print anything. Your task is to complete the function findLeastGreater() which takes an array arr[] of size N and returns a list as an output.

\n\n

Expected Time Complexity: O(N* log N)
\nExpected Auxiliary Space: O(N)

\n\n

Constraints:
\n1 <= N <= 105
\n1 <= A[i] <= 105

\n" }, { "path": "Replace every element with the least greater element on its right - GFG/replace-every-element-with-the-least-greater-element-on-its-right.java", "content": "//{ Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\n\nclass IntArray\n{\n public static int[] input(BufferedReader br, int n) throws IOException\n {\n String[] s = br.readLine().trim().split(\" \");\n int[] a = new int[n];\n for(int i = 0; i < n; i++)\n a[i] = Integer.parseInt(s[i]);\n \n return a;\n }\n \n public static void print(int[] a)\n {\n for(int e : a)\n System.out.print(e + \" \");\n System.out.println();\n }\n \n public static void print(ArrayList a)\n {\n for(int e : a)\n System.out.print(e + \" \");\n System.out.println();\n }\n}\n\nclass GFG {\n public static void main(String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t;\n t = Integer.parseInt(br.readLine());\n while(t-- > 0){\n \n int n; \n n = Integer.parseInt(br.readLine());\n \n \n int[] arr = IntArray.input(br, n);\n \n Solution obj = new Solution();\n ArrayList res = obj.findLeastGreater(n, arr);\n \n IntArray.print(res);\n \n }\n }\n}\n\n// } Driver Code Ends\n\n\nclass Solution {\n public static ArrayList findLeastGreater(int n, int[] arr) {\n // code here\n TreeSet set=new TreeSet<>();\n ArrayList ans =new ArrayList<>();\n for(int i=n-1;i>=0;i--){\n set.add(arr[i]);\n if(set.higher(arr[i])==null)ans.add(-1);\n else ans.add(set.higher(arr[i]));\n }\n Collections.reverse(ans);\n return ans;\n }\n}\n \n" }, { "path": "Return two prime numbers.java", "content": "class Solution{\n static Set set=new HashSet<>();\n \n static List primeDivision(int n){\n // code here\n List ans=new ArrayList<>();\n for(int i=2;i> 1\n return ans\n" }, { "path": "Reverse First K elements of Queue", "content": "public Queue modifyQueue(Queue q, int k) {\n // using a stack and another queue to reverse first k elements.\n Stack s = new Stack<>();\n Queue qq = new LinkedList<>();\n\n // we pop first k elements from queue and push it in the stack.\n while (k-- > 0) {\n int a = q.peek();\n q.poll();\n s.push(a);\n }\n // while stack is not empty, we push the elements into the new queue.\n while (!s.isEmpty()) {\n int a = s.peek();\n s.pop();\n qq.add(a);\n }\n // then we add rest of the elements of original queue to the new queue.\n while (!q.isEmpty()) {\n int a = q.peek();\n q.poll();\n qq.add(a);\n }\n // returning the new queue.\n return qq;\n }\n" }, { "path": "Reverse Level Order.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\n import java.util.*;\npublic class Solution {\n public ArrayList solve(TreeNode node) {\n ArrayList list=new ArrayList<>();\n Stack S = new Stack();\n Queue Q = new LinkedList();\n Q.add(node);\n \n // Do something like normal level order traversal order.Following\n // are the differences with normal level order traversal\n // 1) Instead of printing a node, we push the node to stack\n // 2) Right subtree is visited before left subtree\n while (Q.isEmpty() == false)\n {\n /* Dequeue node and make it root */\n node = Q.peek();\n Q.remove();\n S.push(node);\n \n /* Enqueue right child */\n if (node.right != null)\n // NOTE: RIGHT CHILD IS ENQUEUED BEFORE LEFT\n Q.add(node.right);\n \n /* Enqueue left child */\n if (node.left != null)\n Q.add(node.left);\n }\n \n // Now pop all items from stack one by one and print them\n while (S.empty() == false)\n {\n node = S.peek();\n System.out.print(node.val + \" \");\n S.pop();\n }\n return list;\n }\n}\n\n\n" }, { "path": "Reverse Spiral Form of Matrix - GFG/README.md", "content": "# Reverse Spiral Form of Matrix\n## Medium\n

Given a matrix as 2D array. Find the reverse spiral traversal of the matrix. 
\n
\nExample 1:

\n\n
Input: R = 3, C = 3\n  a = {{9, 8, 7},\n       {6, 5, 4},\n       {3, 2, 1}}\nOutput: 5 6 3 2 1 4 7 8 9\nExplanation: Spiral form of the matrix\nin reverse order starts from the centre \nand goes outward.\n\"\"\n\n
\n\n

Example 2:

\n\n
Input: R = 4, C = 4 \n  a = {{1, 2, 3, 4},\n       {5, 6, 7, 8},\n       {9, 10, 11, 12}, \n       {13, 14, 15, 16}}\nOutput: 10 11 7 6 5 9 13 14 15 16 12 8 4 3 2 1\nExplanation: \n\"\"\n
\n\n


\nYour Task:  
\nYou dont need to read input or print anything. Complete the function reverseSpiral() which takes R, C and a as input parameters and returns the matrix in reverse spiral form.
\n
\nExpected Time Complexity: O(R*C)
\nExpected Auxiliary Space: O(R*C)
\n
\nConstraints:
\n1 <= R,C <=100
\n1 <= a[R][C] <=100

\n
" }, { "path": "Reverse Spiral Form of Matrix - GFG/reverse-spiral-form-of-matrix.java", "content": "//{ Driver Code Starts\n//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String[] input = new String[2]; \n input = read.readLine().split(\" \"); \n int R = Integer.parseInt(input[0]); \n int C = Integer.parseInt(input[1]); \n String s1[] = read.readLine().trim().split(\"\\\\s+\");\n int a[][] = new int[R][C];\n for(int i = 0;i < R*C;i++)\n a[i/C][i%C] = Integer.parseInt(s1[i]);\n Solution ob = new Solution();\n int[] ans = ob.reverseSpiral(R,C,a);\n for(int i = 0; i < ans.length; i++)\n {\n System.out.print(ans[i] + \" \");\n }\n System.out.println();\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\nclass Solution\n{\n public int[] reverseSpiral(int R, int C, int[][] a)\n {\n // code here\n int[] ans=new int[R*C];\n int idx=R*C-1;\n \n int up=0;\n int down=a.length-1;\n int left=0;\n int right=a[0].length-1;\n \n \n \n while(idx>=0){\n //upper row\n for(int i=left;i<=right && idx>=0;i++){\n ans[idx--]=a[up][i];\n }\n up++;\n \n //last col\n for(int i=up;i<=down && idx>=0;i++){\n ans[idx--]=a[i][right];\n }\n right--;\n \n //lower row\n for(int i=right;i>=left && idx>=0;i--){\n ans[idx--]=a[down][i];\n }\n down--;\n \n for(int i=down;i>=up && idx>=0;i--){\n ans[idx--]=a[i][left];\n }\n left++;\n }\n \n return ans;\n \n }\n}" }, { "path": "Reverse a Stack using Recursion.cpp", "content": "class Solution\n{\n \n void insertAtBottom(stack &s,int &x)\n {\n if(s.empty())\n {\n s.push(x);\n return;\n }\n \n int num = s.top();\n s.pop();\n \n insertAtBottom(s,x);\n s.push(num);\n }\n \n void solve(stack &st)\n {\n if(st.empty()) return;\n \n int x = st.top();\n st.pop();\n \n solve(st);\n \n insertAtBottom(st,x);\n }\n\n public:\n stack Reverse(stack st)\n {\n solve(st);\n return st;\n }\n};\n" }, { "path": "Reverse a string using Stack.java", "content": "class Solution {\n \n public String reverse(String S){\n //code here\n Deque s=new ArrayDeque<>();\n for(char c:S.toCharArray()){\n s.push(c);\n }\n S=\"\";\n while(!s.isEmpty()){\n S+=s.pop()+\"\";\n }\n return S;\n }\n}\n" }, { "path": "Reverse a sublist of a linked list - GFG/README.md", "content": "# Reverse a sublist of a linked list\n## Hard \n
\n

Given a linked list and positions m and n. Reverse the linked list from position m to n.

\n\n

Example 1:

\n\n
Input :\nN = 10\nLinked List = 1->7->5->3->9->8->10\n                      ->2->2->5->NULL\nm = 1, n = 8\nOutput : 2 10 8 9 3 5 7 1 2 5 \nExplanation :\nThe nodes from position 1 to 8 \nare reversed, resulting in \n2 10 8 9 3 5 7 1 2 5.\n\n
\n\n

Example 2:

\n\n
Input:\nN = 6\nLinked List = 1->2->3->4->5->6->NULL\nm = 2, n = 4\nOutput: 1 4 3 2 5 6\nExplanation:\nNodes from position 2 to 4 \nare reversed resulting in\n1 4 3 2 5 6.
\n\n
Your task :
\n\n
You don't need to read input or print anything. Your task is to complete the function reverseBetween() which takes the head of the linked list and two integers m and n as input and returns the head of the new linked list after reversing the nodes from position m to n.
\n\n
 
\n\n
Expected Time Complexity: O(N)
\n\n
Expected Auxiliary Space: O(1)
\n\n
 
\n\n
Constraints:
\n\n
1<=N<=10^5
\n

\n
" }, { "path": "Reverse a sublist of a linked list - GFG/reverse-a-sublist-of-a-linked-list.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\nclass Node\n {\n int data;\n Node next;\n Node(int d) {data = d; next = null; }\n }\nclass insertion\n{\n Node head; \n Node tail;\n\tpublic void addToTheLast(Node node) \n\t{\n\t if (head == null) \n\t {\n\t head = node;\n\t tail = node;\n\t } \n\t else \n\t {\n\t tail.next = node;\n\t tail = node;\n\t }\n\t}\n void printList(Node head)\n {\n Node temp = head;\n while (temp != null)\n {\n System.out.print(temp.data+\" \");\n temp = temp.next;\n } \n System.out.println();\n }\n\t/* Drier program to test above functions */\n\tpublic static void main(String args[])throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n // Scanner sc = new Scanner(System.in);\n\t\t int t=Integer.parseInt(br.readLine());\n\t\t while(t>0)\n {\n String S[] = br.readLine().split(\" \");\n\t\t\tint N = Integer.parseInt(S[0]);\n int m = Integer.parseInt(S[1]);\n int n = Integer.parseInt(S[2]);\n\t\t\n\t\t String S1[] = br.readLine().split(\" \");\n\t\t\tinsertion llist = new insertion(); \n\t\t\tint a1=Integer.parseInt(S1[0]);\n\t\t\tNode head= new Node(a1);\n llist.addToTheLast(head);\n for (int i = 1; i < N; i++) \n\t\t\t{\n\t\t\t\tint a = Integer.parseInt(S1[i]);\n\t\t\t\tllist.addToTheLast(new Node(a));\n\t\t\t}\n\t\t\t\n Solution ob = new Solution();\n\t\tNode newhead=ob.reverseBetween(llist.head, m, n);\n\t\tllist.printList(newhead);\n\t\t\n t--;\t\t\n }\n }}// } Driver Code Ends\n\n\n//User function Template for Java\n\n/*\nclass Node\n {\n int data;\n Node next;\n Node(int d) {data = d; next = null; }\n }\n */\nclass Solution\n{\n public static Node reverseBetween(Node head, int m, int n)\n {\n if(m > n)\n return head;\n \n Node prev = null;\n Node curr = head;\n \n for(int i=1; i arr, int n, int k)\n {\n for (int i = 0; i < n; i += k)\n {\n // Get the left element ==========\n int starting = i;\n // Get the right most element ====\n int ending = Math.min(i + k - 1, n - 1);\n \n // Now swap reverse the small piece of sub-arry in the arraylist\n while(starting < ending){\n int aux = arr.get(starting);\n arr.set(starting, arr.get(ending));\n arr.set(ending, aux);\n starting++;\n ending--;\n \n }\n }\n }\n}\n" }, { "path": "Reverse the String.cpp", "content": "#include\nusing namespace std;\n\nint getLength(char ayu[]){\n int count=0;\n for (int i=0; ayu[i]!='\\0';i++){\n count++;\n }\n return count;\n}\n\nvoid reverse(char ayu[], int n){\n int s=0;\n int e=n-1;\n while(s>ayu;\n \n cout<<\"My name is \"<=0;i--){\n if(s.charAt(i)==' '){\n if(sb.length()!=0){\n ans+=sb.reverse()+\" \";\n sb.setLength(0);\n }\n }else{\n sb.append(s.charAt(i));\n } \n }\n ans+=sb.reverse();\n return ans.trim();\n }\n}\n" }, { "path": "Reverse-Interger.java", "content": "class Solution {\n public int reverse(int x) {\n int result = 0; \n while ( x != 0){\n int d = x % 10 ;\n int next = result * 10 + d;\n if((next - d)/10 != result){\n return 0;\n }\n result = next;\n x = x / 10 ;\n }\n \n \n \n return result;\n \n \n \n }\n}\n" }, { "path": "Richest Customer Wealth.java", "content": "class Solution {\n public int maximumWealth(int[][] a) {\n int max=0;\n for(int i=0;i solve(TreeNode A) {\n ArrayList ans=new ArrayList<>();\n dfs(A,ans,0);\n return ans;\n }\n public void dfs(TreeNode a,ArrayList ans,int level){\n if(a==null)return;\n if(ans.size()==level){\n ans.add(a.val);\n }\n dfs(a.right,ans,level+1);\n dfs(a.left,ans,level+1);\n }\n}\n" }, { "path": "Robot Bounded In Circle", "content": "class Solution {\n public boolean isRobotBounded(String instructions) {\n int dir[][] = {{0,1}, {-1, 0}, {0, -1}, {1,0}};\n int i = 0;\n int x = 0;\n int y = 0;\n \n for(int s = 0; s < instructions.length(); s++){\n if(instructions.charAt(s) == 'L'){\n i = (i + 1) % 4;\n }\n else if(instructions.charAt(s) == 'R'){\n i = (i + 3) % 4;\n }\n else{\n x = x + dir[i][0];\n y = y + dir[i][1];\n }\n }\n return x == 0 && y == 0 || i != 0;\n }\n}\n" }, { "path": "Robots.java", "content": "class Solution {\n public String moveRobots(String s1, String s2) {\n int i = 0, j = 0, n = s1.length();\n while(i < n && j < n) {\n if(s1.charAt(i) == '#') {\n i++;\n }\n else if(s2.charAt(j) == '#') {\n j++;\n }\n else if(s1.charAt(i) != s2.charAt(j)) {\n return \"No\";\n }\n else if(s1.charAt(i) == 'B' && i > j) {\n return \"No\";\n }\n else if(s1.charAt(i) == 'A' && i < j) {\n return \"No\";\n }\n else {\n i++;\n j++;\n }\n }\n return \"Yes\";\n }\n}\n" }, { "path": "Roman To Integer.java", "content": "public class Solution {\n public int romanToInt(String A) {\n int ans=0;\n int i=0;\n while(igetValue(A.charAt(i))){\n ans+=getValue(A.charAt(i+1))-getValue(A.charAt(i));\n i+=2;\n }else{\n ans+=getValue(A.charAt(i));\n i++;\n }\n }else{\n ans+=getValue(A.charAt(i));\n i++;\n }\n }\n return ans;\n }\n int getValue(char ch){\n switch(ch){\n case 'I':\n return 1;\n case 'V':\n return 5;\n case 'X':\n return 10;\n case 'L':\n return 50;\n case 'C':\n return 100;\n case 'D':\n return 500;\n case 'M':\n return 1000;\n default:\n return -1;\n }\n }\n}\n" }, { "path": "Root to Leaf Paths With Sum.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n ArrayList> ans;\n public ArrayList> pathSum(TreeNode A, int B) {\n ans=new ArrayList<>();\n ArrayList curr=new ArrayList<>();\n curr.add(A.val);\n dfs(A,B,curr,A.val);\n return ans;\n }\n public void dfs(TreeNode a,int b,ArrayList list,int curr){\n if(a.left==null && a.right==null){\n if(curr==b){\n ans.add(new ArrayList<>(list));\n }\n return;\n }\n \n if(a.left!=null){\n list.add(a.left.val);\n curr+=a.left.val;\n dfs(a.left,b,list,curr);\n curr-=a.left.val;\n list.remove(list.size()-1);\n }\n \n if(a.right!=null){\n list.add(a.right.val);\n curr+=a.right.val;\n dfs(a.right,b,list,curr);\n curr-=a.right.val;\n list.remove(list.size()-1);\n }\n }\n}\n" }, { "path": "Rotate Image.cpp", "content": "class Solution {\npublic:\n void rotate(vector>& matrix) {\n transpose(matrix);\n reflect(matrix);\n }\n public: void transpose(vector>& matrix){\n int n = matrix.size();\n for(int i =0; i>& matrix){\n int n = matrix.size();\n for(int i =0; i0){\n sz--;\n temp=temp.next;\n }\n ListNode Alast=temp;\n ListNode Bfist=Alast.next;\n if(Bfist==null)return A;\n Alast.next=null;\n temp=Bfist;\n while(temp.next!=null){\n temp=temp.next;\n }\n temp.next=A;\n return Bfist;\n }\n}\n" }, { "path": "Rotate Matrix.java", "content": "public class Solution {\n\tpublic void rotate(ArrayList> arr) {\n int n=arr.size();\n int a=0;\n int b=n-1;\n while(a temp=arr.get(a);\n arr.set(a,arr.get(b));\n arr.set(b,temp);\n\t\t\ta++;\n\t\t\tb--;\n }\n int num=0;\n while(num'){\n ans+=left;\n }else{\n left--;\n }\n }\n return ans;\n }\n}\n" }, { "path": "Save Your Life - GFG/README.md", "content": "# Save Your Life\n## Medium\n

Given a string w, integer array b,  character array x and an integer n. n is the size of array b and array x. Find a substring which has the sum of the ASCII values of its every character, as maximum. ASCII values of some characters are redefined.
\nNote: Uppercase & lowercase both will be present in the string w. Array b and Array x contain corresponding redefined ASCII values. For each i, 0<=ib[i] contain redefined ASCII value of character x[i].

\n\n

Example 1:

\n\n
Input:\nW = abcde\nN = 1\nX[] = { 'c' }\nB[] = { -1000 }\nOutput:\nde\nExplanation:\nSubstring \"de\" has the\nmaximum sum of ascii value,\nincluding c decreases the sum value\n
\n\n

Example 2:

\n\n
Input:\nW = dbfbsdbf \nN = 2\nX[] = { 'b','s' }\nB[] = { -100, 45  }\nOutput:\ndbfbsdbf\nExplanation:\nSubstring \"dbfbsdbf\" has the maximum\nsum of ascii value.\n
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function maxSum() which takes string W, character array X, integer array B, integer N as length of array X and B as input parameters and returns the substring with the maximum sum of ascii value.
\n 

\n\n

Expected Time Complexity: O(|W|)
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:

\n\n

1<=|W|<=100000
\n1<=|X|<=52
\n-1000<=Bi<=1000

\n\n

Each character of W and A will be from a-z, A-Z.

\n
" }, { "path": "Save Your Life - GFG/save-your-life.java", "content": "//{ Driver Code Starts\nimport java.io.*;\nimport java.util.*;\n\n// } Driver Code Ends\nclass Solution{\n static String maxSum(String w,char x[],int b[], int n){\n //code here\n Map map=new HashMap<>();\n for(int i=0;imaxSum){\n maxSum=currSum;\n ans=new StringBuilder(temp);\n }\n if(currSum<0){\n currSum=0;\n temp=new StringBuilder();\n }\n }\n \n return ans.toString();\n }\n}\n\n//{ Driver Code Starts.\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String w = read.readLine();\n int n = Integer.parseInt(read.readLine());\n String TE[] = read.readLine().trim().split(\" \");\n char x[] = new char[n];\n for(int i = 0;ib){\n dfs(a,b,ans,i,mid-1);\n }else{\n dfs(a,b,ans,mid+1,j);\n }\n }\n }\n}\n" }, { "path": "Search in Bitonic Array!.java", "content": "public class Solution {\n public int solve(ArrayList A, int B) {\n int l=0;\n int h=A.size()-1;\n while(l<=h){\n int mid=(l+h)/2;\n if(A.get(mid)==B){\n return mid;\n }else if(A.get(mid)B){\n if(A.get(l)\n

Given a sorted array Arr[](0-index based) consisting of N distinct integers and an integer k, the task is to find the index of k, if its present in the array Arr[]. Otherwise, find the index where k must be inserted to keep the array sorted.

\n\n


\nExample 1:

\n\n
Input:\nN = 4\nArr = {1, 3, 5, 6}\nk = 5\nOutput: 2\nExplaination: Since 5 is found at index 2 \nas Arr[2] = 5, the output is 2.
\n\n


\nExample 2:

\n\n
Input:\nN = 4\nArr = {1, 3, 5, 6}\nk = 2\nOutput: 1\nExplaination: Since 2 is not present in \nthe array but can be inserted at index 1 \nto make the array sorted.\n
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function searchInsertK() which takes the array Arr[] and its size N and k as input parameters and returns the index.

\n\n


\nExpected Time Complexity: O(logN)
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 ≤ N ≤ 104
\n-103 ≤ Arr[i] ≤ 103
\n-103 ≤ k ≤ 103

\n

\n " }, { "path": "Search insert position of K in a sorted array - GFG/search-insert-position-of-k-in-a-sorted-array.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n int N = Integer.parseInt(read.readLine());\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int Arr[]= new int[N];\n for(int i = 0; i < N; i++)\n Arr[i] = Integer.parseInt(input_line[i]);\n int k = Integer.parseInt(read.readLine());\n \n Solution ob = new Solution();\n System.out.println(ob.searchInsertK(Arr, N, k));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n static int searchInsertK(int a[], int N, int k){\n int i=0;\n int j=a.length;\n while(i solve(ArrayList arr) {\n Collections.sort(arr);\n return arr;\n }\n}\n" }, { "path": "Self Permutation.java", "content": "public class Solution {\n public int permuteStrings(String A, String B) {\n HashMap hm = new HashMap<>();\n\n if(A.length()!=B.length()) return 0;\n\n for(int i=0; i sequentialDigits(int low, int high) {\n List list=new ArrayList<>();\n this.high=high;\n this.low=low;\n for(int i=1;i<=9;i++){\n dfs(i,list);\n }\n Collections.sort(list);\n return list;\n }\n public void dfs(int num,List list){\n int add=(num%10)+1;\n if(add!=10){\n num=(num*10)+add;\n if(num<=high){\n if(num>=low){\n list.add(num);\n }\n dfs(num,list);\n }\n }\n \n }\n}\n" }, { "path": "Serialize.java", "content": "public class Solution {\n public String serialize(ArrayList A) {\n StringBuilder sb=new StringBuilder();\n for(String s:A){\n sb.append(s);\n sb.append(s.length());\n sb.append(\"~\");\n }\n return sb.toString();\n }\n}\n" }, { "path": "Shop in Candy Store - GFG/README.md", "content": "# Shop in Candy Store\n## Easy \n
\n

In a candy store, there are N different types of candies available and the prices of all the N different types of candies are provided to you.
\nYou are now provided with an attractive offer.
\nYou can buy a single candy from the store and get at most K other candies ( all are different types ) for free.
\nNow you have to answer two questions. Firstly, you have to find what is the minimum amount of money you have to spend to buy all the N different candies. Secondly, you have to find what is the maximum amount of money you have to spend to buy all the N different candies.
\nIn both the cases you must utilize the offer i.e. you buy one candy and get K other candies for free.

\n\n

Example 1:

\n\n
Input:\nN = 4\nK = 2\ncandies[] = {3 2 1 4}\n\nOutput:\n3 7\n\nExplanation:\nAs according to the offer if you buy \none candy you can take at most two \nmore for free. So in the first case, \nyou buy the candy which costs 1 and \ntakes candies worth 3 and 4 for free, \nalso you buy candy worth 2 as well.\nSo min cost : 1+2 =3.\nIn the second case, you can buy the \ncandy which costs 4 and takes candies \nworth 1 and 2 for free, also you need \nto buy candy worth 3 as well. \nSo max cost : 3+4 =7.
\n\n

Example 2:

\n\n
Input: \nN = 5\nK = 4\ncandies[] = {3 2 1 4 5}\n\nOutput: \n1 5\n\nExplanation:\nFor minimimum cost buy the candy with\nthe cost 1 and get all the other candies\nfor free.\nFor maximum cost buy the candy with\nthe cost 5 and get all other candies\nfor free.\n
\n\n

Your Task:  
\nYou don't need to read input or print anything. Your task is to complete the function candyStore() which takes the array candies[], its size N and an integer K as input parameters and returns the minimum amount and maximum amount of money to buy all candies according to the offer.
\n
\nExpected Time Complexity: O(NLogN)
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints:
\n1 <= N <= 100000
\n 0 <= K <= N-1
\n1 <= candies[i] <= 10000

\n

\n
" }, { "path": "Shop in Candy Store - GFG/shop-in-candy-store.java", "content": "// { Driver Code Starts\n//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n int K = Integer.parseInt(input_line[1]);\n input_line = read.readLine().trim().split(\"\\\\s+\");\n int candies[]= new int[N];\n for(int i = 0; i < N; i++)\n candies[i] = Integer.parseInt(input_line[i]);\n\n Solution ob = new Solution();\n ArrayList cost = ob.candyStore(candies,N,K);\n System.out.println(cost.get(0)+\" \"+cost.get(1));\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\n\nclass Solution{\n static ArrayList candyStore(int arr[],int N,int k){\n // code here\n ArrayList ans=new ArrayList<>();\n Arrays.sort(arr);\n int i=0;\n int j=N-1;\n int minCost=0;\n while(i<=j){\n minCost+=arr[i];\n j-=k;\n i++;\n }\n ans.add(minCost);\n i=0;\n j=N-1;\n int maxCost=0;\n while(i<=j){\n maxCost+=arr[j];\n j--;\n i+=k;\n }\n ans.add(maxCost);\n return ans;\n }\n}" }, { "path": "Shortest Distance in a Binary Maze - GFG/README.md", "content": "# Shortest Distance in a Binary Maze\n## Medium\n

Given a n * m matrix grid where each element can either be 0 or 1. You need to find the shortest distance between a given source cell to a destination cell. The path can only be created out of a cell if its value is 1. 

\n\n

If the path is not possible between source cell and destination cell, then return -1.

\n\n

Note : You can move into an adjacent cell if that adjacent cell is filled with element 1. Two cells are adjacent if they share a side. In other words, you can move in one of the four directions, Up, Down, Left and Right.

\n\n

Example 1:

\n\n
Input:\ngrid[][] = {{1, 1, 1, 1},\n            {1, 1, 0, 1},\n            {1, 1, 1, 1},\n            {1, 1, 0, 0},\n            {1, 0, 0, 1}}\nsource = {0, 1}\ndestination = {2, 2}\nOutput:\n3\nExplanation:\n1 1 1 1\n1 1 0 1\n1 1 1 1\n1 1 0 0\n1 0 0 1\nThe highlighted part in the matrix denotes the \nshortest path from source to destination cell.\n
\n\n

Example 2:

\n\n
Input:\ngrid[][] = {{1, 1, 1, 1, 1},\n            {1, 1, 1, 1, 1},\n            {1, 1, 1, 1, 0},\n            {1, 0, 1, 0, 1}}\nsource = {0, 0}\ndestination = {3, 4}\nOutput:\n-1\nExplanation:\nThe path is not possible between source and \ndestination, hence return -1.\n
\n\n

Your Task:

\n\n

You don't need to read or print anything. Your task is to complete the function shortestPath() which takes the a 2D integer array grid, source cell and destination cell as an input parameters and returns the shortest distance between source and destination cell.

\n\n

Expected Time Complexity: O(n * m)
\nExpected Space Complexity: O(n * m)

\n\n

Constraints:

\n\n
    \n\t
  • 1 ≤ n, m ≤ 500
    • \n\t
  • grid[i][j] == 0 or grid[i][j] == 1
    • \n\t
  • The source and destination cells are always inside the given matrix.
    • \n\t
  • The source and destination cells always contain 1.
    • \n
\n
" }, { "path": "Shortest Distance in a Binary Maze - GFG/shortest-distance-in-a-binary-maze.java", "content": "//{ Driver Code Starts\n// Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\n// Position this line where user code will be pasted.\n\nclass GFG {\n public static void main(String[] args) throws IOException {\n Scanner sc = new Scanner(System.in);\n int T = sc.nextInt();\n while (T-- > 0) {\n int n = sc.nextInt();\n int m = sc.nextInt();\n int[][] grid = new int[n][m];\n\n for (int i = 0; i < n; i++) {\n\n for (int j = 0; j < m; j++) {\n grid[i][j] = sc.nextInt();\n }\n }\n int[] source = new int[2];\n for (int i = 0; i < 2; i++) {\n int x = sc.nextInt();\n source[i] = x;\n }\n int[] dest = new int[2];\n for (int i = 0; i < 2; i++) {\n int x = sc.nextInt();\n dest[i] = x;\n }\n Solution ob = new Solution();\n int ans = ob.shortestPath(grid, source, dest);\n System.out.println(ans);\n }\n }\n}\n// } Driver Code Ends\n\n\n// User function Template for Java\n\nclass Solution {\n\n class Pair{\n int x;\n int y;\n Pair(int i,int j){\n x=i;\n y=j;\n }\n }\n int shortestPath(int[][] grid, int[] src, int[] des) {\n Queue q=new LinkedList<>();\n q.add(new Pair(src[0],src[1]));\n grid[src[0]][src[1]]=0;\n int dis=0;\n while(!q.isEmpty()){\n int sz=q.size();\n while(sz-->0){\n Pair curr=q.remove();\n int i=curr.x;\n int j=curr.y;\n if(i==des[0] && j==des[1])return dis;\n if(i>0 && grid[i-1][j]==1){\n grid[i-1][j]=0;\n q.add(new Pair(i-1,j));\n }\n if(j>0 && grid[i][j-1]==1){\n grid[i][j-1]=0;\n q.add(new Pair(i,j-1));\n }\n if(i q = new LinkedList<>();\n \n for (int i = 0; i < n; i++) {\n int source = 1 << i;\n q.add(new int[] {i,source});\n seen[i][source] = true;\n }\n \n int level = 0;\n while (!q.isEmpty()) {\n int size = q.size();\n for (int i = 0; i < size; i++) {\n int[] currentPair = q.remove();\n int node = currentPair[0];\n int mask = currentPair[1];\n for (int nei : graph[node]) {\n int nextMask = mask | (1 << nei);\n if (nextMask == target) return level + 1;\n \n if (!seen[nei][nextMask]) {\n seen[nei][nextMask] = true;\n q.add(new int[] {nei, nextMask});\n }\n }\n }\n level++;\n }\n \n return -1;\n }\n}\n" }, { "path": "Shortest Path between Cities - GFG/README.md", "content": "# Shortest Path between Cities\n## Medium \n
\n

Geek lives in a special city where houses are arranged in a hierarchial manner. Starting from house number 1, each house leads to two more houses.  
\n1 leads to 2 and 3. 
\n2 leads to 4 and 5. 
\n3 leads to 6 and 7. and so on. 
\nGiven the house numbers on two houses x and y, find the length of the shortest path between them. 

\n\n


\nExample 1:

\n\n
Input:\nx = 2, y = 6\nOutput: 3\nExplanation:\n              1\n          /      \\\n        /          \\\n       2             3\n     /   \\         /   \\\n    4     5       6     7         \n   / \\   / \\     / \\   / \\\n  8  9  10 11   12 13 14 15\n\nThe length of the shortest path between 2 \nand 6 is 3. ie 2-> 1-> 3-> 6.
\n\n


\nExample 2:

\n\n
Input:\nx = 8, y = 10\nOutput: 4\nExplanation: 8-> 4-> 2-> 5-> 10\nThe length of the shortest path between 8 \nand 10 is 4.
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Complete the function shortestPath() which takes integers x and y as input parameters and returns the length of the shortest path from x to y.

\n\n


\nExpected Time Complexity: O(log(max(x,y)))
\nExpected Auxiliary Space: O(1)

\n\n


\nConstraints: 
\n1 <= x,y <= 109

\n

\n
" }, { "path": "Shortest Path between Cities - GFG/shortest-path-between-cities.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*; \nclass GFG{\n public static void main(String args[]) throws IOException { \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0){\n \tString input_line[] = read.readLine().trim().split(\"\\\\s+\");\n \tint x = Integer.parseInt(input_line[0]);\n \tint y = Integer.parseInt(input_line[1]);\n Solution ob = new Solution();\n System.out.println(ob.shortestPath(x,y));\n }\n } \n} // } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution {\n Map map;\n int shortestPath( int x, int y){ \n int max=Math.max(x,y);\n int min=Math.min(x,y);\n int ans=0;\n while(max!=min){\n max/=2;\n ans++;\n if(max\n

Given two strings S and T, find length of the shortest subsequence in S which is not a subsequence in T. If no such subsequence is possible, return -1. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous. A string of length n has \"2^n\" different possible subsequences.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nS = \"babab\"\nT = \"babba\"\nOutput:\n3\nExplanation:\nThere are no subsequences of S with\nlength less than 3 which is not a\nsubsequence of T. \"aab\" is an example of\na subsequence of length 3 which isn't a\nsubsequence of T.
\n\n

Example 2:

\n\n
Input:\nS = \"babhi\"\nT = \"babij\"\nOutput:\n1\nExplanation:\n\"h\" is a subsequence of S that is\nnot a subsequence of T.
\n\n

 

\n\n

Your Task:
\nYou don't need to read input or print anything. Your task is to complete the function shortestUnSub() which takes two Strings S, and T as input and returns the shortest Uncommon Subsequence.

\n\n

 

\n\n

Expected Time Complexity: O(|S|2*|T|)
\nExpected Auxiliary Space: O(|S|*|T|)

\n\n

 

\n\n

Constraints:
\n1 <= |S|, |T| <= 500

\n

\n " }, { "path": "Shortest Uncommon Subsequence - GFG/shortest-uncommon-subsequence.cpp", "content": "// { Driver Code Starts\n#include \nusing namespace std;\n\n // } Driver Code Ends\nclass Solution {\n public:\n int findShortest(vector> &dp, string &S, string &T, int n, int m, int i, int j){\n if(i >= n){\n return 501;\n }\n if(j >= m){\n return 1;\n }\n if(dp[i][j] != -1){\n return dp[i][j];\n }\n int k = j;\n for(; k < m; k++){\n if(S[i] == T[k]){\n break;\n }\n }\n if(k == m){\n return 1;\n }\n return dp[i][j] = min(findShortest(dp, S, T, n, m, i + 1, j), 1 + findShortest(dp, S, T, n, m, i + 1, k + 1));\n }\n \n \n int shortestUnSub(string S, string T) {\n int n = S.size();\n int m = T.size();\n vector> dp (n + 1, vector (m + 1, -1));\n int ans = findShortest(dp, S, T, n, m, 0, 0);\n return ans >= 501 ? -1 : ans;\n }\n};\n\n// { Driver Code Starts.\nint main() {\n int t;\n cin >> t;\n while (t--) {\n string S,T;\n cin>>S>>T;\n\n Solution ob;\n cout << ob.shortestUnSub(S,T) << endl;\n }\n return 0;\n} // } Driver Code Ends" }, { "path": "Shortest Uncommon Subsequence - GFG/shortest-uncommon-subsequence.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n String A[] = read.readLine().split(\" \");\n \n String S = A[0];\n String T = A[1];\n\n Solution ob = new Solution();\n System.out.println(ob.shortestUnSub(S,T));\n }\n }\n}// } Driver Code Ends\n\n\n//bcda\n//bcd\n\n\n//dp[i][j]=Math.min(dp[i-1][j],dp[i-1][k]+ 1)\n\n\n//User function Template for Java\n\nclass Solution {\n static int shortestUnSub(String S, String T) {\n // code here\n int n=S.length();\n int m=T.length();\n int[][]dp=new int[n+1][m+1];\n \n for(int i=0;i<=n;i++){\n dp[i][0]=1;\n }\n \n int MAX=501;\n for(int j=0;j<=m;j++){\n dp[0][j]=MAX;\n }\n \n \n for(int i=1;i<=n;i++){\n for(int j=1;j<=m;j++){\n int k;\n for(k=j-1;k>=0;k--){\n if(S.charAt(i-1)==T.charAt(k))break;\n }\n \n if(k==-1){\n dp[i][j]=1;\n }else{\n dp[i][j]=Math.min(dp[i-1][j],dp[i-1][k]+ 1);\n }\n }\n }\n \n if(dp[n][m]>=MAX)return -1;\n \n return dp[n][m];\n \n }\n};" }, { "path": "Shortest Unique prefix for every word.java", "content": "class Trie{\n Trie[] children;\n int count;\n \n Trie(){\n children = new Trie[26];\n count = 0;\n }\n static void insert(Trie root, String s){\n Trie temp = root;\n for(char ch : s.toCharArray()){\n int index = ch-'a';\n if(temp.children[index] == null){\n temp.children[index] = new Trie();\n }\n temp.children[index].count++;\n temp = temp.children[index];\n }\n }\n static String searchPrefix(Trie root, String s){\n StringBuilder ans = new StringBuilder();\n Trie temp = root;\n for(char ch : s.toCharArray()){\n int index = ch-'a';\n ans.append(ch);\n if(temp.children[index].count == 1){\n break;\n }\n temp = temp.children[index];\n }\n return ans.toString();\n }\n}\n\nclass Solution {\n static String[] findPrefixes(String[] arr, int n) {\n // code here\n String[]ans=new String[n];\n Trie root=new Trie();\n for(String s:arr){\n Trie.insert(root,s);\n }\n for(int i=0;i\nusing namespace std;\n\n\nvoid toposort(vector> adj[], vector &vis, stack &st, int node)\n{\n vis[node] = 1;\n for (auto it : adj[node])\n {\n if (!vis[it.first])\n {\n toposort(adj, vis, st, it.first);\n }\n }\n st.push(node);\n}\n\nvoid sdd(vector> adj[], int n, int src)\n{\n vector vis(n, 0);\n stack st;\n\n for (int i = 0; i < n; i++)\n {\n if (!vis[i])\n {\n toposort(adj, vis, st, i);\n }\n }\n vector dist(n, INT_MAX);\n dist[src] = 0;\n while (!st.empty())\n {\n int node = st.top();\n st.pop();\n\n if(dist[node]!=INT_MAX){\n for(auto it: adj[node]){\n if(dist[node]+it.second> m >> n;\n vector> adj[m];\n for (int i = 0; i < n; i++)\n {\n int x, y, w;\n cin >> x >> y >> w;\n adj[x].push_back({y, w});\n }\n int src;\n cin >> src;\n sdd(adj, m, src);\n return 0;\n}\n" }, { "path": "Simplify Path.java", "content": "class Solution {\n public String simplifyPath(String path) {\n Deque dq = new LinkedList<>();\n \n int i = 0;\n while (i < path.length()) {\n i++;\n int l = i;\n while (i < path.length() && path.charAt(i) != '/') i++;\n String segment = path.substring(l, i);\n \n if (segment.equals(\".\") || segment.isEmpty()) continue;\n if (segment.equals(\"..\")) {\n if (!dq.isEmpty()) dq.pollLast();\n } else {\n dq.offerLast(segment);\n }\n }\n \n if (dq.isEmpty()) return \"/\";\n \n StringBuilder result = new StringBuilder();\n while (!dq.isEmpty()) {\n result.append(\"/\").append(dq.pollFirst());\n }\n return result.toString();\n }\n}\n" }, { "path": "Single Element in Sorted Array.py", "content": "\"\"\"LEETCODE\"\"\"\n\n#QUESTION LINK:-https://leetcode.com/problems/single-element-in-a-sorted-array/\n\n#SOLUTION:-\nclass Solution(object):\n def singleNonDuplicate(self, nums):\n \"\"\"\n :type nums: List[int]\n :rtype: int\n \"\"\"\n l,r=0,len(nums)-1\n if r==0:\n return nums[-1]\n while l<=r:\n mid=(l+r)//2\n if (mid==0 and nums[mid]!=nums[mid+1]) or (mid==r and nums[mid]!=nums[mid-1]) or nums[mid]!=nums[mid-1] and nums[mid]!=nums[mid+1]:\n return nums[mid]\n elif (mid%2==0 and nums[mid]==nums[mid-1]) or (mid%2!=0 and nums[mid]==nums[mid+1]):\n r=mid-1\n else:\n l=mid+1\n return -1\n \n#EXPLANATION:-\n #This question is tricky. From examples we can observe that among the repeated elements, the first occur at even index and second at odd index (until the single element is found.) We will use that trick.\n #We will initialize a left and right (l and r) variable as 0 and len(nums)-1. \n #If r==0(only one element of the array), we will return the only element of the array.\n #After that we will start a while loop till l is less than r, and we will initialize a mid variable as l+r//2. \n # Now here the tricky part comes, as first condition, we will check if the mid is at index 0 and it is not equal to next index element, OR if mid is the last index and mid is not equal to the previous index element OR if the element is neither equal to the previous nor to the next element, if it fulfills any condition, we will return the mid index.\n # If the first condition is not fulfilled, we will check if the mid is at even index and the element before the mid is equal to current element OR if the index is odd and the next element is equal to to the current element, we will increment the r index.\n #If none of the conditions meet, we will increment the l index.\n #If none element found in loop, we will return -1 as element not found.\n\n#SUBMISSION REPORT:-\n # Runtime: 147 ms, faster than 92.46% of Python online submissions for Single Element in a Sorted Array.\n # Memory Usage: 20.6 MB, less than 20.29% of Python online submissions for Single Element in a Sorted Array.\n" }, { "path": "Single Number II.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public int singleNumber(final int[] A) {\n \n int num=0,n=A.length;\n for(int i=0;i<32;i++)\n {\n int count=0;\n for(int j=0;j A) {\n int ans=0;\n for(int i:A){\n ans=ans^i;\n }\n return ans;\n }\n}\n" }, { "path": "Sliding Window Maximum.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public int[] slidingMaximum(final int[] arr, int B) {\n int ans[]=new int[arr.length-B+1];\n int idx=0;\n if(arr.length==1){\n ans[0]=arr[0];\n return ans;\n }\n Deque q=new ArrayDeque<>();\n int i;\n for(i=0;i=arr[q.peekLast()]){\n q.removeLast();\n }\n q.addLast(i);\n }\n for(i=B;i=arr[q.peekLast()])q.removeLast();\n q.addLast(i);\n }\n ans[idx]=arr[q.peekFirst()];\n return ans;\n }\n}\n" }, { "path": "Smaller on Left - GFG/README.md", "content": "# Smaller on Left\n## Medium \n
\n

Given an array arr[ ] of N positive integers, the task is to find the greatest element on the left of every element in the array which is strictly smaller than itself, if this element does not exist for an index print \"-1\".

\n\n

Example 1:

\n\n
Input:\nN = 5\narr[] = {2, 3, 4, 5, 1}\nOutput: \n-1 2 3 4 -1\nExplanation:\nGreatest element on the left of 3 smaller \nthan itself is 2, for 4 it is 3 and for 5 \nit is 1. Since 2 is the first element and \nno element on its left is present, so it's \ngreatest smaller element will be -1 and for \n1 no element smaller than itself is present \non its left, so it's greatest smaller element \nis -1.\n
\n\n

Example 2:

\n\n
Input:\nN = 3\narr[] = {1, 2, 3} \nOutput:\n-1 1 2
\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function Smallestonleft() that takes an array arr[ ] and sizeOfArray N, and return the required answer. The driver code takes care of the printing.

\n\n

Expected Time Complexity: O(N*Log(N)).
\nExpected Auxiliary Space: O(N).

\n\n

Constraints:
\n1 ≤ N ≤ 106
\n1 ≤ arr[i] ≤ 108

\n

\n
" }, { "path": "Smaller on Left - GFG/smaller-on-left.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t int sizeOfArray = Integer.parseInt(br.readLine());\n\t\t int arr [] = new int[sizeOfArray];\n\t\t \n\t\t String line = br.readLine();\n\t\t String[] elements = line.trim().split(\"\\\\s+\");\n\t\t for(int i = 0;i set = new TreeSet<>();\n int ans[] = new int[n];\n \n for(int i=0; i sumOf(Arr,0,N-i-2)){\n return count;\n }\n count++;\n }\n return 0;\n }\n \n long sumOf(int[] Arr ,int beg, int end){\n long sum=0;\n for(int i=beg;i<=end;i++){\n sum+=Arr[i];\n }\n return sum;\n }\n}\n" }, { "path": "Smallest Subset With Greater Sum.java", "content": "class Solution { \n int minSubset(int[] arr,int n) { \n Arrays.sort(arr);\n long sum=0;\n for(int i=0;i &Arr,int N){\n sort(Arr.begin(),Arr.end());\n int count=0;\n long long sum=0;\n for(int i=0;i=0){\n sum-=Arr[j];\n rev+=Arr[j];\n if(rev>sum)\n return N-j;\n else{\n j--;\n }\n }\n return N;\n }" }, { "path": "Smallest Subset with Greater Sum gfg s15.cpp", "content": "#include\nusing namespace std;\nclass Solution{\n public:\n int minSubset(vector &Arr,int N){\n sort(Arr.begin(), Arr.end());\n long long sum =0;\n for(int i =0; i=1; i--){\n s+=Arr[i];\n sum-=Arr[i];\n \n if(s >sum) return N-i;\n \n }\n return 1;\n }\n};\nint main(){\n int t;\n cin>>t;\n while(t--){\n int N;\n cin>>N;\n vector Arr(N);\n for(int i=0;i>Arr[i];\n }\n Solution ob;\n cout< &Arr,int N){\n sort(Arr.begin(),Arr.end());\n long long int sum=0;\n for(int i=0;i=1;j--)\n {\n x+=Arr[j];\n if(x>sum-x)\n break;\n count++;\n }\n return count;\n }\n" }, { "path": "Smallest Subset with Greater Sum.java", "content": "class Solution { \n int minSubset(int[] Arr,int N) { \n if(N == 1) return 1;\n \n Arrays.sort(Arr);\n int start = 0; \n int end = N-1;\n \n int count = 1;\n \n \n int sum = Arr[end];\n \n while(start < end) {\n if(Arr[start] < sum) {\n sum -= Arr[start++];\n } else {\n sum += Arr[--end];\n count++;\n }\n }\n \n return count;\n }\n}\n" }, { "path": "Smallest Subset with Max Sum.py", "content": "class Solution:\n def minSubset(self, A,N):\n A.sort()\n totalSum = sum(A)\n currSum = 0\n for i in range(N-1, -1, -1):\n currSum += A[i]\n totalSum -= A[i]\n if totalSum=0;i--){\n if(digits[i]!=0){\n while(digits[i]!=0){\n sb.append((char)(i+48));\n digits[i]--;\n }\n }\n }\n return -Long.parseLong(sb.toString());\n }\n }\n}\n" }, { "path": "Smallest distinct window - GFG/README.md", "content": "# Smallest distinct window\n## Medium \n
\n

Given a string 's'. The task is to find the smallest window length that contains all the characters of the given string at least one time.
\nFor eg. A = aabcbcdbca, then the result would be 4 as of the smallest window will be dbca.

\n\n

 

\n\n

Example 1:

\n\n
\n
Input : \"AABBBCBBAC\"\nOutput : 3\nExplanation : Sub-string -> \"BAC\"\n
\n
\n\n
Example 2:
\n\n
Input : \"aaab\"\nOutput : 2\nExplanation : Sub-string -> \"ab\"
\n\n
 
\n\n
Example 3:
\n\n
Input : \"GEEKSGEEKSFOR\"\nOutput : 8\nExplanation : Sub-string -> \"GEEKSFOR\"
\n\n

 

\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function findSubString() which takes the string  S as input and returns the length of the smallest such window of the string.

\n\n


\nExpected Time Complexity: O(256.N)
\nExpected Auxiliary Space: O(256)

\n\n

 

\n\n

Constraints:
\n1 ≤ |S| ≤ 105
\nString may contain both type of English Alphabets.

\n

\n
" }, { "path": "Smallest factorial number - GFG/README.md", "content": "# Smallest factorial number\n## Easy \n
\n

Given a number n. The task is to find the smallest number whose factorial contains at least n trailing zeroes.

\n\n

Example 1:

\n\n
Input:\nn = 1\nOutput: 5\nExplanation : 5! = 120 which has at\nleast 1 trailing 0.
\n\n

Example 2:

\n\n
Input:\nn = 6\nOutput: 25\nExplanation : 25! has at least\n6 trailing 0.\n
\n\n


\nUser Task:
\nComplete the function findNum() which takes an integer N as input parameters, and returns the answer.

\n\n

Expected Time Complexity: O(log2 N * log5 N).
\nExpected Auxiliary Space: O(1).

\n\n

Constraints:
\n1 <= n <= 104

\n

\n
" }, { "path": "Smallest factorial number - GFG/smallest-factorial-number.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\n\npublic class GFG\n{\n public static void main(String args[])\n {\n Scanner sc = new Scanner(System.in);\n \n int t = sc.nextInt();\n \n while (t-- > 0)\n {\n int n = sc.nextInt();\n \n System.out.println(new Solution().findNum(n));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution\n{\n int findNum(int n)\n {\n int ans = 0;\n int low = 5;\n int high = 5*n;\n \n while(low <= high){\n int mid = low + (high-low)/2;\n int count = 0;\n \n for(int i=5; mid/i >= 1; i *= 5){\n count += mid/i;\n }\n \n if(count >= n){\n ans = mid;\n high = mid-1;\n }else{\n low = mid+1;\n }\n }\n return ans;\n }\n}" }, { "path": "Smallest greater elements in whole array - GFG/README.md", "content": "# Smallest greater elements in whole array\n## Easy \n
\n

Given an array A of N length. We need to calculate the next greater element for each element in a given array. If the next greater element is not available in a given array then we need to fill -10000000 at that index place.

\n\n

Example 1:

\n\n
Input : arr[] = {13, 6, 7, 12}\nOutput : _ 7 12 13 \nExplanation:\nHere, at index 0, 13 is the greatest value \nin given array and no other array element \nis greater from 13. So at index 0 we fill \n'-10000000'.\n
\n\n


\nExample 2:

\n\n
Input : arr[] = {6, 3, 9, 8, 10, 2, 1, 15, 7} \nOutput :  7 6 10 9 15 3 2 _ 8\nExplanation: Here, at index 7, 15 is the greatest\nvalue in given array and no other array element is\ngreater from 15. So at index 7 we fill '-10000000'.\n
\n\n

 

\n\n

Your Task:
\nThis is a function problem. The input is already taken care of by the driver code. You only need to complete the function greaterElement() that takes an array (arr), sizeOfArray (n), and return an array that displays the next greater element to element at that index. The driver code takes care of the printing.

\n\n

Expected Time Complexity: O(N*LOG(N)).
\nExpected Auxiliary Space: O(N).

\n\n

 

\n\n

Constraints:
\n1 ≤ N ≤ 105
\n-106 ≤ Ai ≤ 106

\n\n

 

\n

\n
" }, { "path": "Smallest greater elements in whole array - GFG/smallest-greater-elements-in-whole-array.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\n//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n\nclass Array {\n \n // Driver code\n\tpublic static void main (String[] args) throws IOException{\n\t\t// Taking input using buffered reader\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\t\n\t\tint testcases = Integer.parseInt(br.readLine());\n\t\t\n\t\t// looping through all testcases\n\t\twhile(testcases-- > 0){\n\t\t int sizeOfArray = Integer.parseInt(br.readLine());\n\t\t int arr [] = new int[sizeOfArray];\n\t\t \n\t\t String line = br.readLine();\n\t\t String[] elements = line.trim().split(\"\\\\s+\");\n\t\t for(int i = 0;i set = new HashSet<>();\n for(int i=0;i\nusing namespace std;\n\n// } Driver Code Ends\n// User function Template for C++\n\nclass Solution{\npublic:\n vector leftSmaller(int n, int a[]){\n // code here\n stacks;\n vectorv;\n s.push(-1);\n for(int i =0; i>t;\n while(t--){\n int n;\n cin>>n;\n int a[n];\n for(int i = 0;i < n;i++)\n cin>>a[i];\n \n Solution ob;\n vector ans = ob.leftSmaller(n, a);\n for(int i = 0;i < n;i++)\n cout<\nusing namespace std;\n\n// } Driver Code Ends\n// User function Template for C++\n\nclass Solution{\npublic:\n vector leftSmaller(int n, int a[]){\n // code here\n stacks;\n vectorans; //to store the answer\n \n for(int i=0;i=a[i]){ //Remove elements from stack which are greater than current element\n while(!s.empty() && s.top()>=a[i])\n s.pop(); // poping till we find smaller element\n \n if(s.empty())\n ans.push_back(-1);\n else\n ans.push_back(s.top());\n }\n \n s.push(a[i]); //push the element\n }\n return ans;\n }\n};\n\n//{ Driver Code Starts.\n\nint main(){\n int t;\n cin>>t;\n while(t--){\n int n;\n cin>>n;\n int a[n];\n for(int i = 0;i < n;i++)\n cin>>a[i];\n \n Solution ob;\n vector ans = ob.leftSmaller(n, a);\n for(int i = 0;i < n;i++)\n cout< leftSmaller(int n, int a[])\n {\n //code here\n List ans=new ArrayList<>();\n ans.add(-1);\n Stack s=new Stack<>();\n s.push(a[0]);\n for(int i=1;i=a[i]){\n s.pop();\n }\n if(s.isEmpty()){\n ans.add(-1);\n }else{\n ans.add(s.peek());\n }\n s.push(a[i]);\n }\n return ans;\n }\n}\n\n\nclass Solution{\n static List leftSmaller(int n, int a[])\n {\n List res=new ArrayList<>();\n Stack st=new Stack<>();\n\n for(int i=0;i=a[i]) {\n st.pop();\n }\n\n if(st.isEmpty()) {\n res.add(-1);\n }\n else {\n res.add(st.peek());\n }\n }\n st.push(a[i]);\n }\n return res;\n }\n}\n" }, { "path": "Smallest number with sum of digits as N and divisible by 10^N.cpp", "content": "class Solution{\n\tpublic:\n\tstring digitsNum(int N)\n\t{\n\t // Code here.\n\t string ans = \"\";\n\t int n = N;\n\t \n\t while(n >= 9)\n\t {\n\t n -= 9;\n\t ans.push_back('9');\n\t }\n\t \n\t if(n)\n\t ans.push_back('0'+n);\n\t \n\t reverse(ans.begin(), ans.end());\n\t \n\t for(int i=0; i9){\n sb.insert(0,9);\n N-=9;\n }else{\n sb.insert(0,N);\n N-=N;\n }\n }\n return sb.toString();\n }\n}\n" }, { "path": "Smallest number with sum of digits as N and divisible by 10^N.py", "content": "class Solution:\n\tdef digitsNum(self, N):\n\t\t# Code here\n\t\tans = \"\"\n\t\tif N == 0:\n\t\t ans += \"0\"\n\t\t return ans\n\t\t\n\t\tif (N%9 != 0):\n\t\t ans += chr(N%9 + ord(\"0\"))\n\t\t\n\t\tfor i in range(1, (N//9) + 1):\n\t\t ans += \"9\"\n\t\t\n\t\tfor i in range(1, N+1):\n\t\t ans += \"0\"\n\t\t\n\t\treturn ans\n" }, { "path": "Smallest number with sum of digits as N and divisible by 10powerN.cpp", "content": "#include\nusing namespace std;\n\n\n// } Driver Code Ends\nclass Solution{\n\tpublic:\n\tstring digitsNum(int N)\n\t{\n\t // Code here.\n\t \n\t int n = N;\n\t \n\t string ans =\"\";\n\t \n\t int i=9;\n\t while(i>=1){\n\t \n\t if(n>=i){\n\t ans = to_string(i)+ans;\n\t n -= i;\n\t }else{\n\t i--;\n\t }\n\t \n\t if(n==0){\n\t break;\n\t }\n\t }\n\t \n\t \n\t for(int i=1;i<=N;i++){\n\t ans += '0';\n\t }\n\t return ans;\n\t}\n};\n\n//{ Driver Code Starts.\nint main(){\n\tint tc;\n\tcin >> tc;\n\twhile(tc--){\n\t\tint n;\n\t\tcin >> n;\n\t\tSolution ob;\n\t\tstring ans = ob.digitsNum(n);\n\t\tcout << ans <<\"\\n\";\n\t}\n\treturn 0;\n}\n" }, { "path": "Smallest sum contiguous subarray.cpp", "content": "class Solution{\n public:\n int smallestSumSubarray(vector& a){\n //Code here\n \n int n = a.size();\n int sum = a[0], ans = a[0];\n \n for(int i=1; i 0)\n {\n if(sum > a[i])\n sum = a[i];\n }\n else\n sum += a[i];\n \n ans = min(ans, sum);\n }\n \n return ans;\n }\n};\n\n\n// Another Approach - 2\n\nclass Solution{\n public:\n int smallestSumSubarray(vector& a){\n int ans = INT_MAX,sum=0;\n for(int i=0;i0)curSum=0;\n }\n return ans;\n }\n}\n\n//Approach 2\n\nclass Solution\n{\n static int smallestSumSubarray(int a[], int size)\n {\n int ans=Integer.MAX_VALUE;\n int i=0, j=0, sum=0;\n while(j0) { //In the question , they asked smallest sum contiguous sub array, hence we reduce the sum if sum>0 using sliding window\n sum-=a[i];\n i+=1;\n }\n j+=1;\n }\n return ans;\n\n }\n}\n" }, { "path": "Smallest sum contiguous subarray.py", "content": "def smallestSumSubarray(A):\n currSum, minSum = 0, float('inf')\n for i in A:\n currSum += i\n minSum = min(currSum, minSum)\n if currSum>0: currSum = 0\n return minSum\n" }, { "path": "Smallest window containing 0, 1 and 2.java", "content": "class Solution {\n public int smallestSubstring(String S) {\n // Code here\n int i=0,j=0,n=S.length();\n int count0=0,count1=0,count2=0,size=Integer.MAX_VALUE;\n while(j=1 && count1>=1 && count2>=1){\n while(count0>=1 && count1>=1 && count2>=1){\n if(S.charAt(i)=='0'){\n i++;\n count0--;\n }\n else if(S.charAt(i)=='1'){\n i++;\n count1--;\n }\n else if(S.charAt(i)=='2')\n {\n i++;\n count2--;\n }\n }\n size=Math.min(size,j-i+2);\n }\n j++;\n }\n if(size==Integer.MAX_VALUE)\n return -1;\n return size;\n }\n};\n" }, { "path": "SmallestNumberWithSumOfDigitsAsNAndDivisbileBy10ToThePowerN.java", "content": "/* \n * \nFind the smallest number such that the sum of its digits is N and it is divisible by 10N.\n\nExample 1:\n\nInput: N = 5\nOutptut: 500000\nExplanation: Sum of digits of 500000\nis 5 and divisible by 105.\nExample 2:\n\nInput: N = 20\nOutput: 29900000000000000000000\nExplanation: Sum of digits of \n29900000000000000000000 is 20 and\ndivisible by 1020.\n\nYour Task:\nYou don't need to read or print anything. Your task is to complete the function digitsNum() which takes the input parameter N and returns the smallest number such that sum of its digits is N and divisible by 10N.\n \n\nExpected Time Complexity: O(N)\nExpected Space Complexity: O(N)\n \n\nConstraints:\n1 <= N <= 10000\n * \n */\n\n\npublic class SmallestNumberWithSumOfDigitsAsNAndDivisbileBy10ToThePowerN {\n \n public static void main(String[] args) {\n SmallestNumberWithSumOfDigitsAsNAndDivisbileBy10ToThePowerN obj = \n new SmallestNumberWithSumOfDigitsAsNAndDivisbileBy10ToThePowerN();\n\n System.out.println(obj.digitsNum(5));\n System.out.println(obj.digitsNum(20));\n }\n \n \n public String digitsNum(int N) {\n // Code here\n StringBuilder sb = new StringBuilder();\n for(int i = 0; i < N; i++) {\n sb.append(\"0\");\n }\n \n while(N > 9) {\n N = N-9;\n sb.append(\"9\");\n }\n sb.append(N);\n \n sb.reverse();\n \n return sb.toString();\n }\n}\n" }, { "path": "Solve-the-Sudoku - GFG/Solve-the-Sudoku.java", "content": "import java.util.*;\r\nimport java.io.*;\r\nimport java.lang.*;\r\n\r\nclass Driver_class\r\n{\r\n public static void main(String args[])\r\n {\r\n \r\n Scanner sc = new Scanner(System.in);\r\n int t = sc.nextInt();\r\n \r\n while(t-- > 0)\r\n {\r\n int grid[][] = new int[9][9];\r\n for(int i = 0; i < 9; i++)\r\n {\r\n for(int j = 0; j < 9; j++)\r\n grid[i][j] = sc.nextInt();\r\n }\r\n \r\n Solution ob = new Solution();\r\n \r\n if(ob.SolveSudoku(grid) == true)\r\n ob.printGrid(grid);\r\n else\r\n System.out.print(\"NO solution exists\");\r\n System.out.println();\r\n \r\n }\r\n }\r\n}\r\n\r\nclass Solution\r\n{\r\n static boolean isValid(int grid[][],int i, int j, int k){\r\n for(int row = 0;row<9;row++){\r\n if(grid[row][j]==k) return false;\r\n }\r\n for(int col = 0;col<9;col++){\r\n if(grid[i][col]==k) return false;\r\n }\r\n int col = (j/3)*3;\r\n int row = (i/3)*3;\r\n for(int l = 0;l<3;l++){\r\n for(int m = 0;m<3;m++){\r\n if(grid[row+l][col+m]==k) return false;\r\n }\r\n }\r\n return true;\r\n }\r\n static boolean solve(int grid[][],int i,int j){\r\n int ni = 0,nj = 0;\r\n if(i==9){\r\n return true;\r\n }\r\n if(j==8){\r\n ni=i+1;\r\n nj=0;\r\n }else{\r\n ni = i;\r\n nj = j+1;\r\n }\r\n if(grid[i][j]!=0) return solve(grid,ni,nj);\r\n \r\n for(int k = 1;k<=9;k++){\r\n if(isValid(grid,i,j,k)){\r\n grid[i][j] = k;\r\n if(solve(grid,ni,nj)){\r\n return true;\r\n }\r\n grid[i][j] = 0;\r\n }\r\n }\r\n \r\n return false;\r\n }\r\n static boolean SolveSudoku(int grid[][]){return solve(grid,0,0);}\r\n\r\n static void printGrid (int grid[][])\r\n {\r\n for(int i = 0;i<9;i++){\r\n for(int j = 0;j<9;j++){ System.out.print(grid[i][j]+\" \");} \r\n }\r\n }\r\n}" }, { "path": "Sort Binary Linked List.java", "content": "public class Solution {\n public ListNode solve(ListNode A) {\n ListNode head = A;\n ListNode curr = A;\n ListNode prev = null;\n ListNode next = null;\n while (curr != null){\n next = curr.next;\n if(curr.val == 0){\n if(prev != null){\n prev.next = next;\n curr.next = head;\n head = curr;\n }else {\n prev = curr;\n }\n }else {\n prev = curr;\n }\n curr = next;\n }\n return head;\n }\n}\n" }, { "path": "Sort Even and Odd Indices Independently.java", "content": "class Solution {\n public int[] sortEvenOdd(int[] nums) {\n List even=new ArrayList<>();;\n List odd=new ArrayList<>();;\n for(int i=0;i() {\n @Override\n public int compare(Integer o1, Integer o2) {\n return countSetBits(o2)-countSetBits(o1);\n }\n });\n }\n static int countSetBits(int n)\n {\n int count = 0;\n while (n > 0) {\n count += n & 1;\n n >>= 1;\n }\n return count;\n }\n==========================================================================\n class Compute \n{ \n static void sortBySetBitCount(Integer arr[], int n)\n { \n // Your code goes here\n Arrays.sort(arr,(o1,o2)-> Integer.bitCount(o2)-Integer.bitCount(o1));\n }\n}\n" }, { "path": "Sorted Array To Balanced BST.java", "content": "public class Solution {\n // DO NOT MODIFY THE ARGUMENTS WITH \"final\" PREFIX. IT IS READ ONLY\n public TreeNode sortedArrayToBST(final int[] A) {\n return makeTree(A,0,A.length-1);\n }\n public TreeNode makeTree(int[]a,int start,int end){\n if(start>end)return null;\n int mid=start+(end-start)/2;\n TreeNode root=new TreeNode(a[mid]);\n if(start==end)return root;\n else{\n root.left=makeTree(a,start,mid-1);\n root.right=makeTree(a,mid+1,end);\n }\n return root;\n }\n}\n" }, { "path": "Sorted Insert Position.java", "content": "public class Solution {\n\tpublic int searchInsert(ArrayList a, int b) {\n int i=0;\n int j=a.size();\n while(i\n

Given a Singly Linked List which has data members sorted in ascending order. Construct a Balanced Binary Search Tree which has same data members as the given Linked List.
\nNote: There might be nodes with same value.

\n\n

Example 1:

\n\n
Input:\nLinked List: 1->2->3->4->5->6->7\nOutput:\n4 2 1 3 6 5 7\nExplanation :\nThe BST formed using elements of the \nlinked list is,\n        4\n      /   \\\n     2     6\n   /  \\   / \\\n  1   3  5   7  \nHence, preorder traversal of this \ntree is 4 2 1 3 6 5 7\n
\n\n

Example 2:

\n\n
Input:\nLinked List : 1->2->3->4\nOuput:\n3 2 1 4\nExaplanation:\nThe BST formed using elements of the \nlinked list is,\n      3   \n    /  \\  \n   2    4 \n / \n1\nHence, the preorder traversal of this \ntree is 3 2 1 4\n
\n\n
Your task :
\n\n
You don't have to read input or print anything. Your task is to complete the function sortedListToBST(), which takes head of the linked list as an input parameter and returns the root of the BST created.
\n\n
 
\n\n
Expected Time Complexity: O(N), N = number of Nodes
\nExpected Auxiliary Space: O(N), N = number of Nodes
\n\n
 
\n\n
Constraints:
\n\n
1 ≤ Number of Nodes ≤ 106
\n\n
1 ≤ Value of each node ≤ 106
\n

\n " }, { "path": "Special Matrix.java", "content": "class Solution{\n int mod=1000000007;\n public int FindWays(int n, int m, int[][] bl){\n int[][]arr=new int[n+1][m+1];\n for(int i=0;i q){\n int n = mat.length;\n int m = mat[0].length;\n if(i<0 || i>=n || j<0 || j>=m || visited[i][j] || mat[i][j]=='W') return;\n visited[i][j] = true;\n q.offer(new int[]{i,j});\n }\n \n public static int bfs(char mat[][], int i, int j){\n int n = mat.length;\n int m = mat[0].length;\n boolean visited[][] = new boolean[n][m];\n visited[i][j] = true;\n Queue q = new LinkedList<>();\n q.offer(new int[]{i,j});\n int min = 0;\n while(!q.isEmpty()){\n int len = q.size();\n min++;\n for(int k=0;k=left;i--)\n res[bottom][i]=A[k++];\n bottom--;\n direction=4;\n }\n else if(direction == 4){\n for(int i=bottom;i>=top;i--)\n res[i][left]=A[k++];\n left++;\n direction = 1;\n }\n }\n return res;\n }\n}\n" }, { "path": "Spiral Order Matrix II.java", "content": "public class Solution {\n public int[][] generateMatrix(int n) {\n int[][] arr=new int[n][n];\n for(int i=0;irowBottom || colBack=colFront;i--){\n arr[rowBottom][i]=arr[rowBottom][i+1]+1;\n }\n dir='U';\n rowBottom--;\n }else if(dir=='U'){\n for(int i=rowBottom;i>=rowTop;i--){\n arr[i][colFront]=arr[i+1][colFront]+1;\n }\n dir='R';\n colFront++;\n }else if(dir=='R'){\n for(int i=colFront;i<=colBack;i++){\n arr[rowTop][i]=arr[rowTop][i-1]+1;\n }\n dir='D';\n rowTop++;\n }\n }\n\n return arr;\n }\n}\n" }, { "path": "Split_Array_Into_Consecutive_subsequence.java", "content": "\nclass Solution {\n public boolean isPossible(int[] nums) {\n HashMap available = new HashMap<>();\n for(int i:nums)\n available.put(i,available.getOrDefault(i,0)+1);\n HashMap vacancyFor = new HashMap<>();\n for(int i:nums)\n {\n int freq = available.get(i);\n if(freq > 0)\n {\n if(vacancyFor.containsKey(i) && vacancyFor.get(i)>0)\n {\n vacancyFor.put(i,vacancyFor.getOrDefault(i,0)-1);\n vacancyFor.put(i+1,vacancyFor.getOrDefault(i+1,0)+1);\n available.put(i,available.getOrDefault(i,0)-1);\n }\n else\n {\n if(available.containsKey(i+1) && available.containsKey(i+2) && available.get(i+1)>0 && available.get(i+2)>0)\n {\n vacancyFor.put(i+3,vacancyFor.getOrDefault(i+3,0)+1);\n available.put(i,available.getOrDefault(i,0)-1);\n available.put(i+1,available.getOrDefault(i+1,0)-1);\n available.put(i+2,available.getOrDefault(i+2,0)-1);\n }\n else\n return false;\n }\n }\n }\n return true;\n }\n}\n" }, { "path": "Square Root of Integer.java", "content": "public class Solution {\n public int sqrt(int A) {\n if (A == 0 || A == 1) return A;\n if (A == 2 || A == 3) return 1;\n int i=1;\n int j=A/2;\n int expect=0;\n while(i<=j){\n int m=i+(j-i)/2;\n\n if(m<=A/m){\n i=m+1;\n expect=m;\n }else{\n j=m-1;\n }\n }\n return expect;\n }\n}\n" }, { "path": "Stack Permutation med gfg sep7.cpp", "content": "#include \nusing namespace std;\n\nclass Solution{\npublic:\n int isStackPermutation(int N,vector &A,vector &B){\n // creating stack and a variable to traverse through 'B' variable\n stackst; int j=0;\n \n for(int i =0; i>t;\n while(t--){\n int n;\n cin>>n;\n vector a(n),b(n);\n for(int i=0;i>a[i];\n }\n for(int i=0;i>b[i];\n }\n Solution ob;\n cout< s= new Stack<>();\n int j=0,i=0;\n for(int k=0;k=n){\n return 0;\n }\n else{\n s.push(ip[i]);\n i++;\n }\n \n }\n if(Arrays.equals(ans,op)){\n return 1;\n }\n return 0; \n }\n}\n" }, { "path": "Stack Permutations.java", "content": "class Solution {\n public static int isStackPermutation(int n, int[] ip, int[] op) {\n // code here\n Stack s=new Stack<>();\n int i=0;\n int j=0;\n while(j=len(B): break\n arr.pop()\n j+=1\n else:\n if i>=len(A): break\n arr.append(A[i])\n i+=1\n return 1 if len(arr) == 0 else 0\n" }, { "path": "Step by Step.java", "content": "public class Solution {\n public int solve(int A) {\n A=Math.abs(A);\n int i=0;\n int sum=0;\n while(sum

A number is called a stepping number if all adjacent digits have an absolute difference of 1, e.g. '321' is a Stepping Number while 421 is not. Given two integers n and m, find the count of all the stepping numbers in the range [n, m].
\n
\nExample 1:

\n\n
Input: n = 0, m = 21\nOutput: 13\nExplanation: Stepping no's are 0 1 2 3 4 5\n6 7 8 9 10 12 21
\n\n

Example 2:

\n\n
Input: n = 10, m = 15\nOutput: 2\nExplanation: Stepping no's are 10, 12
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function steppingNumbers() which takes the integer n and integer m as input parameters and returns the number of stepping numbers in the range between n and m.
\n
\nExpected Time Complexity: O(log(M))
\nExpected Auxiliary Space: O(SN) where SN is the number of stepping numbers in the range

\n\n


\nConstraints:
\n0 ≤ N < M ≤ 107

\n" }, { "path": "Stepping Numbers - GFG/stepping-numbers.java", "content": "//{ Driver Code Starts\n//Initial Template for Java\n\n\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n int M = Integer.parseInt(input_line[1]);\n \n Solution ob = new Solution();\n int ans = ob.steppingNumbers(N, M);\n System.out.println(ans);\n }\n }\n}\n\n\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n int steppingNumbers(int n, int m){\n // code here\n int ans=0;\n if(n==0)ans++;\n Queue q=new LinkedList<>();\n for(int i=1;i<=9;i++){\n q.add(i);\n }\n while(q.size()>0){\n int sz=q.size();\n while(sz-->0){\n int ele=q.remove();\n if(ele>=n && ele<=m)ans++;\n int lastDigit=ele%10;\n if(lastDigit==9){\n int next=ele*10+8;\n if(next<=m)q.add(next);\n }else if(lastDigit==0){\n int next=ele*10+1;\n if(next<=m)q.add(next);\n }else{\n int smaller=ele*10+(lastDigit-1);\n if(smaller<=m)q.add(smaller);\n int greater=ele*10+(lastDigit+1);\n if(greater<=m)q.add(greater);\n }\n }\n }\n return ans;\n }\n}\n" }, { "path": "Steps by Knight", "content": "class Solution\n{\n public int minStepToReachTarget(int KnightPos[], int TargetPos[], int N)\n {\n boolean [][]vis = new boolean[N+1][N+1];\n \n Queue q = new ArrayDeque<>();\n q.add(KnightPos);\n \n vis[KnightPos[0]][KnightPos[1]] =true;\n int step =0;\n \n int [][]dir ={{-2,-1},{-2,1},{-1,-2},{-1,2},{1,-2},{1,2},{2,-1},{2,1}};\n \n while(q.size() > 0){\n \n int sz = q.size();\n \n while(sz-- >0 ){\n int []pos = q.poll();\n \n if( pos[0] == TargetPos[0] && pos[1] == TargetPos[1] ){\n return step;\n }\n \n for(int i=0 ; i < 8 ;i++){\n int r = pos[0] + dir[i][0];\n int c = pos[1] + dir[i][1];\n \n if( r > 0 && r <= N && c > 0 && c <= N && !vis[r][c] ){\n vis[r][c] =true;\n q.offer( new int[]{r ,c } );\n }\n }\n \n }\n step++;\n }\n return -1;\n }\n}\n" }, { "path": "Stock buy and sell - GFG/Stock buy and sell.cpp", "content": "// N = 7\n// A[] = { 100, 180, 260, 310, 40, 535, 695 }\n\n\n// This function finds the buy sell schedule for maximum profit\nvoid stockBuySell(int price[], int n) {\n // code here\n vector> v;\n // int profit = 0;\n for(int i=1;i= price[i-1]){\n int j = i;\n while(j < n and price[j] >= price[j-1]){\n j++;\n }\n // profit = max(profit, (price[j-1] - price[i-1]));\n v.push_back({i-1, j-1});\n i = j;\n }else i++;\n }\n // cout<0){\n sb.append(ch);\n sb.append(freq[ch-'a']);\n freq[ch-'a']=0;\n }\n }\n return sb.toString();\n }\n}\n" }, { "path": "String formation from substring - GFG/README.md", "content": "# String formation from substring\n## Medium \n
\n

Given a string s, the task is to check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. 

\n\n

Example 1:

\n\n
Input: s = \"ababab\"\nOutput: 1\nExplanation: It is contructed by \nappending \"ab\" 3 times
\n\n

Example 2:

\n\n
Input: s = \"ababac\"\nOutput: 0\nExplanation: Not possible to construct
\n\n

User Task:
\nYour task is to complete the function isRepeat() which takes a single string as input and returns 1 if possible to construct, otherwise 0. You do not need to take any input or print anything.

\n\n

Expected Time Complexity: O(|s|)
\nExpected Auxiliary Space: O(|s|)

\n\n

Constraints:
\n1 <= |s| <= 105

\n

\n
" }, { "path": "String formation from substring - GFG/string-formation-from-substring.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n String input = read.readLine();\n \n Solution ob = new Solution();\n int result = ob.isRepeat(input);\n \n System.out.println(result);\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution {\n int isRepeat(String s) {\n if(s.length()==1)return 0;\n if(s.length()==2){\n if(s.charAt(0)==s.charAt(1)) return 1;\n return 0;\n }\n String t = s+s;\n String ns = t.substring(2,t.length()-1);\n if(ns.indexOf(s)!=-1)return 1;\n return 0;\n }\n}" }, { "path": "String to Integer (atoi).java", "content": "class Solution {\n public int myAtoi(String s) {\n int sign=1,flagSign=0,n=s.length();\n long ans=0;\n for(int i=0;i='0'&&s.charAt(i)<='9') {\n ans=ans*10+(s.charAt(i)-'0');\n if(ans*sign>=Integer.MAX_VALUE) {\n return Integer.MAX_VALUE;\n }\n else if(ans*sign<=Integer.MIN_VALUE) {\n return Integer.MIN_VALUE;\n }\n flagSign=1;\n }\n else break;\n }\n ans=ans*sign;\n return (int)ans;\n }\n}\n" }, { "path": "Subarray Sum Equals K.java", "content": "public class Solution {\n public int subarraySum(int[] nums, int k) {\n int count = 0, sum = 0;\n Map < Integer, Integer > map = new HashMap<>();\n map.put(0, 1);\n for (int i = 0; i < nums.length; i++) {\n sum += nums[i];\n if (map.containsKey(sum - k)){\n count += map.get(sum - k);\n }\n map.put(sum, map.getOrDefault(sum, 0) + 1);\n }\n return count;\n }\n}\n" }, { "path": "Subarray with equal occurences!.java", "content": "public class Solution {\n public int solve(int[] A, int B, int C) {\n int ans=0;\n for(int i=0;i\r\nusing namespace std;\r\n\r\n\r\n// } Driver Code Ends\r\nclass Solution\r\n{\r\n public:\r\n vector subarraySum(int arr[], int n, long long s)\r\n {\r\n vector ans;\r\n if(s==0)\r\n {\r\n ans.push_back(-1);\r\n return ans;\r\n }\r\n int start=0;\r\n int end=0;\r\n long long sum=0;\r\n while(ends)\r\n {\r\n sum=sum-arr[start];\r\n start++;\r\n if(sum==s)\r\n {\r\n ans.push_back(start+1);\r\n ans.push_back(end);\r\n return ans;\r\n }\r\n\r\n }\r\n while(ends)\r\n {\r\n sum=sum-arr[start];\r\n start++;\r\n if(sum==s)\r\n {\r\n ans.push_back(start+1);\r\n ans.push_back(end);\r\n return ans;\r\n }\r\n\r\n }\r\n ans.push_back(-1);\r\n return ans;\r\n }\r\n};\r\n\r\n//{ Driver Code Starts.\r\n\r\nint main()\r\n {\r\n int t;\r\n cin>>t;\r\n while(t--)\r\n {\r\n int n;\r\n long long s;\r\n cin>>n>>s;\r\n int arr[n];\r\n const int mx = 1e9;\r\n for(int i=0;i>arr[i];\r\n }\r\n Solution ob;\r\n vectorres;\r\n res = ob.subarraySum(arr, n, s);\r\n \r\n for(int i = 0;i> res;\n ArrayList A;\n int N;\n \n\tpublic ArrayList> subsets(ArrayList A) {\n\t ArrayList temp;\n\t res = new ArrayList<>();\n\t temp = new ArrayList<>();\n\t this.A = A;\n\t N = A.size();\n\t Collections.sort(A);\n\t \n\t subset(0, temp);\n\t \n\t Collections.sort(res, new Comparator>() {\n\t @Override\n\t public int compare(ArrayList a, ArrayList b) {\n\t int an = a.size();\n\t int bn = b.size();\n\t for (int i = 0; i < Math.min(an, bn); i++) {\n\t int cmp = Integer.compare(a.get(i), b.get(i));\n\t if (cmp != 0)\n\t return cmp;\n\t }\n\t return Integer.compare(a.size(), b.size());\n\t }\n\t });\n\t \n\t return res;\n\t \n\t}\n\t\n\tprivate void subset(int index, ArrayList arr) {\n\t \n\t if (index == N) {\n\t res.add(new ArrayList<>(arr));\n\t return;\n\t }\n\t \n\t subset(index + 1, arr);\n\t arr.add(A.get(index));\n\t subset(index + 1, arr);\n\t arr.remove(arr.size() - 1);\n\t \n\t}\n\t\n\t\n}\n" }, { "path": "Subsets II.java", "content": "public class Solution {\n ArrayList> ans;\n public ArrayList> subsetsWithDup(ArrayList A) {\n ans=new ArrayList<>();\n ans.add(new ArrayList<>());\n Collections.sort(A);\n dfs(0,A,new ArrayList<>());\n return ans;\n }\n public void dfs(int idx,ArrayList a,ArrayList curr){\n if(idx==a.size())return;\n for(int i=idx;i(curr));\n dfs(i+1,a,curr);\n curr.remove(curr.size()-1);\n }\n }\n}\n" }, { "path": "Subsets with XOR value - GFG/README.md", "content": "# Subsets with XOR value\n## Medium \n
\n

Given an array arr of N integers and an integer K, find the number of subsets of arr having XOR of elements as K.
\n 

\n\n

Example 1:

\n\n
Input:\nN = 4\nk = 6\narr: 6 9 4 2\nOutput:\n2\nExplanation:\nThe subsets are \n{4,2} and {6}
\n\n

Example 2:

\n\n
Input:\nN = 5\nK = 4\narr: 1 2 3 4 5\nOutput:\n4\nExplanation:\nThe subsets are {1, 5},\n{4}, {1, 2, 3, 4},\nand {2, 3, 5}
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Your task is to complete the function subsetXOR​() which takes the array arr[], its size N and an integer K as input parameters and returns the number of subsets having xor as K
\n 

\n\n

Expected Time Complexity: O(N*M)
\nExpected Space Complexity: O(N*M)
\nNote: M = maximum value any XOR subset will acquire
\n 

\n\n

Constraints:
\n1<=N<=20
\n1<=K<=100
\n0<=arr[i]<=100

\n

\n
" }, { "path": "Subsets with XOR value - GFG/subsets-with-xor-value.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n\nimport java.io.*;\nimport java.util.*;\n\n // } Driver Code Ends\n//User function Template for Java\n\nclass Solution{\n static int subsetXOR(int arr[], int N, int K) { \n int max_ele = arr[0]; \n for (int i=1; i max_ele) \n max_ele = arr[i]; \n \n int m = 10*max_ele;\n \n int[][] dp = new int[N+1][m+1];\n \n dp[0][0] = 1;\n \n for(int i=1;i<=N;i++){\n for(int j=0;j<=m;j++){\n dp[i][j] += dp[i-1][j]; \n if((j^arr[i-1])<=m){\n dp[i][j] += dp[i-1][j^arr[i-1]];\n }\n }\n }\n \n return dp[N][K]; \n } \n}\n\n// { Driver Code Starts.\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n Scanner s = new Scanner(System.in);\n int t = s.nextInt();\n while(t-- > 0)\n {\n int N = s.nextInt();\n int K = s.nextInt();\n int arr[] = new int[N];\n for(int i =0;i> subsets(int[] nums) {\n List> list = new ArrayList<>();\n backtrack(list, new ArrayList<>(), nums, 0);\n return list;\n }\n\n private void backtrack(List> list , List tempList, int [] nums, int start){\n list.add(new ArrayList<>(tempList));\n for(int i = start; i < nums.length; i++){\n tempList.add(nums[i]);\n backtrack(list, tempList, nums, i + 1);\n tempList.remove(tempList.size() - 1);\n }\n }\n}\n" }, { "path": "Sum Of k smallest elements in BST.java", "content": "class Tree {\n\n public static void fun(Node root,ArrayListaa){\n\n if(root==null){\n\n return ;\n\n }\n\n else{\n\n fun(root.left,aa);\n\n aa.add(root.data);\n\n fun(root.right,aa);\n\n }\n\n }\n\n int sum(Node root, int k) { \n\n ArrayListaa=new ArrayList();\n\n fun(root,aa);\n\n int sum=0;\n\n for(int i=0;ileft,k,sum);\n if(k==0)\n return;\n sum+=node->data;\n k--;\n inorder(node->right,k,sum);\n}\n\nint sum(Node* root, int k) \n{ \n \n // Your code here\n int sum=0;\n inorder(root,k,sum);\n return sum;\n \n} \n" }, { "path": "Sum of Root To Leaf Binary Numbers.java", "content": "Approach 1: Iterative\nTime: O(H)\nSpace: O(H)\n\nclass Solution {\n public int sumRootToLeaf(TreeNode root) {\n int rootToLeaf = 0, currNumber = 0;\n Deque> stack = new ArrayDeque();\n stack.push(new Pair(root, 0));\n\n while (!stack.isEmpty()) {\n Pair p = stack.pop();\n root = p.getKey();\n currNumber = p.getValue();\n\n if (root != null) {\n currNumber = (currNumber << 1) | root.val;\n // if it's a leaf, update root-to-leaf sum\n if (root.left == null && root.right == null) {\n rootToLeaf += currNumber;\n } else {\n stack.push(new Pair(root.right, currNumber));\n stack.push(new Pair(root.left, currNumber));\n }\n }\n }\n return rootToLeaf;\n }\n}\n\n---------------------------------------------------------------------------------------\n\nApproach 2: Recursive\nTime: O(H)\nSpace: O(H)\n\nclass Solution {\n public int sumRootToLeaf(TreeNode root) {\n return pathSumRootToLeaf(root, 0);\n }\n \n private int pathSumRootToLeaf(TreeNode root, int parentNodeSum){\n if(root == null) return 0;\n \n parentNodeSum = 2 * parentNodeSum + root.val;\n if(root.left == null && root.right == null){\n return parentNodeSum;\n }\n \n return pathSumRootToLeaf(root.left, parentNodeSum) + pathSumRootToLeaf(root.right, parentNodeSum);\n }\n}\n\n---------------------------------------------------------------------------------------\n\nApproach 3: Morris approach(using predessesors)\nTime: O(n)\nSpace: O(1)\n\nclass Solution {\n public int sumRootToLeaf(TreeNode root) {\n int rootToLeaf = 0, currNumber = 0;\n int steps;\n TreeNode predecessor;\n\n while (root != null) {\n // If there is a left child,\n // then compute the predecessor.\n // If there is no link predecessor.right = root --> set it.\n // If there is a link predecessor.right = root --> break it.\n if (root.left != null) {\n // Predecessor node is one step to the left\n // and then to the right till you can.\n predecessor = root.left;\n steps = 1;\n while (predecessor.right != null && predecessor.right != root) {\n predecessor = predecessor.right;\n ++steps;\n }\n\n // Set link predecessor.right = root\n // and go to explore the left subtree\n if (predecessor.right == null) {\n currNumber = (currNumber << 1) | root.val;\n predecessor.right = root;\n root = root.left;\n }\n // Break the link predecessor.right = root\n // Once the link is broken,\n // it's time to change subtree and go to the right\n else {\n // If you're on the leaf, update the sum\n if (predecessor.left == null) {\n rootToLeaf += currNumber;\n }\n // This part of tree is explored, backtrack\n for(int i = 0; i < steps; ++i) {\n currNumber >>= 1;\n }\n predecessor.right = null;\n root = root.right;\n }\n }\n // If there is no left child\n // then just go right.\n else {\n currNumber = (currNumber << 1) | root.val;\n // if you're on the leaf, update the sum\n if (root.right == null) {\n rootToLeaf += currNumber;\n }\n root = root.right;\n }\n }\n return rootToLeaf;\n }\n}\n" }, { "path": "Sum of elements between k1'th and k2'th smallest elements - GFG/README.md", "content": "# Sum of elements between k1'th and k2'th smallest elements\n## Easy \n
\n

Given an array A[] of N positive integers and two positive integers K1 and K2. Find the sum of all elements between K1th and K2th smallest elements of the array. It may be assumed that (1 <= k1 < k2 <= n).

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN  = 7\nA[] = {20, 8, 22, 4, 12, 10, 14}\nK1 = 3, K2 = 6\nOutput:\n26\nExplanation:\n3rd smallest element is 10\n6th smallest element is 20\nSum of all element between\nK1 & K2 is 12 + 14 = 26
\n\n

 

\n\n

Example 2:

\n\n
Input\nN = 6\nA[] = {10, 2, 50, 12, 48, 13}\nK1= 2, K2 = 6\nOutput:\n73
\n\n

 

\n\n

Your Task:  
\nYou don't need to read input or print anything. Your task is to complete the function sumBetweenTwoKth() which takes the array A[], its size N and two integers K1 and K2 as inputs and returns the sum of all the elements between K1th and K2th smallest elements.
\n 

\n\n

Expected Time Complexity: O(N. log(N))
\nExpected Auxiliary Space: O(N)

\n\n

 

\n\n

Constraints:
\n1 ≤ N ≤ 105
\n1 ≤ K1, K2 ≤ 109

\n

\n
" }, { "path": "Sum of elements between k1'th and k2'th smallest elements - GFG/sum-of-elements-between-k1th-and-k2th-smallest-elements.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nclass GFG {\n\tpublic static void main(String[] args) throws IOException\n\t{\n\t BufferedReader br =\n new BufferedReader(new InputStreamReader(System.in));\n int t =\n Integer.parseInt(br.readLine().trim());\n while(t-->0)\n {\n long n = Long.parseLong(br.readLine().trim());\n long a[] = new long[(int)n];\n String inputLine[] = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) {\n a[i] = Long.parseLong(inputLine[i]);\n }\n \n StringTokenizer stt = new StringTokenizer(br.readLine());\n long k1 = Long.parseLong(stt.nextToken());\n long k2 = Long.parseLong(stt.nextToken());\n \n Solution obj = new Solution();\n System.out.println( obj.sumBetweenTwoKth(a, n, k1, k2) );\n \n }\n\t}\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution { \n public static long sumBetweenTwoKth(long A[], long N, long K1, long K2)\n {\n // Your code goes here\n Arrays.sort(A);\n long ans = 0;\n for(long i=K1;i S;\n \n while((!S.empty() or cur) and k--)\n {\n while(cur)\n {\n S.push(cur);\n cur = cur->left;\n }\n \n cur = S.top();\n S.pop();\n \n ans += cur->data;\n \n cur = cur->right;\n }\n \n return ans;\n} \n" }, { "path": "Sum of k smallest elements in BST.java", "content": "\nclass Tree {\n int sum;\n int cnt;\n int sum(Node root, int k) { \n sum=0;\n cnt=0;\n dfs(root,k);\n return sum;\n // Code here\n } \n void dfs(Node root,int k){\n if(root==null)return;\n dfs(root.left,k);\n if(cnt\n

Note: This POTD is a part of Geek Summer Carnival. Solve all POTD consecutively from 5th to 10th April and get a chance to win exclusive discount vouchers on our GfG courses.

\n\n
\n

Geek is at the geek summer carnival. To unlock discounts on exclusive courses he is given a card with a binary tree, a target node and a positive integer k on it. 
\nHe needs to find the sum of all nodes within a max distance k from target node such that the target node is included in sum.

\n\n

Example 1:

\n\n
Input:\ntarget = 9 \nk = 1\nBinary Tree = \n            1\n           /  \\\n          2    9\n        /     /  \\\n       4     5    7\n      /  \\       /  \\\n     8    19    20   11\n    /   /   \\\n  30   40   50\n\nOutput: 22\n\nExplanation: \nNodes within distance 1 from 9 \n9 + 5 + 7 + 1 = 22
\n\n


\nExample 2:

\n\n
Input:\ntarget = 40 \nk = 2\nBinary Tree = \n            1\n           /  \\\n          2    9\n        /     /  \\\n       4     5    7\n      /  \\       /  \\\n     8    19    20   11\n    /   /   \\\n  30   40   50\n\nOutput: 113\n\nExplanation:\nNodes within distance 2 from 40,\n40 + 19 + 50 + 4 = 113\n
\n\n

Your Task:
\nYou don't need to read input or print anything. Complete the function sum_at_distK() that takes the root of the given binary tree, target and k as input parameters and return the required sum. 

\n\n

Expected time complexity: O(n)
\nExpected space complexity: O(n)
\n
\nConstraints:
\n1 <= number of nodes <= 1000
\n1 <= data in nodes,target <= 10000
\n1 <= k <= 20

\n

\n " }, { "path": "Sum of nodes within k distance from target - GFG/sum-of-nodes-within-k-distance-from-target.java", "content": "// { Driver Code Starts\nimport java.util.LinkedList; \nimport java.util.Queue; \nimport java.io.*;\nimport java.util.*;\n\nclass Node{\n int data;\n Node left;\n Node right;\n Node(int data){\n this.data = data;\n left=null;\n right=null;\n }\n}\n\nclass GfG {\n \n static Node buildTree(String str){\n \n if(str.length()==0 || str.charAt(0)=='N'){\n return null;\n }\n \n String ip[] = str.split(\" \");\n // Create the root of the tree\n Node root = new Node(Integer.parseInt(ip[0]));\n // Push the root to the queue\n \n Queue queue = new LinkedList<>(); \n \n queue.add(root);\n // Starting from the second element\n \n int i = 1;\n while(queue.size()>0 && i < ip.length) {\n \n // Get and remove the front of the queue\n Node currNode = queue.peek();\n queue.remove();\n \n // Get the current node's value from the string\n String currVal = ip[i];\n \n // If the left child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the left child for the current node\n currNode.left = new Node(Integer.parseInt(currVal));\n // Push it to the queue\n queue.add(currNode.left);\n }\n \n // For the right child\n i++;\n if(i >= ip.length)\n break;\n \n currVal = ip[i];\n \n // If the right child is not null\n if(!currVal.equals(\"N\")) {\n \n // Create the right child for the current node\n currNode.right = new Node(Integer.parseInt(currVal));\n \n // Push it to the queue\n queue.add(currNode.right);\n }\n i++;\n }\n \n return root;\n }\n \n\tpublic static void main (String[] args) throws IOException{\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n \n int t=Integer.parseInt(br.readLine());\n \n while(t > 0){\n String line = br.readLine().trim();\n Node root = buildTree(line);\n \n line = br.readLine().trim();\n String target_k[] = line.split(\" \");\n int target = Integer.parseInt(target_k[0]);\n int k = Integer.parseInt(target_k[1]);\n \n solver x = new solver();\n System.out.println( x.sum_at_distK(root, target, k) );\n t--;\n }\n }\n}\n\n// } Driver Code Ends\n\n\n/*\n// node structure:\n\nclass Node{\n int data;\n Node left;\n Node right;\n Node(int data){\n this.data = data;\n left=null;\n right=null;\n }\n}\n\n*/\n\nclass solver{\n static Map map=new HashMap<>();\n static Node tar;\n static int n;\n static int sum_at_distK(Node root, int target, int k){\n n=target;\n Node copy=root;\n addAll(copy);\n Set set=new HashSet<>();\n bfs(tar,set,0,k);\n int sum=0;\n for(int i:set){\n sum+=i;\n }\n return sum;\n }\n static void bfs(Node curr,Setset,int dis,int k){\n if(curr==null)return;\n if(dis>k)return;\n if(set.contains(curr.data))return;\n set.add(curr.data);\n bfs(curr.left,set,dis+1,k);\n bfs(curr.right,set,dis+1,k);\n bfs(map.get(curr),set,dis+1,k);\n }\n static void addAll(Node root){\n if(root==null)return;\n if(root.data==n)tar=root;\n if(root.left!=null){\n map.put(root.left,root);\n addAll(root.left);\n }\n if(root.right!=null){\n map.put(root.right,root);\n addAll(root.right);\n }\n }\n}\n\n" }, { "path": "Sum of two large numbers.cpp", "content": "class Solution {\n public:\n string findSum(string X, string Y) {\n // Your code goes here\n string ans = \"\";\n \n int n = X.length()-1, m = Y.length()-1, rem = 0;\n \n while(n >= 0 and m >= 0)\n {\n int cur = (X[n--]-'0') + (Y[m--]-'0') + rem;\n rem = cur/10;\n cur = cur%10;\n \n ans.push_back('0'+cur);\n }\n \n while(n >= 0)\n {\n int cur = (X[n--]-'0') + rem;\n rem = cur/10;\n cur = cur%10;\n \n ans.push_back('0'+cur);\n }\n \n while(m >= 0)\n {\n int cur = (Y[m--]-'0') + rem;\n rem = cur/10;\n cur = cur%10;\n \n ans.push_back('0'+cur);\n }\n \n if(rem)\n ans.push_back('0'+rem);\n \n while(ans.back() == '0')\n ans.pop_back();\n \n if(ans.empty())\n return \"0\";\n \n reverse(ans.begin(), ans.end());\n \n return ans;\n }\n};\n\n// Used almost same approach\n// class Solution {\n// public:\n// string findSum(string X, string Y) {\n \n// int i = X.length()-1, j = Y.length()-1;\n \n// string ans = \"\";\n// int c = 0;\n// while(i >= 0 || j >= 0 || c != 0){\n// int val1 = 0, val2 = 0;\n// if(i >= 0) val1 = X[i] - 48;\n// if(j >= 0) val2 = Y[j] - 48;\n// int sum = val1+val2+c;\n \n// int rem = sum % 10;\n// ans.push_back(char(rem+48));\n// c = sum / 10;\n// if(i>=0) i--;\n// if(j>=0) j--;\n// }\n// reverse(ans.begin(), ans.end());\n \n// int idx = 0;\n// while(idx < ans.size()-1){\n// if(ans[idx] != '0')\n// break;\n// idx++;\n// }\n// ans.erase(0,idx);\n// return ans;\n// }\n// };\n" }, { "path": "Sum of two large numbers.java", "content": "class Solution {\n String findSum(String X, String Y) {\n // code here\n StringBuilder a=new StringBuilder(X);\n StringBuilder b=new StringBuilder(Y);\n StringBuilder ans=new StringBuilder();\n \n int carry=0;\n while(a.length()>0 || b.length()>0){\n int first=a.length()>0?a.charAt(a.length()-1)-'0':0;\n int second=b.length()>0?b.charAt(b.length()-1)-'0':0;\n int sum=first+second+carry;\n if(sum>9){\n sum-=10;\n carry=1;\n }else{\n carry=0;\n }\n ans.insert(0,sum);\n if(a.length()>0)a.setLength(a.length()-1);\n if(b.length()>0)b.setLength(b.length()-1);\n }\n if(carry==1){\n ans.insert(0,1);\n }\n //000000\n for(int i=0;i'0'){\n return ans.substring(i);\n }\n }\n return \"0\";\n }\n}\n" }, { "path": "Sum of two numbers without using arithmetic operators - GFG/README.md", "content": "# Sum of two numbers without using arithmetic operators\n## Easy \n
\n

Given two integers a and b. Find the sum of two numbers without using arithmetic operators.

\n\n

Example 1:

\n\n
Input:\na = 5, b = 3\nOutput: 8\nExplanation :\n5 + 3 = 8
\n\n

Example 2:

\n\n
Input:\na = 10, b = 30\nOutput: 40\nExplanation:\n10 + 30 = 40
\n\n
Your task:
\n\n
You don't need to read input or print anything. Your task is to complete the function sum() which takes two integers a and b as input and returns the sum of a and b, which is calculated without using any arithmetic operator.
\n\n
 
\n\n
Expected Time Complexity : O(max(number of bits in 'a', number of bits in 'b'))
\n\n
Expected Auxiliary Space : O(1)
\n\n
 
\n\n
Constraints:
\n\n
1<=a, b<=10^8
\n

\n
" }, { "path": "Sum of two numbers without using arithmetic operators - GFG/sum-of-two-numbers-without-using-arithmetic-operators.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*; \nimport java.math.BigInteger;\n\nclass GFG\n{\n\tpublic static void main(String[] args) throws NumberFormatException, IOException \n\t{\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\tint t = Integer.parseInt(br.readLine());\n\t\twhile(t>0)\n\t\t{\n\t\t String S[] = br.readLine().split(\" \");\n \n int a = Integer.parseInt(S[0]);\n int b = Integer.parseInt(S[1]);\n\t\t\tSolution obj = new Solution();\n\t\t\tSystem.out.println(obj.sum(a,b));\n t--;\n\t\t}\n\t}\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n int sum(int a , int b){\n while(b!=0){\n int ans=(a^b);\n int carry=(a&b)<<1;\n a=ans;\n b=carry;\n }\n return a;\n }\n}" }, { "path": "Summary Ranges.java", "content": "class Solution {\n public List summaryRanges(int[] nums) {\n List res = new ArrayList<>();\n StringBuilder buf = new StringBuilder();\n for(int i = 0; i < nums.length; i++)\n {\n buf.setLength(0);\n int index = i;\n while(index < nums.length-1 && nums[index]+1 == nums[index+1]){\n index++;\n }\n if(index == i){\n buf.append(\"\");\n buf.append(nums[i]);\n }else{\n buf.append(nums[i]);\n buf.append(\"->\");\n buf.append(nums[index]);\n }\n res.add(buf.toString());\n i = index;\n }\n return res;\n }\n}\n" }, { "path": "Super Primes - GFG/README.md", "content": "# Super Primes\n## Medium \n
\n

A prime number is Super Prime if it is a sum of two primes. Find all the Super Primes upto N

\n\n

Example 1:

\n\n
Input:\nN = 5\nOutput: 1\nExplanation: 5 = 2 + 3, 5 is the\nonly super prime\n\n
\n\n

Example 2:

\n\n
Input:\nN = 10 \nOutput: 2\nExplanation: 5 and 7 are super primes\n
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function superPrimes() which takes the N as input and returns the count of super primes.
\n
\nExpected Time Complexity: O(Nlog(logN))
\nExpected Auxiliary Space: O(N)
\n
\nConstraints:
\n1 ≤ N ≤ 105

\n

\n
" }, { "path": "Super Primes - GFG/super-primes.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n BufferedReader read =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int n = Integer.parseInt(read.readLine());\n \n Solution ob = new Solution();\n System.out.println(ob.superPrimes(n));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution {\n int superPrimes(int n) {\n boolean [] primes=new boolean[n+1];\n Arrays.fill(primes,true);\n \n //performing sieve\n for(int i=2;i<=Math.sqrt(n);i++){\n if(primes[i]==true){\n for(int j=i*i;j<=n;j+=i){\n primes[j]=false;\n }\n }\n }\n int count=0;\n for(int i=5;i<=n;i++){\n if(primes[i] && primes[i-2]){\n count++;\n }\n }\n return count;\n }\n}" }, { "path": "Swap Bits.java", "content": "public class Solution {\n public int solve(int n, int p, int q) {\n if ((((n & (1 << p-1)) >> p-1) ^ ((n & (1 << q-1)) >> q-1))!=0){\nn ^= (1 << p-1);\nn ^= (1 << q-1);\n}\n\n\nreturn n ;\n\n }\n}\n" }, { "path": "Swap Kth nodes from ends - GFG/README.md", "content": "# Swap Kth nodes from ends\n## Medium \n
\n

Given a singly linked list of size N, and an integer K. You need to swap the Kth node from the beginning and Kth node from the end of the linked list. Swap the nodes through the links. Do not change the content of the nodes.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nN = 4,  K = 1\nvalue[] = {1,2,3,4}\nOutput: 1\nExplanation: Here K = 1, hence after\nswapping the 1st node from the beginning\nand end thenew list will be 4 2 3 1.\n
\n\n

 

\n\n

Example 2:

\n\n
Input:\nN = 5,  K = 7\nvalue[] = {1,2,3,4,5}\nOutput: 1\nExplanation: K > N. Swapping is invalid. \nReturn the head node as it is.\n
\n\n

 

\n\n

Your Task: 
\nYou do not need to read input or print anything. The task is to complete the function swapkthnode(), which has takes head of link list, N and K as input parameters and returns the new head.
\nThe generated output will be 1 if you are able to complete your task. 

\n\n

 

\n\n

Expected Time Complexity: O(n)
\nExpected Auxillary space Complexity: O(1)

\n\n

 

\n\n

Constraints:
\n1 <= N <= 103
\n1 <= K <= 103

\n\n

 

\n

\n
" }, { "path": "Swap Kth nodes from ends - GFG/swap-kth-nodes-from-ends.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass Node\n{\n int data;\n Node next;\n \n Node(int data)\n {\n this.data = data;\n next = null;\n }\n}\n\nclass LinkedList\n{\n static Node head; \n static Node lastNode;\n \n public static void addToTheLast(Node node)\n {\n\n if (head == null)\n {\n head = node;\n lastNode = node;\n }\n else\n {\n Node temp = head;\n lastNode.next = node;\n lastNode = node;\n }\n }\n \n public static void main(String args[])\n {\n Scanner sc= new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n int n, K;\n n = sc.nextInt();\n K = sc.nextInt();\n \n Node head = null;\n int val = sc.nextInt();\n head = new Node(val);\n addToTheLast(head);\n \n for(int i = 1; i< n; i++)\n {\n val = sc.nextInt();\n addToTheLast(new Node(val));\n }\n \n Node before[] = new Node[n];\n addressstore(before, head);\n GFG obj = new GFG();\n \n head = obj.swapkthnode(head, n, K);\n \n Node after[] = new Node[n];\n addressstore(after, head);\n \n if(check(before, after, n, K) == true)\n System.out.println(\"1\");\n else\n System.out.println(\"0\");\n \n }\n }\n \n static boolean check(Node before[], Node after[], int num, int K)\n {\n if(K > num)\n return true;\n \n return (before[K-1] == after[num - K]) && (before[num-K] == after[K-1]);\n \n \n }\n \n static void addressstore(Node arr[], Node head)\n {\n Node temp = head;\n int i = 0;\n while(temp != null){\n arr[i] = temp;\n i++;\n temp = temp.next;\n }\n}\n \n}// } Driver Code Ends\n\n\n//User function Template for Java\n\n\n/* Linked List Node class\n class Node {\n int data;\n Node next;\n Node(int data)\n {\n this.data = data;\n next = null;\n }\n }\n*/\nclass GFG{\n //Function to swap Kth node from beginning and end in a linked list.\n Node swapkthnode(Node head, int num, int k){\n // your code here\n if (head == null)return head;\n if (k > num)return head;\n // begining node will be at k\n // end node will be at n - k + 1\n Node x = head;\n Node prevX = null;\n Node y = head;\n Node prevY = null;\n for (int i = 1; i < k; i++) {\n prevX = x;\n x = x.next;\n }\n for (int i = 1; i < num - k + 1; i++) {\n prevY = y;\n y = y.next;\n }\n \n if (prevX != null) {\n prevX.next = y;\n }\n if (prevY != null) {\n prevY.next = x;\n }\n Node temp = x.next;\n x.next = y.next;\n y.next = temp;\n if (k == 1) {\n head = y;\n }\n if (k == num) {\n head = x;\n }\n return head;\n }\n}" }, { "path": "Swap Nodes in Pairs.java", "content": "class Solution {\n public ListNode swapPairs(ListNode head) {\n if(head==null)return null;\n if(head.next==null)return head;\n ListNode rec=swapPairs(head.next.next);\n ListNode sec=head.next;\n sec.next=head;\n head.next=rec;\n return sec;\n }\n}\n" }, { "path": "Swap bits - GFG/README.md", "content": "# Swap bits\n## Easy \n
\n

Given a number X and two positions (from right side) in binary representation of x, write a program that swaps N bits at given two positions and returns the result.

\n\n

 

\n\n

Example 1:

\n\n
Input:\nX = 47\nP1 = 1\nP2 = 5\nN = 3\nOutput: 227\nExplanation:\nThe 3 bits starting from the second bit \n(from the right side) are swapped with 3 bits\nstarting from 6th position (from the right side)
\n\n
X = 47 (00101111)\n[001]0[111]1\nANS = [111]0[001]1\nANS = 227 (11100011)\nHence, the result is 227.  \n
\n\n

 

\n\n

Example 2:

\n\n
Input:\nX = 28\nP1 = 0\nP2 = 3\nN = 2\nOutput: 7
\n\n


\nYour Task:  
\nYou don't need to read input or print anything. Your task is to complete the function swapBits() which takes the integer X, integer P1, integer P2, and integer N as input parameters and returns the new integer after swapping. 
\n
\nExpected Time Complexity: O(1)
\nExpected Auxiliary Space: O(1)
\n 

\n\n


\nConstraints:
\n1 ≤ X ≤ 200
\n0 ≤ P1 < P2 ≤ 11
\n1 ≤ N ≤ 5
\n
\n 

\n

\n
" }, { "path": "Swap bits - GFG/swap-bits.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int X = Integer.parseInt(input_line[0]);\n int P1 = Integer.parseInt(input_line[1]);\n int P2 = Integer.parseInt(input_line[2]);\n int N = Integer.parseInt(input_line[3]);\n \n Solution ob = new Solution();\n System.out.println(ob.swapBits(X, P1, P2, N));\n }\n }\n}\n\n\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n \n int swapBits(int x, int p1, int p2, int n){\n int mask1= (x >> p1) & ((1 << n) - 1);\n int mask2 = (x >> p2) & ((1 << n) - 1);\n int xor = ( mask1^ mask2);\n xor = (xor << p1) | (xor << p2);\n int res = x ^ xor;\n \n return res;\n }\n}" }, { "path": "Symmetric Binary Tree.java", "content": "public class Solution {\n public int isSymmetric(TreeNode A) {\n if( isMirrorUtil(A, A)){\n return 1;\n }\n return 0;\n }\n public static boolean isMirrorUtil(TreeNode root1, TreeNode root2){\n if(root1 == null && root2 == null){\n return true;\n }\n if(root1 != null && root2!= null && root1.val == root2.val){\n return (isMirrorUtil(root1.left, root2.right) \n && isMirrorUtil(root1.right, root2.left));\n }\n return false;\n }\n}\n" }, { "path": "The Bit Game easy s24.cpp", "content": "#include \nusing namespace std; \nclass Solution{ \npublic:\n int swapBitGame(long long N){\n // code here \n int win=0, swap=0;\n while(N>0){\n if((N&1)==1 && swap>0) win^=swap;\n if((N&1)==0) swap++;\n N>>=1;\n }\n return win>0? 1: 2;\n }\n};\n\nint main() \n{ \n int t;\n cin>>t;\n while(t--)\n {\n long long N;\n cin >> N;\n Solution ob;\n cout << ob.swapBitGame(N) << endl;\n }\n return 0; \n}" }, { "path": "The bit Game.cpp", "content": "class Solution{\npublic:\n int swapBitGame(long long N){\n int cnt=0;\n while(N>0){\n if((N&1)==1){\n cnt++;\n }\n N>>=1;\n }\n return cnt%2==0?2:1;\n }\n};\n" }, { "path": "Theft at World Bank - GFG/README.md", "content": "# Theft at World Bank\n## Easy \n
\n

The worlds most successful thief Albert Spaggiari was planning for his next heist on the world bank. He decides to carry a sack with him, which can carry a maximum weight of C kgs. Inside the world bank there were N large blocks of gold. All the blocks have some profit value associated with them i.e. if he steals ith block of weight w[i] then he will have p[i] profit. As blocks were heavy he decided to steal some part of them by cutting them with his cutter.
\nThe thief does not like symmetry, hence, he wishes to not take blocks or parts of them whose weight is a perfect square. Now, you need to find out the maximum profit that he can earn given that he can only carry blocks of gold in his sack. 
\nNote: The answer should be precise upto 3 decimal places.

\n\n

Example 1 :

\n\n
N = 3, C = 10\nw[] = {4, 5, 7}\np[] = {8, 5, 4)\nOutput: \n7.857\nExplanation: As first blocks weight is 4\nwhich is a perfect square, he will not use \nthis block. Now with the remaining blocks \nthe most optimal way is to use 2nd block \ncompletely and cut 5kg piece from the 3rd \nblock to get a total profit of 5 + 2.857 \n= 7.857
\n\n

Your Task:
\nYou don't need to read or print anything. Your task is to complete the function maximumProfit() which takes N, C, w[ ] and p[ ] as input parameters and returns the maximum profit thief can achieve with precision upto 3 decimal places.

\n\n

Expected Time Complexity: O(N * LogN)
\nExpected Space Complexity : O(N)

\n\n

Constraints:
\n1 ≤ N ≤ 103
\n1 ≤ C ≤ 1018
\n1 ≤ Wi ≤ 109
\n1 ≤ Pi ≤ 109

\n

\n
" }, { "path": "Theft at World Bank - GFG/theft-at-world-bank.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n String s1 = br.readLine().trim();\n String []S1 = s1.split(\" \");\n int n = Integer.parseInt(S1[0]);\n long C = Long.parseLong(S1[1]);\n String s2 = br.readLine().trim();\n String []S2 = s2.split(\" \");\n long [] w = new long[n];\n long [] p = new long[n];\n for(int i = 0; i < n; i++){\n w[i] = Long.parseLong(S2[2*i]);\n p[i] = Long.parseLong(S2[(2*i)+1]);\n }\n Solution ob = new Solution();\n double ans = ob.maximumProfit(n, C, w, p);\n String a1 = String.format(\"%.3f\",ans);\n System.out.println(a1);\n }\n }\n}\n// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Pair{\n long weight;\n long profit;\n double ratio;\n Pair(long weight, long profit, double ratio){\n this.weight=weight;\n this.profit=profit;\n this.ratio=ratio;\n }\n}\nclass Solution\n{\n public boolean isPerfect(long num){\n long sq=(long)Math.sqrt(num);\n return sq*sq==num;\n }\n public double maximumProfit(int n, long c, long w[], long p[])\n {\n Pair[] item=new Pair[n];\n for(int i=0;iDouble.compare(b.ratio, a.ratio));\n double total=0;\n int i=0;\n while(c>0){\n if(!isPerfect(item[i].weight)){\n long wgt=Math.min(c, item[i].weight);\n total+=(double)(wgt)*item[i].ratio;\n c-=wgt;\n }\n i++;\n }\n return total;\n }\n}" }, { "path": "Topo_sort.cpp", "content": "#include\nusing namespace std;\nvoid funct(vector adj[],vector &vis,stack&st,int node){\n vis[node]=1;\n for(auto it:adj[node]){\n if(!vis[it]){\n funct(adj,vis,st,it);\n }\n }\n st.push(node);\n}\n\nvoid topo(int n, vector adj[]){\n stack st;\n vector vis(n,0);\n for(int i =0;i v;\n while(!st.empty()){\n v.push_back(st.top());\n st.pop();\n }\n for(int i =0;i< v.size();i++){\n cout<>m>>n;\n vector adj[m];\n for(int i =0;i>x>>y;\n adj[x].push_back(y);\n }\n topo(m,adj);\n return 0;\n}\n" }, { "path": "Total Moves For Bishop!.java", "content": "public class Solution {\n public int solve(int A, int B) {\n int topLeft=Math.min(A-1,B-1);\n int topRight=Math.min(A-1,8-B);\n int botLeft=Math.min(8-A,B-1);\n int botRight=Math.min(8-A,8-B);\n return topLeft+topRight+botLeft+botRight;\n }\n}\n" }, { "path": "Towers_CSES.cpp", "content": "#include\nusing namespace std;\n#define ll long long\nvoid solve(){\n int n;\n cin>>n;\n multisetset;\n for(int i = 0; i>x;\n auto it = set.upper_bound(x);\n if(it == set.end()){\n set.insert(x);\n }\n else{\n set.erase(it);\n set.insert(x);\n }\n }\n cout<=0 && n2>=0){\n if(A.charAt(n1)==B.charAt(n2)){\n n1--;\n n2--;\n }else{\n n1--;\n res++;\n }\n }\n return res;\n }\n}\n" }, { "path": "Transform String - GFG/README.md", "content": "# Transform String\n## Medium \n
\n

Given two strings A and B. Find the minimum number of steps required to transform string A into string B. The only allowed operation for the transformation is selecting a character from string A and inserting it in the beginning of string A.

\n\n

Example 1:

\n\n
Input:\nA = \"abd\"\nB = \"bad\"\nOutput: 1\nExplanation: The conversion can take place in\n1 operation: Pick 'b' and place it at the front.
\n\n

Example 2:

\n\n
Input:\nA = \"GeeksForGeeks\"\nB = \"ForGeeksGeeks\"\nOutput: 3\nExplanation: The conversion can take\nplace in 3 operations:\nPick 'r' and place it at the front.\nA = \"rGeeksFoGeeks\"\nPick 'o' and place it at the front.\nA = \"orGeeksFGeeks\"\nPick 'F' and place it at the front.\nA = \"ForGeeksGeeks\"
\n\n

Your Task: 
\nYou dont need to read input or print anything. Complete the function transform() which takes two strings A and B as input parameters and returns the minimum number of steps required to transform A into B. If transformation is not possible return -1.

\n\n


\nExpected Time Complexity: O(N) where N is max(length of A, length of B) 
\nExpected Auxiliary Space: O(1)  

\n\n


\nConstraints:
\n1<= A.length(), B.length() <= 104

\n\n

 

\n

\n
" }, { "path": "Tree Path Sum.java", "content": "public class Solution {\n public int hasPathSum(TreeNode A, int B) {\n if(A==null) return 0;\n if(A.val==B && A.left==null && A.right==null) return 1;\n if(hasPathSum(A.left,B-A.val)==1) return 1;\n return hasPathSum(A.right,B-A.val);\n }\n}\n" }, { "path": "Triangle and Square - GFG/README.md", "content": "# Triangle and Square\n## Easy \n
\n

\"Lamp\" Geeks Summer Carnival is LIVE NOW  

Note: This POTD is a part of Geek Summer Carnival. Solve all POTD consecutively from 5th to 10th April and get a chance to win exclusive discount vouchers on our GfG courses.

\n\n
\n

Geek has a ticket to the Geek Summer Carnival. The ticket has a positive integer B written on it. B denotes the base of a right-angled isosceles triangle. 
\nGeek can avail discounts on X courses in the carnival.

\n\n

X is the maximum number of squares of size 2x2 units that can fit in the given right-angled isosceles triangle. 
\nFind X. 

\n\n


\nExample 1:

\n\n
Input:\nB = 8\nOutput:\n6 \nExplanation: \n\"\"\n
\n\n


\nExample 2:

\n\n
Input:\nB = 2\nOutput:\n0
\n\n


\nYour Task:
\nYou don't need to read input or print anything. Complete the function countSquare() that takes integer b as input parameter and returns the number of possible squares that can fit into the isosceles triangle. 

\n\n


\nExpected Time Complexity: O(1)
\nExpected Auxiliary Space: O(1)

\n\n

 

\n\n

Constraints:
\n1 <= B <= 1000

\n

\n
" }, { "path": "Triangle and Square - GFG/triangle-and-square.java", "content": "// { Driver Code Starts\n//Initial Template for Java\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass GFG{\n\tpublic static void main(String [] args) throws IOException{\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\t\tint test = Integer.parseInt(br.readLine());\n\t\twhile(test-- > 0) {\n\t\t\tint B = Integer.parseInt(br.readLine());\n\t\t\tSolution obj = new Solution();\n\t\t\tint count = obj.countSquare(B);\n\t\t\tSystem.out.println(count);\n\t\t}\n\t}\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n\tint countSquare(int B){\n\t\t//Write your code here\n\t\tB-=2;\n\t\tB/=2;\n\t\treturn B*(B+1)/2;\n\t}\n}" }, { "path": "Tricky Subset Problem - GFG/README.md", "content": "# Tricky Subset Problem\n## Medium \n
\n

N children are made to stand in a queue. Each of them is given a number A[i]. The teacher writes a number S on a page and passes it to the first child. Each child must add all the numbers they see on the page along with their own number, write the sum on the paper and pass it to the next person. 
\nIn the end, the teacher must determine if X can be formed by adding some of the numbers from the series of numbers written on the paper.

\n\n

Example 1:

\n\n
Input: \nS = 1, N = 4, X = 7\nA = {1, 2, 4, 2}\nOutput: yes\nExplaination: The final sequence of \nnumbers on the paper is 1, 2, 5, 12, 22. \nUsing 2 and 5 we can form 7.
\n\n


\nExample 2:

\n\n
Input: \nS = 100, N = 2, X = 500\nA = {51, 88}\nOutput: no\nExplaination: The final sequence of \nnumbers on the paper is 100, 151, 339. \nUsing these numbers we cannot form 500.
\n\n


\nYour Task:
\nYou do not need to read input or print anything. Your task is to complete the function isPossible() which takes S, N, X and array A as input parameters and returns 1 if there is a subset which adds to this sum. Otherwise returns 0.

\n\n


\nExpected Time Complexity: O(N)
\nExpected Auxiliary Space: O(N)
\n 

\n\n

Constraints
\n1 ≤ N ≤ 105
\n1 ≤ S, Ai , X ≤ 1018  

\n

\n
" }, { "path": "Tricky Subset Problem - GFG/tricky-subset-problem.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n long S = Long.parseLong(a[0]);\n int N = Integer.parseInt(a[1]);\n long X = Long.parseLong(a[2]);\n String a1[] = in.readLine().trim().split(\"\\\\s+\");\n long A[] = new long[N];\n for(int i = 0;i < N;i++)\n A[i] = Long.parseLong(a1[i]);\n \n Solution ob = new Solution();\n if(ob.isPossible(S, N, X, A) == 1)\n System.out.println(\"yes\");\n else\n System.out.println(\"no\");\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static int isPossible(long S, int N, long X, long A[])\n {\n int i=0;\n long s=S;\n for(i=0;iX){\n break;\n }\n }\n if(s==X)return 1;\n while(X>=0 && i>=0){\n if(X>=A[i])X-=A[i];\n if(X==0 || X-S==0)return 1;\n i--;\n }\n return 0;\n }\n}" }, { "path": "Two Sum.java", "content": "class Solution {\n public int[] twoSum(int[] nums, int target) {\n int i;\n int j;\n for (i=1;i List[int]:\n \n \n lookup_dict = {}\n \n for position, number in enumerate(nums):\n \n if target - number in lookup_dict:\n return lookup_dict[target-number], position\n \n else:\n lookup_dict[number] = position\n" }, { "path": "UTF-8-Validation med lc.cpp", "content": "#include\nusing namespace std;\n// TC : O(N) where N is the number of elements in data\n// SC: O(1) \nclass Solution {\npublic:\n bool validUtf8(vector& data) {\n int remaining = 0;\n for (auto& x : data) {\n if (remaining == 0) {\n if ((x >> 5) == 0b110) {\n remaining = 1;\n } else if ((x >> 4) == 0b1110) {\n remaining = 2;\n } else if ((x >> 3) == 0b11110) {\n remaining = 3;\n } else if ((x >> 7) != 0) {\n return false;\n }\n } else {\n if ((x >> 6) != 0b10) return false;\n else remaining--;\n }\n }\n return remaining == 0;\n }\n};\n" }, { "path": "Union-Find - GFG/README.md", "content": "# Union-Find\n## Easy \n
\n

This problem is to implement disjoint set union. There will be 2 incomplete functions namely union and find. You have to complete these functions. 

\n\n

Union: Join two subsets into a single set.
\nisConnected: Determine which subset a particular element is in. This can be used for determining if two elements are in same subset.

\n\n

Example 1:

\n\n
Input:\nN = 5\nq = 4\nQueries = \nUnion(1,3)\nisConnected(1,2)\nUnion(1,5)\nisConnected(3,5)\nOutput:\n0\n1\nExplanation: Initially all nodes 1 2 3 4 5\nare not connected. \nAfter Union(1,3), node 1 and 3 will be\nconnected.\nWhen we do isConnected(1,2),  as node 1\nand 2 are not connected it will return 0.\nAfter Union(1,5), node 1 and 5 will be\nconnected.\nWhen we do isConnected(3,5),  as node\n1 and 3 are connected, and node 1 and 5\nare connected, hence 3 and 5 are\nconnected. Thus it will return 1.
\n\n

Example 2:

\n\n
Input:\nN = 5\nq = 4\nQueries = \nUnion(1,4)\nUnion(1,5)\nisConnected(2,3)\nUnion(3,4)\nOutput: 0\n
\n\n

Your Task:

\n\n

You have to complete the function union_() which merges the node1 and node2. You will also have to complete the function isConnected() which will return whether the two nodes are connected.

\n\n

Note: Both function will contain two arrays par[] and ranks1[] along with two nodes. Initially par[i] = i and rank1[i] = 1 

\n\n

Expected Time Complexity: O(N + Q).
\nExpected Auxiliary Space: O(1).

\n\n

Constraints: 
\n1 <= N <= 105
\n1<= Q <= 105
\n1 <= node1, node2 <= N

\n

\n
" }, { "path": "Union-Find - GFG/union-find.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\n\npublic class GFG {\n public static void main(String[] args) throws IOException {\n \n //using BufferedReader to take input\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n \n //taking total testcases\n int t = Integer.parseInt(br.readLine());\n\n while(t-- > 0){\n \n //taking total number of elements\n int n = Integer.parseInt(br.readLine());\n \n int par[] = new int[n+1];\n int rank[] = new int[n+1];\n \n //initializing the parent and\n //the rank array\n for(int i = 1; i<=n; ++i){\n par[i] = i;\n rank[i] = 1;\n }\n int a = 0, b = 0;\n char c = '0';\n \n //taking number of queries\n int query = Integer.parseInt(br.readLine());\n \n Boolean output = false;\n while(query-- >0){\n String str[] = br.readLine().trim().split(\" \");\n c = str[0].charAt(0);\n a = Integer.parseInt(str[1]);\n b = Integer.parseInt(str[2]);\n\n //if query type is 'U'\n //then calling union_ method\n if(c == 'U'){\n new Solution().union_(a, b, par, rank);\n }\n else{//else calling isConnected() method\n output = new Solution().isConnected(a, b, par, rank);\n if(output == true)\n System.out.println(\"1\");\n else\n System.out.println(\"0\");\n }\n }\n\n\n\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\n\nclass Solution\n{\n public int findPar(int node,int par[]){\n if(node==par[node])return node;\n return par[node]=findPar(par[node],par);\n }\n //Function to merge two nodes a and b.\n public void union_(int a, int b, int par[], int rank[])\n {\n a=findPar(a,par);\n b=findPar(b,par);\n if(rank[a]\n

Given an array arr[] of integers of size N that might contain duplicates, the task is to find all possible unique subsets.

\n\n

Note: Each subset should be sorted.

\n\n

Example 1:

\n\n
Input: N = 3, arr[] = {2,1,2}\nOutput:(),(1),(1 2),(1 2 2),(2),(2 2)\nExplanation: \nAll possible subsets = (),(2),(1),(1,2),(2),(2,2),(2,1),(2,1,2)\nAfter Sorting each subset = (),(2),(1),(1,2),(2),(2,2),(1,2),(1,2,2) \nUnique Susbsets in Lexicographical order = (),(1),(1,2),(1,2,2),(2),(2,2)\n
\n\n

Example 2:

\n\n
Input: N = 4, arr[] = {1,2,3,3}\nOutput: (),(1),(1 2),(1 2 3)\n(1 2 3 3),(1 3),(1 3 3),(2),(2 3)\n(2 3 3),(3),(3 3)
\n\n

Your Task:
\nYour task is to complete the function AllSubsets() which takes the array arr[] and N as input parameters and returns list of all possible unique subsets in lexicographical order. 

\n\n

Expected Time Complexity: O(2N).
\nExpected Auxiliary Space: O(2N * X), X = Length of each subset.

\n\n

Constraints:
\n1 ≤ N ≤ 12
\n1 ≤ arr[i] ≤ 9

\n

\n " }, { "path": "Unique Subsets - GFG/unique-subsets.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nclass GFG {\n \n \n\tpublic static void main (String[] args) {\n\t\tScanner sc = new Scanner(System.in);\n\t\tint testCases = sc.nextInt();\n\t\tfor(int t=0;t> res = new solve().AllSubsets(arr,n);\n\t\t for (int i = 0; i < res.size (); i++)\n\t\t {\n\t\t System.out.print (\"(\");\n\t\t for (int j = 0; j < res.get(i).size (); j++)\n\t\t {\n\t\t if (j != res.get(i).size()-1)\n\t\t System.out.print ((res.get(i)).get(j) + \" \");\n\t\t else\n\t\t System.out.print ((res.get(i)).get(j));\n\t\t }\n\t\t System.out.print (\")\");\n\t\t \n\t\t }\n\t\t System.out.println();\n\t\t}\n\t}\n}// } Driver Code Ends\n\n\nclass solve{\n public static ArrayList > AllSubsets(int arr[], int n){\n Arrays.sort(arr);\n ArrayList> ans= new ArrayList<>();\n ArrayList al=new ArrayList<>();\n check(arr,n,0,ans,al);\n ans.remove(0);\n return ans;\n }\n \n public static void check(int arr[], int n,int index,ArrayList> ans,ArrayList al){\n if(!ans.contains(al))ans.add(al);\n if(index==n) return;\n ArrayList temp=new ArrayList<>(al);\n temp.add(arr[index]);\n check(arr,n,index+1,ans,temp);\n check(arr,n,index+1,ans,al);\n }\n\n\n}\n" }, { "path": "Unit Area of largest region of 1's.cpp", "content": "class Solution\n{\n public:\n //Function to find unit area of the largest region of 1s.\n void solve(vector> &grid , int i , int j , int n , int m , int &cnt)\n {\n if(i < 0 || j < 0 || i >= n || j >= m || grid[i][j] == 0)\n return;\n \n cnt+=1;\n grid[i][j] = 0;\n \n // 8 directions\n solve(grid,i-1,j,n,m ,cnt);\n solve(grid,i+1,j,n,m ,cnt);\n solve(grid,i,j-1,n,m ,cnt);\n solve(grid,i,j+1,n,m ,cnt);\n solve(grid,i-1,j-1,n,m ,cnt);\n solve(grid,i-1,j+1,n,m ,cnt);\n solve(grid,i+1,j-1,n,m ,cnt);\n solve(grid,i+1,j+1,n,m ,cnt);\n }\n \n int findMaxArea(vector>& grid) \n {\n int ans = 0;\n int n = grid.size() , m = grid[0].size();\n for(int i = 0;i>& grid, int i, int j)\n// {\n// if(i < 0 or i >= n or j < 0 or j >= m or grid[i][j] == 0)\n// return 0;\n \n// int ans = 1;\n// grid[i][j] = 0;\n \n// for(int d=0; d<8; d++)\n// ans += countArea(grid, i+dx[d], j+dy[d]);\n \n// return ans;\n// }\n \n// //Function to find unit area of the largest region of 1s.\n// int findMaxArea(vector>& grid) {\n// // Code here\n// n = grid.size();\n// m = grid[0].size();\n \n// int ans = 0;\n \n// for(int i=0; i=ROW || col>=COL || visited[row][col] || grid[row][col]==0)\n return false;\n return true; \n }\n\n \n void DFS(int[][] grid,int row,int col,boolean[][] visited,int ROW,int COL)\n {\n int[] x = { -1, -1, -1, 0, 0, 1, 1, 1 };\n int[] y = { -1, 0, 1, -1, 1, -1, 0, 1 };\n\n visited[row][col] = true;\n\n for (int k = 0; k < 8; k++) \n {\n if (isSafe(grid, row + x[k], col + y[k],visited, ROW, COL)) \n {\n count++;\n DFS(grid, row + x[k], col + y[k],visited, ROW, COL);\n }\n }\n }\n \n public int findMaxArea(int[][] grid)\n {\n int ROW = grid.length;\n int COL = grid[0].length;\n \n boolean[][] visited = new boolean[ROW][COL];\n\n int result = 0;\n \n for (int i = 0; i < ROW; i++) \n {\n for (int j = 0; j < COL; j++) \n {\n \n if (grid[i][j] == 1 && !visited[i][j]) \n {\n count = 1;\n DFS(grid, i, j, visited, ROW, COL);\n\n result = Math.max(result, count);\n }\n }\n }\n return result;\n }\n}\n\n \n \n" }, { "path": "Valid Binary Search Tree.java", "content": "public class Solution {\n int check(TreeNode a,int min,int max){\n if(a==null)return 1;\n if(a.valmax)return 0;\n return check(a.left,min,a.val-1)& check(a.right,a.val+1,max);\n }\n public int isValidBST(TreeNode root) {\n return check(root,Integer.MIN_VALUE,Integer.MAX_VALUE);\n }\n}\n" }, { "path": "Valid Mountain Array.java", "content": "class Solution {\n public boolean validMountainArray(int[] A) {\n int N = A.length;\n int i = 0;\n\n // walk up\n while (i+1 < N && A[i] < A[i+1])\n i++;\n\n // peak can't be first or last\n if (i == 0 || i == N-1)\n return false;\n\n // walk down\n while (i+1 < N && A[i] > A[i+1])\n i++;\n\n return i == N-1;\n }\n}\n" }, { "path": "Valid Parentheses.java", "content": "class Solution {\n public boolean isValid(String s) {\n\t\tchar[] stack = new char[s.length()];\n\t\tint head = 0;\n\t\tfor(char c : s.toCharArray()) {\n\t\t\tswitch(c) {\n\t\t\t\tcase '{':\n\t\t\t\tcase '[':\n\t\t\t\tcase '(':\n\t\t\t\t\tstack[head++] = c;\n\t\t\t\t\tbreak;\n\t\t\t\tcase '}':\n\t\t\t\t\tif(head == 0 || stack[--head] != '{') return false;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ')':\n\t\t\t\t\tif(head == 0 || stack[--head] != '(') return false;\n\t\t\t\t\tbreak;\n\t\t\t\tcase ']':\n\t\t\t\t\tif(head == 0 || stack[--head] != '[') return false;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn head == 0;\n }\n}\n" }, { "path": "Valid Password.java", "content": "public class Solution {\n public int solve(String A) {\n if(A.length()<8 || A.length()>15)return 0;\n boolean num=false;\n boolean lower=false;\n boolean upper=false;\n boolean spcl=false;\n for(int i=0;i='0' && ch<='9')num=true;\n if(ch>='a' && ch<='z')lower=true;\n if(ch>='A' && ch<='Z')upper=true;\n if(ch=='@' || ch=='#' || ch=='%'||ch=='&'||ch=='!'||ch=='$'||ch=='*')spcl=true;\n }\n return num && lower && upper && spcl?1:0;\n }\n}\n" }, { "path": "Validate Stack Sequences.java", "content": "class Solution {\n public boolean validateStackSequences(int[] a, int[] b) {\n Deque st=new ArrayDeque<>();\n int i=0;\n int j=0;\n st.push(a[i]);\n i++;\n while(i=0&&arr[i]==pop[j])\n {\n i--;\n j++;\n }\n }\n if(i==-1&&j==n)\n return true;\n return false;\n \n }\n}\n" }, { "path": "Verify Prime.java", "content": "static boolean prime(int n)\n{\n // Corner cases\n if (n <= 1)\n return false;\n if (n <= 3)\n return true;\n \n // This is checked so that we can skip\n // middle five numbers in below loop\n if (n % 2 == 0 || n % 3 == 0)\n return false;\n \n for (int i = 5; i * i <= n; i += 6)\n if (n % i == 0 || n % (i + 2) == 0)\n return false;\n \n return true;\n}\n" }, { "path": "Vertical Sum of a Binary Tree.java", "content": "/**\n * Definition for binary tree\n * class TreeNode {\n * int val;\n * TreeNode left;\n * TreeNode right;\n * TreeNode(int x) {\n * val = x;\n * left=null;\n * right=null;\n * }\n * }\n */\npublic class Solution {\n int min;\n int max;\n public ArrayList verticalSum(TreeNode A) {\n min=Integer.MAX_VALUE;\n max=Integer.MIN_VALUE;\n ArrayList arr=new ArrayList<>();\n Map map=new HashMap<>();\n dfs(A,map,0);\n while(min<=max){\n arr.add(map.get(min));\n min++;\n }\n return arr;\n }\n public void dfs(TreeNode a,Map map,int curr){\n if(a==null)return;\n map.put(curr,map.getOrDefault(curr,0)+a.val);\n min=Math.min(min,curr);\n max=Math.max(max,curr);\n dfs(a.left,map,curr-1);\n dfs(a.right,map,curr+1);\n }\n}\n" }, { "path": "Villain Con - GFG/README.md", "content": "# Villain Con\n## Medium \n
\n

The minions are very elitist in nature. If minion x admires minion y, then y thinks too highly of himself and does not admire x back. Also, if x admires y, x also admires everyone that y admires.
\nAll the minions are going to be present at the Villain Con. They want to make sure that they do not dress in the same color as someone who admires them. 
\nThere are N minions and M relations between them. The relations are given in a 2D array mat. Each relation is given in xi , yi format where yi admires xi. Find the minimum number of different colours that the minions will be dressing in. 

\n\n

 

\n\n

Example 1:

\n\n
Input: \nN = 5, M = 6\nmat = {{1, 3}, \n       {2, 3}, \n       {3, 4}, \n       {1, 4}, \n       {2, 5}, \n       {3, 5}}\nOutput: 3\nExplaination:\nIf we assign red colour to 1 and 2,\ngreen colour to 3, and blue colour to 4 and 5, then\nevery minion will have different coloured dresses\nfrom the one who admires them.
\n\n

Example 2:

\n\n
Input:\nN = 3, M = 2\nmat = {{1,3},{2,3}}\nOutput:\n2\nExplanation:\nIf we assign red colour to 1 and 2, and green colour to 3, then the condition is satisfied.
\n\n

Your Task:
\nYou do not need to read input or print anything. Your task is to complete the function minColour() which takes N, M and mat[][] as input parameters and returns the minimum number of colours required.

\n\n

 

\n\n

Expected Time Complexity: O(N+M)
\nExpected Auxiliary Space: O(N+M)

\n\n

 

\n\n

Constraints:
\n1 ≤ N ≤ 105
\n1 ≤ M ≤ 2*105  
\n1 ≤ xi , yi ≤ N

\n

\n
" }, { "path": "Villain Con - GFG/villain-con.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0) {\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(a[0]);\n int M = Integer.parseInt(a[1]);\n int mat[][] = new int[M][2];\n for(int i = 0;i < M;i++){\n String a1[] = in.readLine().trim().split(\"\\\\s+\");\n mat[i][0] = Integer.parseInt(a1[0]);\n mat[i][1] = Integer.parseInt(a1[1]);\n }\n \n Solution ob = new Solution();\n System.out.println(ob.minColour(N, M, mat));\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static int minColour(int N, int M, int mat[][]) {\n Queue q = new LinkedList<>();\n int[] indegree = new int[N+1];\n ArrayList> adj = new ArrayList<>();\n for(int i=0;i<=N;i++){\n adj.add(new ArrayList<>());\n }\n for(int[] row : mat){\n indegree[row[0]]++;\n adj.get(row[1]).add(row[0]);\n }\n \n for(int i=0;i<=N;i++){\n if(indegree[i] == 0){\n q.offer(i);\n }\n }\n \n \n int count = 0;\n \n \n while(!q.isEmpty()){\n count++;\n int size = q.size();\n while(size-->0){\n int currVertex = q.poll();\n for(int neighbor : adj.get(currVertex)){\n if(indegree[neighbor] == 1){\n q.offer(neighbor);\n }\n indegree[neighbor]--;\n }\n }\n }\n \n return count;\n }\n}" }, { "path": "Vowel and Consonant Substrings!.java", "content": "public class Solution {\n int mod=1000000007;\n public int solve(String A) {\n int ans=0;\n int con=0;\n int vow=0;\n for(int i=A.length()-1;i>=0;i--){\n char c=A.charAt(i);\n if(vowel(c)){\n vow++;\n ans+=con;\n }else{\n con++;\n ans+=vow;\n }\n ans%=mod;\n }\n return ans;\n }\n public boolean vowel(char c){\n if(c=='a' || c=='e' || c=='i' || c=='o' || c=='u'){\n return true;\n }\n return false;\n }\n}\n" }, { "path": "Wave Array.java", "content": "public class Solution {\n public ArrayList wave(ArrayList arr) {\n Collections.sort(arr);\n int i=0;\n while(i+1 0) {\n ways += dp[i-1];\n ways %= mod;\n }\n dig = s.substring(i-2, i);\n if(Integer.parseInt(dig) >= 10 && Integer.parseInt(dig) <= 26) {\n ways += dp[i-2];\n ways %= mod;\n }\n dp[i] = ways;\n }\n return dp[n];\n }\n}\n" }, { "path": "Window String.java", "content": "public class Solution {\n public String minWindow(String A, String B) {\n int want=B.length();\n int count=0;\n StringBuilder sb=new StringBuilder();\n String ans=null;\n Map map=new HashMap<>();\n Map curr=new HashMap<>();\n for(char c:B.toCharArray()){\n map.put(c,map.getOrDefault(c,0)+1);\n }\n \n int i=0;\n int j=0;\n while(jsb.length()){\n ans=sb.toString();\n }\n char c=A.charAt(j);\n sb.deleteCharAt(0);\n curr.put(c,curr.get(c)-1);\n if(!map.containsKey(c)){\n j++;\n continue;\n }\n if(curr.get(c)\n

Given a string s and a dictionary of words dict of length n, add spaces in s to construct a sentence where each word is a valid dictionary word. Each dictionary word can be used more than once. Return all such possible sentences.

\n\n

Follow examples for better understanding.

\n\n

Example 1:

\n\n
Input: s = \"catsanddog\", n = 5 \ndict = {\"cats\", \"cat\", \"and\", \"sand\", \"dog\"}\nOutput: (cats and dog)(cat sand dog)\nExplanation: All the words in the given \nsentences are present in the dictionary.
\n\n

Example 2:

\n\n
Input: s = \"catsandog\", n = 5\ndict = {\"cats\", \"cat\", \"and\", \"sand\", \"dog\"}\nOutput: Empty\nExplanation: There is no possible breaking \nof the string s where all the words are present \nin dict.
\n\n

Your Task:
\nYou do not need to read input or print anything. Your task is to complete the function wordBreak() which takes n, dict and s as input parameters and returns a list of possible sentences. If no sentence is possible it returns an empty list.

\n\n

Expected Time Complexity: O(N2*n) where N = |s|
\nExpected Auxiliary Space: O(N2)

\n\n

Constraints:
\n1 ≤ n ≤ 20
\n1 ≤ dict[i] ≤ 15
\n1 ≤ |s| ≤ 500 

\n

\n " }, { "path": "Word Break - Part 2 - GFG/word-break-part-2.java", "content": "// { Driver Code Starts\n//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nimport java.util.stream.*;\n\nclass GFG{\n public static void main(String args[])throws IOException\n {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n int n = Integer.parseInt(in.readLine());\n String arr[] = in.readLine().trim().split(\"\\\\s+\");\n List dict = new ArrayList();\n for(int i = 0;i < n;i++)\n dict.add(arr[i]);\n String s = in.readLine();\n \n Solution ob = new Solution();\n List ans = new ArrayList();\n ans = ob.wordBreak(n, dict, s);\n if(ans.size() == 0)\n System.out.println(\"Empty\");\n else{\n List sol = ans.stream().sorted().collect(Collectors.toList());\n for(int i = 0;i < sol.size();i++)\n System.out.print(\"(\"+sol.get(i)+\")\");\n System.out.println();\n }\n }\n }\n}// } Driver Code Ends\n\n\n//User function Template for Java\n\nclass Solution{\n static List wordBreak(int n, List dict, String s)\n {\n // code here\n List ans=new ArrayList<>();\n dfs(dict,s,\"\",ans);\n return ans;\n }\n static void dfs(List dict,String s,String sentence,List ans){\n if(s.length()==0){\n ans.add(sentence.substring(0,sentence.length()-1));\n }\n \n for(int i=0;ians;\n void backTrack(int i, string &s, string t, vector& wordDict){\n if(i == s.size()){\n t.pop_back();\n ans.push_back(t);\n return;\n }\n for(auto &w : wordDict){\n int n = w.size();\n string str = s.substr(i, n);\n \n if(w == str){\n backTrack(i + n, s, t + str + \" \", wordDict);\n }\n }\n }\n vector wordBreak(string s, vector& wordDict) {\n backTrack(0, s, \"\", wordDict);\n return ans;\n }\n};\n" }, { "path": "Word Break II.java", "content": "public class Solution {\n ArrayList> dp;\n public ArrayList wordBreak(String A, ArrayList B) {\n dp = new ArrayList<>();\n for(int i = 0;i());\n }\n Set set = new HashSet<>();\n for(String str:B){\n set.add(str);\n }\n return wordBreak(A,set,0);\n }\n public ArrayList wordBreak(String A, Set set, int i) {\n if(i==A.length()){\n return new ArrayList();\n }\n if(dp.get(i).size()!=0)\n return dp.get(i);\n ArrayList ans = new ArrayList<>();\n for(int j = i+1;j<=A.length();j++){\n if(set.contains(A.substring(i,j))){\n ArrayList buf = wordBreak(A,set,j);\n for(String a: buf){\n ans.add(A.substring(i,j)+\" \"+a);\n }\n if(j==A.length()){\n ans.add(A.substring(i));\n }\n }\n }\n dp.set(i,ans);\n return ans;\n }\n}\n\n" }, { "path": "Word Break.java", "content": "public class Solution {\n public int wordBreak(String A, String[] B) {\n Set set = new HashSet<>();\n for (String s : B) {\n set.add(s);\n }\n Boolean[] dp = new Boolean[A.length()];\n return wordBreak(A, set, 0, dp);\n }\n \n private int wordBreak(String s, Set set, int start, Boolean[] dp) {\n if (start == s.length()) {\n return 1;\n }\n if (dp[start] != null) return dp[start] ? 1 : 0;\n \n int ans = 0;\n for (int end = start + 1; end <= s.length(); end++) {\n if (set.contains(s.substring(start, end)) && wordBreak(s, set, end, dp) == 1) {\n ans = 1;\n break;\n }\n }\n \n dp[start] = ans == 1;\n return ans;\n }\n}\n\n" }, { "path": "Word Count.py", "content": "class Solution:\n # @param A : string\n # @return an integer\n def solve(self, A):\n list1=A.split(' ')\n i=0\n k=len(list1)\n while i& wordList) {\n if(startWord==targetWord){\n for(int i=0;i> st;\n st.push({startWord, 1});\n set sr;\n \n while(!st.empty()){\n auto tp = st.front();\n sr.insert(tp.first);\n if(tp.first==targetWord) return tp.second;\n st.pop();\n \n for(int i=0; i List[List[str]]:\n #generate\n Nei = defaultdict(list)\n for word in wordList:\n for i in range(len(word)):\n pattern = word[:i]+'*'+word[i+1:]\n Nei[pattern].append(word) \n \n #breadth first search + generate parent dictionary with path length limit\n seen = {beginWord:0}\n q = deque([(beginWord,0)])\n minDist = float(\"inf\")\n Parent = defaultdict(set)\n while q: \n for _ in range(len(q)):\n pre,dis = q.popleft()\n for i in range(len(pre)):\n pattern = pre[:i] + \"*\" + pre[i+1:]\n for neighbor in Nei[pattern]:\n if neighbor not in seen or (seen[neighbor] == dis + 1 and seen[neighbor] <= minDist):\n if neighbor == endWord: \n minDist = dis + 1\n Parent[neighbor].add(pre)\n if neighbor not in seen: \n q.append((neighbor,dis+1))\n seen[neighbor] = dis + 1\n\t\t\t\t\t\t\t\t\n #generate path from parent dictionary\n def makeList(cur,Path):\n if cur == beginWord:\n res.append(Path)\n else:\n for parent in Parent[cur]:\n makeList(parent,[parent] + Path)\n res = []\n makeList(endWord,[endWord])\n \n #return results\n return res\n \n" }, { "path": "Word Ladder.java", "content": "class Solution {\n public int ladderLength(String beginWord, String endWord, List wordList) {\n if (wordList == null || wordList.size() == 0) return 0;\n //Hashset benefits: deduplication is also completed\n //start end\n HashSet start = new HashSet<>();\n //end\n HashSet end = new HashSet<>();\n //dictionary of all strings\n HashSet dic = new HashSet<>(wordList);\n start.add(beginWord);\n end.add(endWord);\n if (!dic.contains(endWord)) return 0;\n //After going through the above series of judgments, when you get here, if there is a path, the minimum is 2, so start with 2\n return bfs(start, end, dic, 2);\n\n }\n\n public int bfs(HashSet st, HashSet ed, HashSet dic, int l) {\n //When searching with two ends, if any segment is \"broken\", that is to say, there is no path that can be connected, it will return 0 directly.\n if (st.size() == 0) return 0;\n if (st.size() > ed.size()) {//Double-ended search, in order to optimize the time, always use less to find more. For example, if 1000 are inserted at the beginning, but only 3 at the end, it is definitely better to start from the less end.\n return bfs(ed, st, dic, l);\n }\n //Marking behavior of BFS, i.e. used not reused\n dic.removeAll(st);\n //Collect next level proximity points\n HashSet next = new HashSet<>();\n for (String s : st) {\n char[] arr = s.toCharArray();\n for (int i = 0; i < arr.length; i++) {\n char tmp = arr[i];\n //Variety\n for (char c = 'a'; c <= 'z'; c++) {\n if (tmp == c) continue;\n arr[i] = c;\n String nstr = new String(arr);\n if (dic.contains(nstr)) {\n if (ed.contains(nstr)) return l;\n else next.add(nstr);\n }\n }\n //Variety\n arr[i] = tmp;\n }\n }\n return bfs(next, ed, dic, l + 1);\n }\n}\n" }, { "path": "Word Pattern.java", "content": "class Solution {\n public boolean wordPattern(String pattern, String s) {\n String[] words = s.split(\" \");\n Map wordMap = new HashMap<>();\n Map charMap = new HashMap<>();\n if(pattern.length()!=words.length){\n return false;\n }\n for(int i= 0;i\n

\n
\n
\n

Given an array nums[] of size n, where nums[i] denotes the number of characters in one word. Let K be the limit on the number of characters that can be put in one line (line width). Put line breaks in the given sequence such that the lines are printed neatly.
\nAssume that the length of each word is smaller than the line width. When line breaks are inserted there is a possibility that extra spaces are present in each line. The extra spaces include spaces put at the end of every line except the last one. 

\n\n

You have to minimize the following total cost where total cost = Sum of cost of all lines, where cost of line is = (Number of extra spaces in the line)2.

\n\n

Example 1:

\n\n
Input: nums = {3,2,2,5}, k = 6\nOutput: 10\nExplanation: Given a line can have 6\ncharacters,\nLine number 1: From word no. 1 to 1\nLine number 2: From word no. 2 to 3\nLine number 3: From word no. 4 to 4\nSo total cost = (6-3)2 + (6-2-2-1)2 = 32+12 = 10.\nAs in the first line word length = 3 thus\nextra spaces = 6 - 3 = 3 and in the second line\nthere are two word of length 2 and there already\n1 space between two word thus extra spaces\n= 6 - 2 -2 -1 = 1. As mentioned in the problem\ndescription there will be no extra spaces in\nthe last line. Placing first and second word\nin first line and third word on second line\nwould take a cost of 02 + 42 = 16 (zero spaces\non first line and 6-2 = 4 spaces on second),\nwhich isn't the minimum possible cost.\n
\n\n

Example 2:

\n\n
Input: nums = {3,2,2}, k = 4\nOutput: 5\nExplanation: Given a line can have 4 \ncharacters,\nLine number 1: From word no. 1 to 1\nLine number 2: From word no. 2 to 2\nLine number 3: From word no. 3 to 3\nSame explaination as above total cost\n= (4 - 3)2 + (4 - 2)2 = 5.\n
\n\n


\nYour Task:
\nYou don't need to read or print anyhting. Your task is to complete the function solveWordWrap() which takes nums and k as input paramater and returns the minimized total cost.
\n 

\n\n

Expected Time Complexity: O(n2)
\nExpected Space Complexity: O(n)
\n 

\n\n

Constraints:
\n1 ≤ n ≤ 500
\n1 ≤ nums[i] ≤ 1000
\nmax(nums[i]) ≤ k ≤ 2000

\n
\n
\n
\n

\n " }, { "path": "Word Wrap - GFG/word-wrap.java", "content": "// { Driver Code Starts\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG\n{\n public static void main(String[] args) throws IOException\n {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int T = Integer.parseInt(br.readLine().trim());\n while(T-->0)\n {\n int n = Integer.parseInt(br.readLine().trim());\n int[] nums = new int[n];\n String[] S = br.readLine().trim().split(\" \");\n for(int i = 0; i < n; i++)\n nums[i] =Integer.parseInt(S[i]);\n int k = Integer.parseInt(br.readLine().trim());\n Solution obj = new Solution();\n System.out.println(obj.solveWordWrap(nums, k));\n }\n }\n}\n// } Driver Code Ends\n\n\nclass Solution{\n public int solveWordWrap (int[] nums, int k){\n return solveWordWrapRec(nums, k, 0, new HashMap<>());\n }\n \n public int solveWordWrapRec (int[] nums, int k, int idx, Map cache){\n if(idx >= (nums.length-1)){\n return 0;\n }\n \n Integer value = cache.get(idx);\n if(value != null) return value;\n \n int cost = Integer.MAX_VALUE;\n int used = 0;\n \n for(int i=idx; i k) break;\n \n if(i+1 < nums.length){\n cost = Math.min(cost, solveWordWrapRec(nums, k, i+1, cache) + getCost(nums, idx, i, k));\n }else{\n cost = Math.min(cost, getCost(nums, idx, i, k));\n }\n used += nums[i] + 1;\n }\n value = cost;\n cache.put(idx, value);\n \n return value;\n }\n \n private int getCost(int[] nums, int from, int to, int k){\n if(to == nums.length-1) return 0;\n int used = 0;\n \n for(int i=from; i<=to; i++){\n if(used > 0) used++;\n used += nums[i]; \n }\n \n return (k-used)*(k-used);\n }\n}" }, { "path": "X Total Shapes.java", "content": "\nclass Solution\n{\n //Function to find the number of 'X' total shapes.\n public int xShape(char[][] grid)\n {\n // code here\n int ans=0;\n int n=grid.length;\n int m=grid[0].length;\n boolean[][] vis=new boolean[n][m];\n for(int i=0;i0){\n dfs(grid,i-1,j,vis);\n }\n if(i0){\n dfs(grid,i,j-1,vis);\n }\n if(j> 1;\n // int b = a ^ k;\n // return Math.abs(a - b) == 1? Math.min(a,b): -1;\n if (k % 2 == 0)\n return -1;\n \n if ((k & (k+1)) != 0)\n return -1;\n \n if (k == 1)\n return 2;\n \n return k>>1;\n }\n}\n" }, { "path": "XOR-ing the Subarrays!.java", "content": "public class Solution {\n public int solve(int[] A) {\n int ans=0;\n if(A.length%2==0)return ans;\n for(int i=0;i> zigzagLevelOrder(TreeNode root) {\n ArrayList> res = new ArrayList<>();\n if(root==null)\n return res;\n Queue q = new LinkedList<>();\n q.offer(root);\n \n int p=0;\n \n while(!q.isEmpty())\n {\n int l = q.size();\n List level = new ArrayList<>();\n for(int i=0;i(level));\n p++;\n }\n return res;\n }\n}\n\n" }, { "path": "Zigzag String.java", "content": "public class Solution {\n public String convert(String input, int num) {\n if(num<=1){\n return input;\n }\n StringBuilder result = new StringBuilder();\n List list = new ArrayList<>();\n for (int i = 0; i < num; i++) {\n list.add(new StringBuilder());\n }\n boolean l2r = true;\n int i = 0;\n int size = input.length();\n int ptr = 0;\n while (i < size) {\n if (l2r) {\n while (ptr < num && i < size) {\n list.get(ptr).append(input.charAt(i));\n i++;\n ptr++;\n }\n ptr -= 2;\n l2r = false;\n } else {\n while (ptr >= 0 && i < size) {\n list.get(ptr).append(input.charAt(i));\n i++;\n ptr--;\n }\n ptr = 1;\n l2r = true;\n }\n }\n for (StringBuilder temp : list) {\n result.append(temp);\n }\n return result.toString();\n }\n \n}\n\n" }, { "path": "alternate positive and negative.cpp", "content": "\tvoid rearrange(int arr[], int n) {\n // code here\n vector A;\n vector B;\n for (int i=0; i& nums) {\n \n int size = nums.size();\n int count = 0;\n\n for(int x=0; x nums[(x+1)%size])\n count ++;\n }\n return (count <= 1);\n \n // in case of sorted and rotated array the count is 1 and in case of only sorted array the count is 0\n // in case of non-sorted and non-rotated array the count is greater than 1 so false.\n }\n};\n" }, { "path": "depth first search.cpp", "content": "#include \n#include \nusing namespace std;\n\nvoid dfs(vector* adj,int node,vector& visited)\n{\n visited[node]=1;\n cout<>n>>e; // n is number of vertix\n // e is number of edges\n \n vector adj[n];\n while(e--)\n {\n int u,v;\n cin>>u>>v;\n adj[u].push_back(v);\n adj[v].push_back(u);\n }\n \n vector visited(n,0);\n for(int i=0;i& nums, int k) { \n // eg 1 2 3 4 5 6 7\n k %= nums.size();\n reverse(nums.begin(), nums.end()); // reverse full 7 6 5 4 3 2 1\n reverse(nums.begin(), nums.begin()+k); // reverse till first k 5 6 7 4 3 2 1\n reverse(nums.begin()+k, nums.end()); // reverse till end from k 5 6 7 1 2 3 4 \n }\n};\n" }, { "path": "sorting-characters-by-frequency/sorting-characters-by-frequency.cpp", "content": "bool compare(const string& a, const string &b){\n return a.length() > b.length();\n}\nclass Solution {\npublic: \n string frequencySort(string s) {\n \n // 1.\n // unordered_map mp;\n // for(int i=0;i 0){\n // int maxFre = -1;\n // char ch;\n // for(auto it : mp){\n // if(maxFre < it.second){\n // maxFre = it.second;\n // ch = it.first;\n // }\n // }\n // mp.erase(ch);\n // for(int i=0;i freq(100,\"\");\n for (char a : s) freq[a-'0'] += a;\n sort(freq.begin(), freq.end(), compare);\n s = \"\";\n for (string str : freq) s += str;\n return s;\n // what it does is it is appending the string at the position of characters based on their indexes in alphabet order\n // like for tree it storing like for position 4(0-based indexing) ee, 19 - t and 17 - r\n // and then sorting based on length of strings. \n \n }\n};\n" }, { "path": "split array into consecutive subsequences/split-array-into-consecutive-subsequences.cpp", "content": "class Solution {\npublic:\n bool isPossible(vector& nums) {\n int n = nums.size(); \n unordered_mapm, m1; \n // to store the frequency of each element\n for(int i=0;i0){// step 3. earlier explained\n m1[it-1]--;\n m1[it]++;\n }else if(m[it+1] != 0 and m[it+2] != 0){ // step 4. --> if(next 2 consecutive elements present in the map) like if it == 1 then if 2 and 3 is present in the map or not if not then false else reduce their freq and store the last element's freq in second map\n m[it+1]--;\n m[it+2]--;\n m1[it+2]++;\n }\n // if for test case 1 2 3 3 4 4 5 5 answer is true but our algo return false when reached to 4 so to overcome it we are using m1 and doing step 3, like if for 4 if 3 is present in m1 then add 4 also to one of the subsequence.\n // https://youtu.be/Gmc-4Dpzw2g -- video for reference\n else{\n return false;\n }\n }\n return true;\n }\n};\n" }, { "path": "string-to-integer(atoi)/string-to-integer(atoi).cpp", "content": "#include\nclass Solution {\npublic:\n int myAtoi(string str) {\n long long res = 0;\n int i=0, len = str.length();\n bool neg = false;\n while(str[i]==' ') i++; // skip all the spaces in starting\n if(str[i]=='+') i++; // skip + in starting\n else if(str[i]=='-') {i++; neg=true;} // skip - in starting\n\n while(str[i]>='0' && str[i]<='9'){\n res = res*10 + (str[i]-'0');\n if(res>=INT_MAX && !neg) {res = INT_MAX; break;}\n else if(res>INT_MAX && neg) {res = INT_MIN; break;}\n i++;\n }\n\n if (neg) res *= -1;\n return (int)res;\n }\n};\n" }, { "path": "sum of k smallest elements in BST.cpp", "content": "void inorder(Node* node,vector &ans)\n{\n if(node==NULL)\n return ;\n inorder(node->left,ans);\n ans.push_back(node->data);\n inorder(node->right,ans);\n}\n\nint sum(Node* root, int k) \n{ \n \n // Your code here\n int sum=0;\n vector ans;\n inorder(root,ans);\n int cnt=0;\n for(int i=0;i stack = new Stack();\n for(char c: s.toCharArray()){\n if(c == '(' || c == '[' || c == '{'){ \n stack.push(c);\n }\n else if(c == ')' && !stack.isEmpty() && stack.peek() == '(' ){ \n stack.pop();\n }\n else if(c == ']' && !stack.isEmpty() && stack.peek() == '[') {\n stack.pop();\n }\n else if(c == '}' && !stack.isEmpty() && stack.peek() == '{') {\n stack.pop();\n }\n else{\n return false; \n } \n }\n return stack.isEmpty(); \n }\n}\n" } ]