question_id int64 700k 876k | question_title stringlengths 3 81 | question_content stringlengths 131 2.51k | dataset stringclasses 1 value | difficulty stringclasses 3 values | java dict | python dict | test_cases stringlengths 200 208M |
|---|---|---|---|---|---|---|---|
701,716 | First Repeating Element | Given an array arr[], find the first repeating element. The element should occur more than once and the index of its first occurrence should be the smallest.
Examples:
Input:
arr[] = [1, 5, 3, 4, 3, 5, 6]
Output:
2
Explanation:
5 appears twice and its first appearance is at index 2 which is less than 3 whose first the occurring index is 3.
Input:
arr[] = [1, 2, 3, 4]
Output:
-1
Explanation:
All elements appear only once so answer is -1.
Constraints:
1 <= arr.size <= 10**6
0 <= arr[i]<= 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1616042083,
"func_sign": [
"public static int firstRepeated(int[] arr)"
],
"initial_code": "// 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 br = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine().trim()); // Inputting the testcases\n while (t-- > 0) {\n\n String line = br.readLine();\n String[] tokens = line.split(\" \");\n\n // Create an ArrayList to store the integers\n ArrayList<Long> array = new ArrayList<>();\n\n // Parse the tokens into integers and add to the array\n for (String token : tokens) {\n array.add(Long.parseLong(token));\n }\n\n int[] arr = new int[array.size()];\n int idx = 0;\n for (long i : array) arr[idx++] = (int)i;\n\n Solution obj = new Solution();\n\n // calling maxSubarraySum() function\n System.out.println(obj.firstRepeated(arr));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution {\n // Function to return the position of the first repeating element.\n public static int firstRepeated(int[] arr) {\n int n = arr.length;\n boolean flag = false;\n int ans = -1;\n\n // using map to store frequency of each element.\n Map<Integer, Integer> m = new HashMap<>();\n\n // storing the frequency of each element in map.\n for (int i = 0; i < n; i++) {\n if (m.containsKey(arr[i])) {\n m.put(arr[i], m.get(arr[i]) + 1);\n } else {\n m.put(arr[i], 1);\n }\n }\n\n // iterating over the array elements.\n for (int i = 0; i < n; i++) {\n // if frequency of current element in map is greater than 1,\n // then we store the index and break the loop.\n if (m.get(arr[i]) > 1) {\n ans = i + 1;\n break;\n }\n }\n\n // returning the position of the first repeating element.\n return ans;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n // Function to return the position of the first repeating element.\n public static int firstRepeated(int[] arr) {\n // Your code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1616042083,
"func_sign": [
"firstRepeated(self,arr)"
],
"initial_code": "# Initial Template for Python 3\n\n# contributed by RavinderSinghPB\nif __name__ == '__main__':\n t = int(input())\n\n for _ in range(t):\n arr = [int(x) for x in input().strip().split()]\n ob = Solution()\n print(ob.firstRepeated(arr))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n # Function to return the position of the first repeating element.\n def firstRepeated(self, arr):\n n = len(arr)\n ans = 9999999999999\n # dictionary to hold key value pair.\n d = dict()\n\n # iterating over the array.\n for i, e in enumerate(arr):\n if e in d:\n # if d[e]<ans and ans is not equal to -1, we store the index.\n if d[e] < ans and ans != -1:\n ans = d[e]\n else:\n d[e] = i\n\n # returning the position of the first repeating element or -1.\n if ans != 9999999999999:\n return (ans + 1)\n else:\n return (-1)\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n #Function to return the position of the first repeating element.\n def firstRepeated(self,arr):\n \n #arr : given array\n #n : size of the array"
} | eJy9VMFuwjAM5TDxHVbODDVp2qZ8CdI67bD1sEvhUCQktGkfMbjxrzyHstFpZhhVi+U2keLn5xcnH3fb/XgUx3yHycPGvDbLVWtmZGzV2CQOKuOgbmkmZOr1sn5u65enxar93v9eNeZtQn2QGBt+YPSXVoB0AmRKljw8o5Ic5finlClpFcQoDjgOs4ICLCevRLEx2kUs5uQjHpuWj6UExl9JDTEScjp4CvfwDJ7DC3hgqeGsMy8E6CBAZyiHyzuW6SE0i60tLenFs9R88KRtpFPr2KN1qw54QKyhGt9eKP339OVN+e9vIMAX4IzEV0ZdDmn3tVSUzfuP0p1zPdEPTPRi50rvlXSjlSfXk0srTAVlk6Eai4Z79v7O/vg5PQCd/bqp |
703,463 | Sorting all array elements except one | Given an array arr[] of positive integers and an integer k, sort the array in ascending order such that the element at index kthstays unmoved and all other elements are sorted.
Examples:
Input:
arr[] = [10, 4, 11, 7, 6, 20], k = 2
Output:
[4, 6, 11, 7, 10, 20]
Explanation:
Sorting array except an index 2 So, [4, 6, 11, 7, 10, 20].
Input:
arr[] = [30, 20, 10], k = 0
Output:
[30, 10, 20]
Explanation:
the 0th index is unmoved so array become,[30, 10, 20].
Constraints:
1 ≤ arr.size() ≤ 10**5
1 ≤ arr[i] ≤ 10**5** | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public void sortExceptK(int[] arr, int k)"
],
"initial_code": "import java.util.*;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n int t = scanner.nextInt();\n scanner.nextLine(); // Consume the newline character\n\n while (t-- > 0) {\n // Array input\n String input = scanner.nextLine();\n String[] inputArray = input.split(\" \");\n int[] arr = new int[inputArray.length];\n for (int i = 0; i < inputArray.length; i++) {\n arr[i] = Integer.parseInt(inputArray[i]);\n }\n\n // k input\n int k = scanner.nextInt();\n scanner.nextLine(); // Consume the newline character\n\n Solution solution = new Solution();\n solution.sortExceptK(arr, k);\n\n // Output the sorted array\n for (int num : arr) {\n System.out.print(num + \" \");\n }\n System.out.println();\n System.out.println(\"~\");\n }\n\n scanner.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public void sortExceptK(int[] arr, int k) {\n int n = arr.length;\n // Swap the element at index k with the last element\n swap(arr, n - 1, k);\n // Sort all elements except the last one\n Arrays.sort(arr, 0, n - 1);\n // Restore the element at index k to its original position\n for (int i = n - 2; i >= k; i--) {\n swap(arr, i, i + 1);\n }\n }\n\n private void swap(int[] arr, int i, int j) {\n int temp = arr[i];\n arr[i] = arr[j];\n arr[j] = temp;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public void sortExceptK(int[] arr, int k) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"sort_except_k(self, arr, k)"
],
"initial_code": "def main():\n t = int(input())\n for _ in range(t):\n arr = list(map(int, input().split()))\n k = int(input())\n\n solution = Solution()\n solution.sort_except_k(arr, k)\n\n print(\" \".join(map(str, arr)))\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def sort_except_k(self, arr, k):\n n = len(arr)\n # Swap the element at index k with the last element\n arr[k], arr[-1] = arr[-1], arr[k]\n # Sort all elements except the last one\n arr[:n - 1] = sorted(arr[:n - 1])\n # Restore the element at index k to its original position\n for i in range(n - 2, k - 1, -1):\n arr[i], arr[i + 1] = arr[i + 1], arr[i]\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n\n def sort_except_k(self, arr, k):\n # code here\n pass\n"
} | eJzFVTtOAzEQpaDhFqOtEfKMvWubkyCxiAJS0CwUQUJCIA4BB6HjeDz/QlBik4QgXHjX8sx743kz9svh28fRQRxn7/g5f+xuprv7eXdKHY8TKwzq88QU1uS9J8GXFT7E1JMep747pm72cDe7ms+uL2/v5wWENAySqWRnXgVV4/Q8Tt3TMX0PwIcRnLyLs43zQEKGBnIBmMmOk6nSBzsL+2ibnL+AEqivkLNoMj3cXYiZmYVYs2GcZ2DLQPSihElEtBiSXgYBlROvFWnWopEYV4tsH+Drc+bs0JPRggNrUFjC2mjCGgcOv6AS7NAAcogQTCl4jZOuRBt2s1OCSZAJPlElmASfgGMglSBRNJAkCOkhj4GKKAFbYQ8iSyykIRpDtppk46RqCa+5pAIEPVeLqFisB4ibVCtVblXnSikWpzYhkgYJkA3ojLxIIKl3YEidicY2pA7gFeDlrgImVEEkDn1bz2rDZa89xX/YVAm1kGwSuP0J+5ehr8PNURbuAl/YmsEvSoua96hvlWoyTW7RwRa0JcRaX35v93yGrbp+4dNo/lX193tPZ7Qs/s73cxLD/YkabiM52leW3+nO8u1LK1n+21PePrDa7cRqh4dBbfEyFLYloCFDZMqL15NPhLRecw== |
703,823 | Ways to sum to N | Given a set of m distinct positive integers and a value ‘N’. Count the total number of ways we can form ‘N’ byaddingthe array elements. Repetitions and different arrangements are allowed.Note: Answer can be quite largeoutput the answer modulo 10**9+7.
Examples:
Input:
m = 3 , N = 7
Arr[] = {1,5,6}
Output:
6
Explanation:
The different ways are:
1+1+1+1+1+1+1
1+1+5
1+5+1
5+1+1
1+6
6+1
Input:
m = 3 , N = 3
Arr[] = {1,2,3}
Output:
4
Explanation:
The different ways are:
1+1+1
1+2
2+1
3
Constraints:
1 <= N , m <= 10**3 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int countWays(int arr[], int m, int N)"
],
"initial_code": "//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\nclass GfG\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 m = sc.nextInt();\n int N = sc.nextInt();\n int Arr[] = new int[m];\n for(int i = 0;i<m;i++)\n Arr[i] = sc.nextInt();\n Solution ob = new Solution();\n System.out.println(ob.countWays(Arr,m,N));\n \nSystem.out.println(\"~\");\n}\n }\n} ",
"script_name": "GfG",
"solution": "class Solution\n{\n \n private static final int MOD = 1000000007;\n\n private int solve(int[] arr, int m, int target, int[] dp) {\n if (target == 0) {\n return 1;\n }\n \n if (target < 0) {\n return 0;\n }\n \n if (dp[target] != -1) {\n return dp[target];\n }\n\n int ways = 0;\n for (int index = 0; index < m; ++index) {\n ways = (ways + solve(arr, m, target - arr[index], dp)) % MOD;\n }\n \n return dp[target] = ways % MOD;\n }\n \n public int countWays(int arr[], int m, int n) \n { \n //code here.\n int[] dp = new int[n + 1];\n Arrays.fill(dp, -1);\n return solve(arr, m, n, dp);\n } \n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public int countWays(int arr[], int m, int N) \n { \n //code here.\n } \n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"countWays(self, arr, m, n)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n m, n = list(map(int, input().strip().split()))\n arr = list(map(int, input().strip().split()))\n ob = Solution()\n print(ob.countWays(arr, m, n))\n print(\"~\")\n",
"solution": "class Solution:\n def countWays(self, arr, m, n):\n dp = [-1] * (1003)\n # initialize the dp array with -1\n\n # call the recursive function and return its result\n return self.rec(arr, m, n, dp)\n\n # recursive function to count the number of ways\n def rec(self, a, n, m, dp):\n mod = 10 ** 9 + 7\n # set the modulo value\n\n if m == 0:\n return 1\n # base case: if target sum is 0, return 1 as 1 way to reach that sum\n\n if dp[m] != -1:\n return dp[m]\n # if the result for the given target sum is already calculated, return it\n\n res = 0\n # variable to store the count of ways\n\n for i in range(n):\n # iterate through the array\n if m >= a[i]:\n res += self.rec(a, n, m - a[i], dp) % mod\n res %= mod\n # recursive call to count the ways with updated target sum\n # update the result by adding the count of ways\n\n dp[m] = res\n # store the result in the dp array for future reference\n\n return dp[m]\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def countWays(self, arr, m, n):\n # code here "
} | eJytUz1Pw0AMZUCMbOxPmSvkO5/vzvwSJIoYIANL6NBKlRCIHwH/F1/EVwenKZBTokiJn/0+/HL8dnZyNF6Xp/Zy9djdD6vNurtAF5ZDQHt0C3T9dtXfrvu7m4fN+vv783LonhbYLYooy4GRnLLolDGk1UawU5icwkAIRDS+RAITEkEImVAIlaDjDx6LXFMuEovHpmHRKMWc43ThTJG0ek0qVKyHDS0BEiEmRoIIJEOKgynEQWr0bOAPVZgZzMlu8YZzEDJUtcnadG3CNmVHOUxbT0/aM06IFg2jVaoeiBBa62aERQSmDgwEppwBe96mnDRoqL8i+CXf/81pxB2wWlKOFDwrdjHDHPKRjA9H9jLnQOoUpnJpR+YKqn+KjLcVNLkW1RwntcTP3wtuxnjTeZb8wNm3YLMI8myGIrValihPO2szHZZBFc6BKn0qd/16/g45s6mC |
701,195 | Power Of Numbers | Given a number and its reverse. Find that number raised to the power of its own reverse.Note: As answers can be very large, print the result modulo 10**9 + 7.
Examples:
Input:
N = 2, R = 2
Output:
4
Explanation:
The reverse of 2 is 2 and after raising power of 2 by 2 we get 4 which gives remainder as 4 when divided by 1000000007.
Input:
N = 12, R = 21
Output:
864354781
Explanation:
The reverse of 12 is 21and 12
**21
when divided by 1000000007 gives remainder as 864354781.
| geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1731334387,
"func_sign": [
"public int reverseExponentiation(int n)"
],
"initial_code": "import java.util.Scanner;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n int T = sc.nextInt(); // test cases\n\n Solution ob = new Solution();\n\n while (T-- > 0) {\n int n = sc.nextInt(); // input N\n int ans = ob.reverseExponentiation(n);\n System.out.println(ans);\n }\n\n sc.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n // Function to reverse the digits of the number\n public int reverseNumber(int n) {\n int reversed = 0;\n while (n > 0) {\n reversed = reversed * 10 + n % 10;\n n = n / 10;\n }\n return reversed;\n }\n\n // Recursive function to compute base raised to the power of exponent\n public int reverseExponentiationHelper(int base, int exponent) {\n if (base == 0) return 0;\n if (exponent == 0) return 1;\n\n int result;\n if (exponent % 2 == 0) {\n result = reverseExponentiationHelper(base, exponent / 2);\n return result * result;\n } else {\n result = reverseExponentiationHelper(base, exponent - 1);\n return base * result;\n }\n }\n\n // Main function to compute n raised to the power of its reverse\n public int reverseExponentiation(int n) {\n int reversed = reverseNumber(n);\n return reverseExponentiationHelper(n, reversed);\n }\n}",
"updated_at_timestamp": 1731334387,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int reverseExponentiation(int n) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1731334387,
"func_sign": [
"reverse_exponentiation(self, n)"
],
"initial_code": "# Input handling\nif __name__ == \"__main__\":\n T = int(input()) # test cases\n for _ in range(T):\n n = int(input()) # input N\n solution = Solution()\n ans = solution.reverse_exponentiation(n)\n print(ans)\n",
"solution": "class Solution:\n # Function to reverse the digits of the number\n def reverse_number(self, n):\n reversed_num = 0\n while n > 0:\n reversed_num = reversed_num * 10 + n % 10\n n //= 10\n return reversed_num\n\n # Recursive function to compute base raised to the power of exponent\n def reverse_exponentiation_helper(self, base, exponent):\n if base == 0:\n return 0\n if exponent == 0:\n return 1\n\n if exponent % 2 == 0:\n result = self.reverse_exponentiation_helper(base, exponent // 2)\n return result * result\n else:\n result = self.reverse_exponentiation_helper(base, exponent - 1)\n return base * result\n\n # Main function to compute n raised to the power of its reverse\n def reverse_exponentiation(self, n):\n reversed_num = self.reverse_number(n)\n return self.reverse_exponentiation_helper(n, reversed_num)\n",
"updated_at_timestamp": 1731334387,
"user_code": "#User function Template for python3\n\nclass Solution:\n def reverse_exponentiation(self, n):\n # code here"
} | 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 |
705,148 | Pairs of Adjacent elements | Given an array arr[] of positive integers. The task is to count consecutive pairs of adjacent elements. A pair is said to be consecutive if the second element in the pair is greater than the first element by 1. For example, (4,5) is a pair of consecutive elements.
Examples:
Input:
arr = [5, 7, 6, 7, 4]
Output:
1
Explanation:
(6, 7) pair is the only such pair.
Input:
arr = [1, 2, 3, 4]
Output:
3
Explanation:
(1, 2), (2, 3), (3, 4) are the pairs.
Constraints:
1 ≤ arr.size ≤ 10**6
1 ≤ arr[i] ≤ 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int adjacentPairs(int arr[])"
],
"initial_code": "// 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\n String a[] = in.readLine().trim().split(\"\\\\s+\");\n int N = a.length;\n int arr[] = new int[N];\n for (int i = 0; i < N; i++) arr[i] = Integer.parseInt(a[i]);\n\n Solution ob = new Solution();\n System.out.println(ob.adjacentPairs(arr));\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n static int adjacentPairs(int arr[]) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"adjacentPairs(self,arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n arr = input().split()\n N = len(arr)\n for i in range(N):\n arr[i] = int(arr[i])\n ob = Solution()\n print(ob.adjacentPairs(arr))\n print(\"~\")\n",
"solution": "# User function Template for Python3\nclass Solution:\n # Method to count adjacent pairs where the difference is 1\n def adjacentPairs(self, arr):\n count = 0 # Initialize count to 0\n # Loop through the array starting from the second element\n for i in range(1, len(arr)):\n # Check if the current element and the previous element have a difference of 1\n if arr[i] - arr[i - 1] == 1:\n count += 1 # Increment count if condition is met\n return count # Return the total count of adjacent pairs\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def adjacentPairs(self,arr):\n # code here"
} | eJxrYJn6j4UBDCK+AxnR1UqZeQWlJUpWCkqGMXmGSjoKSqkVBanJJakp8fmlJVApg5i8upg8pVodBTT1BmBAqi4FKCTPNgVLMFDAzsVhphFut5DlB6IsNSTKIyTabKRgrGCqYKJgpmCuYKlgAXSCgiGukDTG6WuQGUD9lMUAmLSAUOakB6AhEJtS5nt8nscV5UYKCJ/gDz5CwWBClXAwJCsgYAnQktzkS4mfDWGepiD2KXO+IWYQEJ+sY6foAQBsPHR2 |
700,203 | DFS of Graph | Given a connected undirected graph represented by an adjacency listadj, which is a vector of vectors where eachadj[i]represents the list of vertices connected to vertexi. Perform a Depth First Traversal (DFS) starting from vertex 0, visiting vertices from left to right as per the adjacency list, and return a list containing the DFS traversal of the graph.
Examples:
Input:
adj = [[2,3,1], [0], [0,4], [0], [2]]
Output:
[0, 2, 4, 3, 1]
Explanation:
Starting from 0, the DFS traversal proceeds as follows:
Visit 0 → Output:
0
Visit 2 (the first neighbor of 0) → Output:
0, 2
Visit 4 (the first neighbor of 2) → Output:
0, 2, 4
Backtrack to 2, then backtrack to 0, and visit 3 → Output:
0, 2, 4, 3
Finally, backtrack to 0 and visit 1 → Final Output:
0, 2, 4, 3, 1
Input:
adj = [[1, 2], [0, 2], [0, 1, 3, 4], [2], [2]]
Output:
[0, 1, 2, 3, 4]
Explanation:
Starting from 0, the DFS traversal proceeds as follows:
Visit 0 → Output:
0
Visit 1 (the first neighbor of 0) → Output:
0, 1
Visit 2 (the first neighbor of 1) → Output:
0, 1, 2
Visit 3 (the first neighbor of 2) → Output:
0, 1, 2, 3
Backtrack to 2 and visit 4 → Final Output:
0, 1, 2, 3, 4
Constraints:
1 ≤ adj.size() ≤ 10**4
1 ≤ adj[i][j] ≤ 10**4** | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public ArrayList<Integer> dfsOfGraph(ArrayList<ArrayList<Integer>> adj)"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.lang.*;\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());\n while (T-- > 0) {\n String[] s = br.readLine().trim().split(\" \");\n int V = Integer.parseInt(s[0]);\n int E = Integer.parseInt(s[1]);\n ArrayList<ArrayList<Integer>> adj = new ArrayList<ArrayList<Integer>>();\n for (int i = 0; i < V; i++) adj.add(new ArrayList<Integer>());\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 ArrayList<Integer> ans = obj.dfsOfGraph(adj);\n for (int i = 0; i < ans.size(); i++) System.out.print(ans.get(i) + \" \");\n System.out.println();\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n\n private void dfs(int ch, boolean[] vis, ArrayList<Integer> ans,\n ArrayList<ArrayList<Integer>> adj) {\n // marking vertex as visited and adding it to output list.\n vis[ch] = true;\n ans.add(ch);\n\n // iterating over connected components of the vertex and if any\n // of them is not visited then calling the function recursively.\n for (int i = 0; i < adj.get(ch).size(); i++)\n if (!vis[adj.get(ch).get(i)]) dfs(adj.get(ch).get(i), vis, ans, adj);\n }\n\n // Function to return a list containing the DFS traversal of the graph.\n public ArrayList<Integer> dfsOfGraph(ArrayList<ArrayList<Integer>> adj) {\n int V = adj.size();\n // using a boolean list to mark all the vertices as not visited.\n boolean[] vis = new boolean[V];\n ArrayList<Integer> ans = new ArrayList<Integer>();\n dfs(0, vis, ans, adj);\n\n // returning the output list.\n return ans;\n }\n}",
"updated_at_timestamp": 1730268044,
"user_code": "class Solution {\n // Function to return a list containing the DFS traversal of the graph.\n public ArrayList<Integer> dfsOfGraph(ArrayList<ArrayList<Integer>> adj) {\n // Code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"dfsOfGraph(self, adj)"
],
"initial_code": "if __name__ == '__main__':\n T = int(input())\n while T > 0:\n V, E = map(int, input().split())\n # Create adjacency list with V vertices\n # List of lists (vector of vectors equivalent)\n adj = [[] for i in range(V)]\n\n # Reading edges\n for i in range(E):\n u, v = map(int, input().split())\n adj[u].append(v)\n adj[v].append(u)\n\n # Create an object of Solution class\n ob = Solution()\n ans = ob.dfsOfGraph(adj)\n\n # Printing the result\n for i in range(len(ans)):\n print(ans[i], end=\" \")\n print()\n print(\"~\")\n T -= 1\n",
"solution": "class Solution:\n # Function to return a list containing the DFS traversal of the graph.\n def dfsOfGraph(self, adj):\n V = len(adj)\n # initialize a visited list to keep track of visited nodes\n visited = [0] * V\n # initialize an empty list to store the DFS traversal\n values = []\n # call the dfs function to perform DFS traversal\n self.dfs(0, adj, visited, values)\n # return the DFS traversal list\n return values\n\n # DFS function to perform depth-first search\n def dfs(self, node, adj, visited, values):\n # mark the current node as visited\n visited[node] = 1\n # append the current node to the DFS traversal list\n values.append(node)\n\n # visit all the adjacent nodes of the current node\n for i in adj[node]:\n # if the adjacent node is not visited, recursively call the dfs function\n if visited[i] == 0:\n self.dfs(i, adj, visited, values)\n",
"updated_at_timestamp": 1730268044,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to return a list containing the DFS traversal of the graph.\n def dfsOfGraph(self, adj):\n # code here"
} | eJztl0Fu1EAQRVlwAW5QmnWE3FXddpuTIGHEArJgY7JIJCQE4hBwInaciv9/TRIU5GRGYgHRzMKdeHqqq96vX5a/Pv3+89kTfV7+wB+vPu3erxdXl7sXtivLWgYrbVlx5cVxw4KXuqxujZdxWcMmXvqyVpuXtfHeyHsT73Xem23gt213Zrvzjxfnby/P3735cHW5PwnxDVFsNEQ1RLFuy/plWXefz+xORm6lH51RGZhSKcxpZk68MesGSmSAkhl27X4gzRkpMgRyxXGIspVsnnNArpWnN/41Pnh6Hlo3AdmwGWDjJ54J3nfw1mEDPvnrGZ/NAPxyMwYKOozSraJVYJsExNXFLXSt1Hgg+0aJXQpXKTxm+zzAt1/LGghGcSk3jeBbFTR8OfztEug79M+oPp3Sil1llFl1EBpydCKs5p4keS5sxIInc8Qo3ZyFAwWiONJDFC/miOJugSgeFmyDaoEo3iwQxUcL5j9ZsIJugSg+W7AKeAZRAmUiSrhVRImwiihRrSJKwMeIEuhURInJKqJEt0oSIMqmhy6kAU7koS6sQXK1klqVIeooWpNA1S5Gdd6PJVEWYLFNrAk0UTahnIRSc8jT8p6eFyAXGaKchTKyKSNRsnqgZNlAyXqBkoUCJSsESpYGlKwJKFmMy9Ag6QKZHEdh7KJI7WOQ7KBIxUGRYoMiZQZF6guKFDZSUVCklKBIDUGR4oEiVQNFygWK1IkYuzhSGYCkJDW1AEqKAJSiP98zL9IQaiuT2CYdbg2iPjKpC8o3TmHLmRrBmDr+lX3AoHC0q0FNbYMcTK2COmk3dZYxUxyHm/gKQTeH3XTQ40mTXV0hl8XN5nqzhe1m470grh9O26PQWg6BIVtsUI9EKl1TKu7AuBj5PBpswjIN1jmuMCT5TBqYbcknU1G3gjE7EvzZdeDSWAqmGZax2EQMxTofN5hVWOZiOdQ9m9vT6J5OdTVJw9JQO4HAPFgmt46lu81YZiehkI2oc+SUiLR5qMMalgYudBr6BMuE8Yalw4lY5vSyupsTquaIqTkjatocSwN5LGO1iZMPz1YsHUMSy4yd26oQsgmuCaoJJkCeJvVpUj+mSZ3u/s/ntTjnONyo4GTYx2LYkxuPdCMTqLRh0Zsl34HVZSbt6Sq12bX55E+A2LswLVj37v3Dsf/KmxcDH/f25b+9gG3MlGXZeqO7u1ebhyN2HzeuhiMPYPPrABnA4+BzmNjm1tffnv8CL6KDKA== |
703,468 | Multiply left and right array sum | You are given an array of integers, your task is to divide the array into two sub-arrays (left and right) containing half of the array elements. Find the sum of the subarrays and then return the multiply of both the subarrays.
Examples:
Input:
arr = [1, 2, 3, 4]
Output:
21
Explanation:
Sum up an array from index 0 to 1 = 3, Sum up an array from index 2 to 3 = 7. Their multiplication is
21
.
Input:
arr = [1, 2]
Output:
2
Explanation:
Their multiplication is 1*2 is equal to
2
.
Constraints:
1 ≤ arr.size() ≤ 1000
1 ≤ arr[i] ≤ 100 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1619177699,
"func_sign": [
"public int multiply(int[] arr)"
],
"initial_code": "import java.util.*;\n\npublic class GFG {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n sc.nextLine(); // consume the newline character\n\n while (t-- > 0) {\n String[] input = sc.nextLine().split(\" \");\n int[] arr = Arrays.stream(input).mapToInt(Integer::parseInt).toArray();\n Solution ob = new Solution();\n System.out.println(ob.multiply(arr));\n \nSystem.out.println(\"~\");\n}\n\n sc.close();\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public int multiply(int[] arr) {\n int sum1 = 0, sum2 = 0;\n int n = arr.length;\n // Calculating sum of first half of the array\n for (int i = 0; i < n / 2; i++) {\n sum1 += arr[i];\n }\n // Calculating sum of second half of the array\n for (int i = n / 2; i < n; i++) {\n sum2 += arr[i];\n }\n // Returning the product of the sum of first and second half of array\n return sum1 * sum2;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int multiply(int[] arr) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619177699,
"func_sign": [
"multiply(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n arr = list(map(int, input().split()))\n ob = Solution()\n print(ob.multiply(arr))\n print(\"~\")\n",
"solution": "class Solution:\n\n def multiply(self, arr):\n sum1, sum2 = 0, 0\n n = len(arr)\n\n for i in range(n // 2):\n sum1 += arr[i]\n\n for i in range(n // 2, n):\n sum2 += arr[i]\n\n return sum1 * sum2\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def multiply(self, arr):\n # Code here"
} | eJy1VMtKA0EQ9CD4G8Weg0zPzqPbLxGMeNAcvMQcEgiI4kfo53jzw6xdQjTqTHYT3KFCYGu7p7ur+uX07ePspH8u3/nn6rG5ny9Wy+YCjUzn4hw80RKBiEQiMqGEEeS46byZoJmtF7Pb5ezu5mG13MQg2fXvn0l5muB3+CNQzhoqSc0g2P0pBqrFEXi0CIhIyFAwDm8lEA9pIQESIQmSIQox9rGYRqOPxSyDTqUZ4qxUQsSgUwztY3W0bK2xLxmWYBEWYC3Mw9h16segCmXrEjRCA7SFemh5HCqp0qlOqlQqhUqdUqZUKUXaper10k2HBCFDSBFyhCQhS0gT66VenVGlWqqBaIlARCIRmVDXldvPqFxZcj6XS/MYdGoyHqOAMRKIBxtklLb/slNF8tl8RZfdRvuvleYLX+1r0rZa/7N8n6uVqkupNNwD7/J9YCOuyNnqzvarXNvSETZ2Oz5u3UgnZwu5YuU9a103QtQwZLOHnNX22vrLw+rHOVuy31Zy/Xr+CWmQ8gg= |
711,400 | Number of Ways to Arrive at Destination | You are in a city that consists ofnintersections numbered from0ton - 1withbi-directionalroads 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.
Examples:
Input:
n=7, m=10
edges= [[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]]
Output:
4
Explanation:
The four ways to get there in 7 minutes are:
- 0 6
- 0 4 6
- 0 1 2 5 6
- 0 1 3 5 6
Input:
n=6, m=8
edges= [[0,5,8],[0,2,2],[0,1,1],[1,3,3],[1,2,3],[2,5,6],[3,4,2],[4,5,2]]
Output:
3
Explanation:
The three ways to get there in 8 minutes are:
- 0 5
- 0 2 5
- 0 1 3 4 5
Constraints:
1 <= n <= 200
n - 1 <= roads.length <= n * (n - 1) / 2
roads[i].length == 3
0 <= u
i
, v
i
<= n - 1
1 <= time
i
<= 10**9
u
i
!= v
i
There is at most one road connecting any two intersections.
You can reach any intersection from any other intersection.
Expected Time Complexity:O(M * logN + N)
Expected Space Complexity: O(M+N) | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1658245029,
"func_sign": [
"static int countPaths(int n, List<List<Integer>> roads)"
],
"initial_code": "// Initial Template for Java\n\nimport java.util.*;\n// Position this line where user code will be pasted.\n\nclass GFG {\n\n public static void main(String[] args) {\n\n Scanner sc = new Scanner(System.in);\n\n int t = sc.nextInt();\n while (t-- > 0) {\n int n = sc.nextInt();\n int m = sc.nextInt();\n\n List<List<Integer>> adj = new ArrayList<>();\n\n for (int i = 0; i < m; i++) {\n List<Integer> temp = new ArrayList<>();\n for (int j = 0; j < 3; j++) {\n int x = sc.nextInt();\n temp.add(x);\n }\n adj.add(temp);\n }\n\n Solution obj = new Solution();\n System.out.println(obj.countPaths(n, adj));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\n\nclass Solution {\n\n // Function to count the number of paths.\n static int countPaths(int n, List<List<Integer>> roads) {\n // Mod value for taking modulo.\n double mod = 1e9 + 7;\n // Graph to store the roads.\n List<List<int[]>> graph = new ArrayList<>();\n\n // Initializing the graph ArrayList.\n for (int i = 0; i <= n; i++) {\n graph.add(new ArrayList<>());\n }\n\n // Adding the roads to the graph.\n for (List<Integer> road : roads) {\n graph.get(road.get(0)).add(new int[]{road.get(1), road.get(2)});\n graph.get(road.get(1)).add(new int[]{road.get(0), road.get(2)});\n }\n\n // Array to store the minimum distance from start node.\n long[] distance = new long[n];\n // Initializing the distance array with maximum values.\n Arrays.fill(distance, Long.MAX_VALUE);\n\n // Array to store the path count.\n int[] path = new int[n];\n\n // Priority queue for Dijkstra's algorithm.\n PriorityQueue<long[]> pq =\n new PriorityQueue<>((x, y)->{ return (int)x[0] - (int)y[0]; });\n\n // Adding the start node to priority queue.\n pq.add(new long[]{0, 0});\n // Setting the distance from start node to 0.\n distance[0] = 0;\n // Setting the path count for start node to 1.\n path[0] = 1;\n\n // Dijkstra's algorithm.\n while (!pq.isEmpty()) {\n long[] t = pq.poll();\n\n for (int[] nbr : graph.get((int)t[1])) {\n long vert = nbr[0];\n long edge = nbr[1];\n\n // Updating the distance and path count.\n if (distance[(int)vert] > distance[(int)t[1]] + edge) {\n distance[(int)vert] = distance[(int)t[1]] + edge;\n pq.add(new long[]{distance[(int)vert], vert});\n path[(int)vert] = path[(int)t[1]] % 1000000007;\n } else if (distance[(int)vert] == t[0] + edge) {\n path[(int)vert] += path[(int)t[1]];\n path[(int)vert] %= 1000000007;\n }\n }\n }\n\n // Returning the path count for the last node.\n return path[n - 1];\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n\n static int countPaths(int n, List<List<Integer>> roads) {\n // Your code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1658246530,
"func_sign": [
"countPaths(self, n: int, roads: List[List[int]]) -> int"
],
"initial_code": "# Initial Template for Python 3\n\nclass IntArray:\n def __init__(self) -> None:\n pass\n\n def Input(self, n):\n arr = [int(i) for i in input().strip().split()] # array input\n return arr\n\n def Print(self, arr):\n for i in arr:\n print(i, end=\" \")\n print()\n\n\nif __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n n, m = map(int, input().split())\n\n adj = []\n\n for i in range(m):\n tmp = []\n x, y, z = map(int, input().split())\n tmp.append(x)\n tmp.append(y)\n tmp.append(z)\n adj.append(tmp)\n\n obj = Solution()\n res = obj.countPaths(n, adj)\n\n print(res)\n\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\n# Importing necessary libraries\nfrom typing import List\nfrom collections import defaultdict\nimport sys\nimport heapq\n\n# Creating a class Solution\n\n\nclass Solution:\n\n # Function to count the number of paths\n def countPaths(self, n: int, roads: List[List[int]]) -> int:\n\n # Creating a defaultdict to store the graph as adjacency list\n graph = defaultdict(list)\n\n # Defining the modulus value\n mod = int(1e9+7)\n\n # Constructing the graph\n for u, v, t in roads:\n graph[u].append((t, v))\n graph[v].append((t, u))\n\n # Creating a min heap\n heap = []\n\n # Initializing the shortest path to a large value\n shortest = sys.maxsize\n\n # Pushing the source node into the heap with time 0\n heapq.heappush(heap, (0, 0))\n\n # Initializing the distance array with maximum values\n dist = [[sys.maxsize, 0]] * n\n\n # Setting the distance of the source node to (0,1)\n dist[0] = [0, 1]\n\n # Performing Dijkstra's Algorithm to find the shortest paths\n while heap:\n time, node = heapq.heappop(heap)\n if node == n - 1:\n if shortest == sys.maxsize:\n shortest = time\n continue\n if shortest != sys.maxsize and time > shortest:\n break\n for next_time, nei in graph[node]:\n if time + next_time <= dist[nei][0]:\n if time + next_time == dist[nei][0]:\n dist[nei][1] += dist[node][1]\n else:\n dist[nei] = [time + next_time, dist[node][1]]\n # add path to heap only if new_path has less time\n heapq.heappush(heap, (time + next_time, nei))\n return dist[n-1][1] % mod\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nfrom typing import List\nfrom collections import defaultdict\nimport sys\nclass Solution:\n def countPaths(self, n: int, roads: List[List[int]]) -> int:\n #Your code here"
} | eJytlj1uFEEYRAmIOUNrYwv19s/0DBIZh0ACRAAOSIwDW0JCIA4B96W+V21AttZ4bTuoh2T8ZmZ3q7Z/PP316tkTfl6/1D/efN19Oju/vNi9SLv927OSFDntA7uTtDv9cn764eL04/vPlxd//9d3/fLbSTr0p/nq52hHTfXP5fdpGksqB0XlgKjdFJVU7/FUPbUDopraPXz/PmG2b2qPFLW0XBdl39j+Slvv/9glS71ttz96Sz3xEi2BJY3ASGtgTVtAkfl7pUVK357St6tEF4kwEmUk0ki0kYiVBbOyYFYW36Q+MH70mgpmZcGsLJiVBbOyYFYWzMqKWVkxKytmZfULoLcRs7JiVlbMyopZWTErK2Zlw6xsmJUNs7JhVja/uC01zMqGWdkwKxtmZcOs7JiVHbOyY1Z2zMqOWdn9xvXUMSs7ZmXHrOyYlQtm5YJZuWBWLpiVC2blglm5+EOxpAWzcsGsXDArB2blwKwcmJUDs3JgVg7MyoFZOfyBG2lgVg7MyhWzcsWsXDErV8zKFbNyxaxcMStXzMrVH+Y1rZiVG2blhlm5YVZumJUbZuWGWblhVm6YlRtm5eaiRFNmVYTssgSy6xLILkwguzKB7NIEsmsTyC5OILs6gezyBGYxaeaspjDLGZj1DMyCBmZFA7OkgVnTwCxqYFY14LIC1xWUOQWCKwtcWuDaAhcXuLrA5QWuL3CBgSsMXGJQ5/QILjJwlYHLDFxn4EIDVxq41MC1Bi42cLVBm1MnuN7ABQeuOHDJgWsOXHTgqgOXHbjuwIUHfU6r4NID1x64+MDVBy4/cP2BBwB4AoBHAHgGwDKnXPAUAI8B8BwADwLwJACPAvAsAA8D8DQAjwMY86tD8EAATwTwSADPBPBQAE8F8FgAzwXwYABPBljnV5Xg2QAeDuDpAB4P4PkAHhDgCQEeEeAZAR4S4Ck5+oQzbv+anyewOE+U+F275TzWD1wkPsK+SvdVuq/SfZXuw0T3YaL7MNHnwSb7osEWR43sexnxp9y8IrD3OeTIx9fc+vBEle9yeM3/O3PefCUf9WxX2/6Bp7vDp2Ot0QN0131jO152xOH/4P3sH+VsfPB9ju+rY96ge13juEfY80lWY7bH+NBqxO7ywrz7+fw3NN2Yiw== |
704,563 | Narcissistic number | Given N, check whether it is a Narcissistic number or not.
Examples:
Input:
N = 407
Output:
1
Explanation:
4
**3
+0
**3
+7
**3 = 64+0+343
= 407 equals to N.
Input:
N = 111
Output:
0
Explanation:
1
**3
+1
**3
+1
**3 = 1+1+1
= 3 not equals to N.
Constraints:
1 <= N <= 10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int isNarcissistic(int N)"
],
"initial_code": "//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 int N = Integer.parseInt(read.readLine());\n Solution ob = new Solution();\n System.out.println(ob.isNarcissistic(N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n static int isNarcissistic(int N) {\n // count the number of digits\n int l = 0;\n int x = N;\n while (x != 0) {\n x = x / 10;\n l++;\n }\n int dup = N;\n int sum = 0;\n // calculates the sum of digits\n // raised to power\n while (dup != 0) {\n sum += Math.pow(dup % 10, l);\n dup /= 10;\n }\n if (N == sum) return 1;\n else return 0;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution{\n static int isNarcissistic(int N){\n // code her\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"isNarcissistic(self, N)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n\n ob = Solution()\n print(ob.isNarcissistic(N))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n\n def isNarcissistic(self, N):\n # count the number of digits\n l = 0\n x = N\n while x:\n x = x // 10\n l += 1\n dup = N\n sum = 0\n\n # calculates the sum of digits\n # raised to power\n while dup:\n sum += pow(dup % 10, l)\n dup //= 10\n\n if N == sum:\n return 1\n else:\n return 0\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n\n def isNarcissistic(self, N):\n # code here"
} | eJytU8sKwjAQ9KD/UXIW2baJbfwSwYgH7cHL6qEFoSjiN+j/uo32QV9JxD0sbZeZnU4m9+nrMZvoWuf0sMnZEc9ZylYeEwo5RAp9ESqUPOIK4wBi+qCQzT2WXM7JPk0Ou1OWfiE0uel5b2fXudfgJ9YwgqLR2F+G3IG2RRUoBK1RGDigD02L/YDUcLFUGMWSXoFqkAoaVDBMG5SuCeqx1c+1GHzNPIrrImRRBu39KGeQjU1dUz7bTIYM7YSe2Lh51AzLfzQUCkwejkipnbQRNZIUouNV5NCYueH7aHchYVSPlHUYf02k1PSgqBzUOR1bM5C/HGFLVxUDW/tKsdvn4g339cBR |
702,887 | Check Arithmetic Progression | Given an array arr[] of integers. Write a program to check whether an arithmetic progression can be formed using all the given elements.
Examples:
Input:
arr[] = [0, 12, 4, 8]
Output:
true
Explanation:
Rearrange given array as [0, 4, 8, 12] which forms an arithmetic progression.
Input:
arr[] = [12, 40, 11, 20]
Output:
false
Explanation:
there is no rearrangment which can forms an arithmetic progression.
Constraints:
1 ≤ arr.size() ≤ 10**6
0 ≤ arr[i] ≤ 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public boolean checkIsAP(int[] arr)"
],
"initial_code": "// Initial Template for Java\n\n// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\n\n// Driver class\npublic class Main {\n public static void main(String[] args) throws IOException {\n Scanner sc = new Scanner(System.in);\n int t = Integer.parseInt(sc.nextLine().trim());\n while (t-- > 0) {\n String inputLine = sc.nextLine().trim();\n String[] inputArray = inputLine.split(\"\\\\s+\");\n int[] arr = Arrays.stream(inputArray).mapToInt(Integer::parseInt).toArray();\n\n Solution ob = new Solution();\n boolean ans = ob.checkIsAP(arr);\n if (ans)\n System.out.println(\"true\");\n else\n System.out.println(\"false\");\n System.out.println(\"~\");\n }\n sc.close();\n }\n}",
"script_name": "Main",
"solution": "class Solution {\n // Function to check if the given array forms an arithmetic progression\n public boolean checkIsAP(int[] arr) {\n int n = arr.length;\n // Check if all elements in the array are the same\n int ele = arr[0];\n boolean allSame = true;\n for (int i = 0; i < n; i++) {\n if (arr[i] != ele) {\n allSame = false;\n break;\n }\n }\n if (allSame) return true;\n // Find the minimum element in the array\n int mn = Integer.MAX_VALUE;\n for (int num : arr) {\n mn = Math.min(mn, num);\n }\n // Create a HashMap to store the count of each element after subtracting the\n // minimum\n Map<Integer, Integer> countMap = new HashMap<>();\n for (int i = 0; i < n; i++) {\n arr[i] -= mn;\n countMap.put(arr[i], countMap.getOrDefault(arr[i], 0) + 1);\n }\n // Find the minimum non-zero element in the array\n int mN = Integer.MAX_VALUE;\n for (int num : arr) {\n if (num != 0) {\n mN = Math.min(mN, num);\n }\n }\n // Check if the array forms an arithmetic progression\n for (int i = 1; i < n; i++) {\n if (!countMap.containsKey(i * mN)) {\n return false;\n }\n }\n return true;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n // Function to check if the given array forms an arithmetic progression\n public boolean checkIsAP(int[] arr) {\n // Your code goes here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"checkIsAP(self, arr)"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n arr = list(map(int, input().split()))\n ob = Solution()\n ans = ob.checkIsAP(arr)\n if ans:\n print(\"true\")\n else:\n print(\"false\")\n print(\"~\")\n",
"solution": "class Solution:\n # Function to check if the given array forms an arithmetic progression\n def checkIsAP(self, arr):\n n = len(arr)\n\n # Step 1: Check if all elements are the same\n # If all elements in the array are equal, they naturally form an arithmetic progression\n ele = arr[0]\n for i in range(n):\n if arr[i] != ele:\n break # If any element is different, break the loop\n if i == n - 1: # If loop reaches the end and all elements are the same\n return True # All elements are the same, so return True\n\n # Step 2: Find the minimum element in the array\n mn = min(arr)\n\n # Step 3: Normalize the array by subtracting the minimum element\n # Subtract the minimum value from all elements\n arr = [x - mn for x in arr]\n\n # Step 4: Count the occurrences of each normalized element using a dictionary\n count_map = {}\n for num in arr:\n # Count occurrences of each normalized value\n count_map[num] = count_map.get(num, 0) + 1\n\n # Step 5: Find the minimum non-zero element in the normalized array\n mN = float('inf')\n for num in arr:\n if num != 0:\n mN = min(mN, num) # Identify the smallest non-zero element\n\n # Step 6: Check if the elements can form an arithmetic progression\n # The arithmetic progression should have a common difference `mN`\n for i in range(1, n):\n if (i * mN) not in count_map: # If any expected element is missing, return False\n return False\n\n return True # If all required elements are present, return True\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def checkIsAP(self, arr):\n #Your code goes here\n \n"
} | eJylk0EKwjAQRV3oPT5Zi3TSpFb37jyAYEVEKwhSi7YgiOIh9L6GjC4UKjqZWbxCmQ//Z+bavo87LV+TkfuYntSmKOtKDaEoK0h1ofJjmS+rfDXf1dXzV7Wv86y4ZIU6d/ExEvlCAwWCiKH/H+vjo+VWBr4YKUOg5ucSHrcMw4gZmkEMQVIaBglSFzVIgwwoAaXQAinrRSy0RWxhmhTWi+2h+d0I2nfs2ggUItjA3bGhzmXWnxpRkAjvi+ReyD19WPJvh/Pten5KQeY/4GAbKNxiekXp7PySw+zWewAm1pH8 |
702,776 | Number and the Digit Sum | Given a positive value N, we need to find the count of numbers smaller than or equal to N such that the difference between the number and sum of its digits is greater than or equal to the given specific value K.
Examples:
Input:
N = 13, K = 2
Output:
4
Explanation:
10, 11, 12 and 13 satisfy the given condition shown below,
10 - sumofdigit(10) = 9 >= 2
11 - sumofdigit(11) = 9 >= 2
12 - sumofdigit(12) = 9 >= 2
13 - sumofdigit(13) = 9 >= 2
Input:
N = 10, K = 5
Output:
1
Explanation:
Only 10 satisfies the givencondition as
10 - sumofdigit(10) = 9 >= 5
Constraints:
1 <= N, K<= 10**9 | geeksforgeeks | Easy | {
"class_name": "Sol",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static long numberCount(long N, long K)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nclass GfG\n{\n public static void main (String[] args)\n {\n \n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n long n = sc.nextLong();\n long k = sc.nextLong();\n \n \t\tSystem.out.println (new Sol().numberCount (n, k));\n \nSystem.out.println(\"~\");\n}\n \n }\n}",
"script_name": "GfG",
"solution": "// Back-end complete function Template for Java\nclass Sol {\n public static int sumOfDigit(long K) {\n int sod = 0;\n while (K > 0) {\n sod += K % 10;\n K /= 10;\n }\n return sod;\n }\n\n public static long numberCount(long N, long K) {\n long low = K + 1;\n // no number lesser than or equal to k\n // can have required value of difference\n // hence lower limit for binary search is set to k+1\n long high = N;\n if (K + 90 < high) high = K + 90;\n // max sum of digits for a 10 digit\n // decimal number = 90\n // hence difference between (k+90) and\n // sumOfDigits(k+90) will definitely be >= k\n // hence upper limit for binary search is k+90\n // time complexity for this binary search is\n // constant as differnece between upper and\n // lower limits is capped at 89\n while (low <= high) {\n long mid = (low + high) / 2;\n if (mid - sumOfDigit(mid) < K) low = mid + 1;\n else high = mid - 1;\n }\n return (N - high);\n }\n}\n",
"updated_at_timestamp": 1730468492,
"user_code": "//User function Template for Java\n\nclass Sol\n{\n public static long numberCount (long N, long K)\n {\n // your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"numberCount(self,n,k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n for _ in range(int(input())):\n n, k = (int(x) for x in input().split())\n ob = Solution()\n print(ob.numberCount(n, k))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def sumOfDigits(self, val):\n ret = 0\n while val > 0:\n ret += val % 10\n val = val // 10\n return ret\n\n def numberCount(self, n, k):\n if n - self.sumOfDigits(n) < k:\n return 0\n\n low = k + 1\n # no number lesser than or equal to k\n # can have required value of difference\n # hence lower limit for binary search is set to k+1\n\n high = min(n, k + 90)\n # max sum of digits for a 10 digit\n # decimal number = 90\n # hence difference between (k+90) and\n # sumOfDigits(k+90) will definitely be >= k\n # hence upper limit for binary search is k+90\n\n # time complexity for this binary search is\n # constant as differnece between upper and\n # lower limits is capped at 89\n while high > low:\n mid = (high + low) // 2\n\n if mid - self.sumOfDigits(mid) < k:\n low = mid + 1\n else:\n high = mid\n\n return n - high + 1\n",
"updated_at_timestamp": 1730468492,
"user_code": "#User function Template for python3\n\nclass Solution:\n def numberCount(self,n,k):\n # code here\n"
} | eJy1Vr2OFDEMpqDiKaypTyj/se9JkBhEAVvQhCv2JCQEOomOGt4X20m0c9xkdm/31oUznk382bE/7zy8/vv7zSuVd7/44f336Uu5u99PtzD5uVhjwJq5OFkj29GAM9MNTLtvd7tP+93nj1/v920/2rn85D19dXWdftzAwqtTr02AVGSzDzFlJCDMKYYBBO/Vcx3BhUSGzBoOR09NQAHZVtfeWahwc+kvDNR1DIsCrTjsJXqDwanFBrKkUa7NvQD2AEASHSDFYKn5IrQU45HUCNoFYhdQPZfcBVSPM6s3WpNBzPwikVp8KrGVcS2GuLxO1StBHaqqT0/uW48IKEepyyhKvmXZWa/8cczimcW3DHIK7C3avpPzwbSaAdcjdgHVcwldQPVcfBdQzUzoAqpHZYwxCHhSYAlPrFpMduMkmaAW+7Bi+UGhF1yxLen/KjuX1AVUbzcx2ZXi8im54JRHjPUxE5MNQZQMBFnkLehPA0j5LQlQTTVwK3BtVqvhn8wAyd2Rx5Aj6ML14uJ6dGQhZId+hOq8xNToyk4whEi1FOxBJga5M0cTnTybJPc8mE1XIM81uMPp4jr7nz+BlvU9dxpJx75MPJeFMvq/keZJj8i6ydZtuoqDQBuEPcpYdyZl3amcPdbG6ap9bHg65Jfr482PhEu+EHjADz4PzmiZS3tmo2lOjIapvGCzUw49N65D1aoHaw4xffjz9h+1uNYy |
705,091 | Game with String | Given a string str of lowercase alphabets and a number k, the task is to print the minimum value of the string after removal of k characters. The value of a string is defined as the sum of squares of the count of each distinct character present in the string. Return the minimum possible required value.
Examples:
Input:
str = abccc, k = 1
Output:
6
Explanation:
We remove c to get the value as 1
**2
+ 1
**2
+ 2
**2
Input:
str = aabcbcbcabcc, k = 3
Output:
27
Explanation:
We remove two 'c' and one 'b'. Now we get the value as 3
**2
+ 3
**2
+ 3
**2
.
Note :
Here
n
is the length of string and p is number of distinct alphabets and k number of alphabets to be removed. | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int minValue(String s, int k)"
],
"initial_code": "// 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 s = in.readLine();\n int k = Integer.parseInt(in.readLine());\n\n Solution ob = new Solution();\n System.out.println(ob.minValue(s, k));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n static int minValue(String s, int k) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"minValue(self, s, k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n s = input()\n k = int(input())\n\n ob = Solution()\n print(ob.minValue(s, k))\n print(\"~\")\n",
"solution": "from collections import Counter\nimport heapq\n\n\nclass Solution:\n def minValue(self, s: str, k: int) -> int:\n # Dictionary to store the frequency of each character.\n freq_map = Counter(s)\n # Priority queue to store the frequencies in descending order.\n pq = [-freq for freq in freq_map.values()]\n heapq.heapify(pq)\n\n # Decreasing the frequencies k times to obtain the minimum value.\n for _ in range(k):\n freq = heapq.heappop(pq)\n freq += 1\n heapq.heappush(pq, freq)\n\n # Calculating the result by squaring the remaining frequencies in the priority queue.\n result = sum(freq ** 2 for freq in pq)\n\n # Returning the minimum value.\n return result\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def minValue(self, s, k):\n # code here"
} | eJytU8tOhEAQ9KD/Qea8MYBZjX6Bt72a2MYIDG+aAWZ4aDR+hP6vQMxuyGYaxJ3TJDPV1VVd/Xn+vbs4G8/DfX95fGMRCiXZncEswBdAE5BtDMZbwV3JvedcycP7R//4vjGOQJYWZOpAJEpLNcCu/k7muB6npG1p4HaFPMdxXUBbi7zWIF/3h+K1tR2PxJ7Hue8HQRhGURwnSZpmGWKeC1EUZVlVUipV103Ttl03ENkE0y3ljR+EUZykGeaiKCup6qbt+noWkSKd8IPXi/ybmfVRGQtgkoS1WVo0HkokAJ1FLXTQgqQnN7P5X7kA5q+b1M7O79BkIPDvueJp6oz97HXC5MvSkDx9Xf4AltPOmw== |
712,431 | Non-overlapping Intervals | Given an 2D arrayintervals of representing intervals where intervals [ i ] = [starti, endi), return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.
Examples:
Input:
intervals [] = [[1, 2], [2, 3], [3, 4], [1, 3]]
Output:
1
Explanation:
[1, 3] can be removed and the rest of the intervals are non-overlapping.
Input:
intervals [] = [[1, 3], [1, 3], [1, 3]]
Output:
2
Explanation:
You need to remove two [1, 3] to make the rest of the intervals non-overlapping.
| geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1666678237,
"func_sign": [
"static int minRemoval(int intervals[][])"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.math.*;\nimport java.util.*;\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 a[][] = new int[n][2];\n for (int i = 0; i < n; i++) {\n a[i][0] = sc.nextInt();\n a[i][1] = sc.nextInt();\n }\n Solution obj = new Solution();\n int ans = obj.minRemoval(a);\n System.out.println(ans);\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "// Java program to minimum number of intervals required \n// to be removed to make remaining intervals non-overlapping\n// Using sorting by ending value\n\nimport java.util.*;\n\nclass GfG {\n \n static int minRemoval(int[][] intervals) {\n int cnt = 0;\n\n // Sort by minimum ending point\n Arrays.sort(intervals, (a, b) -> a[1] - b[1]);\n\n int end = intervals[0][1];\n\n for (int i = 1; i < intervals.length; i++) {\n\n // if there is an overlap increase the count\n if (intervals[i][0] < end)\n cnt++;\n\n // else increment the ending point\n else\n end = intervals[i][1];\n }\n\n // return the count\n return cnt;\n }\n\n public static void main(String[] args) {\n int[][] intervals = {{1, 2}, {2, 3}, {3, 5}, {1, 4}};\n System.out.println(minRemoval(intervals));\n }\n}",
"updated_at_timestamp": 1731151468,
"user_code": "// User function Template for Java\n\nclass Solution {\n static int minRemoval(int intervals[][]) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1666815057,
"func_sign": [
"minRemoval(self, intervals)"
],
"initial_code": "# Initial Template for Python 3\n# Position this line where user code will be pasted.\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n intervals = [list(map(int, input().split())) for i in range(N)]\n ob = Solution()\n res = ob.minRemoval(intervals)\n print(res)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def minRemoval(self, intervals):\n N = len(intervals)\n if not intervals or N == 0:\n return 0\n\n # Sorting the intervals based on the start time\n intervals.sort()\n prevEnd = intervals[0][1]\n cnt = 0\n\n # Checking for overlapping intervals and counting the number of removals\n for i in range(1, N):\n if prevEnd > intervals[i][0]:\n cnt += 1\n prevEnd = min(prevEnd, intervals[i][1])\n else:\n prevEnd = intervals[i][1]\n\n return cnt\n",
"updated_at_timestamp": 1731151375,
"user_code": "#User function Template for python3\n\nclass Solution:\n def minRemoval(self, intervals):\n # Code here"
} | eJzVVLtOwzAU7cAAf3GVuUK+fsXmS5AwYoAOLIahlZAQiI+Aj2XjnpuoooNbpYUiuiRx4/PyuXk7+ZidzfR3+Xk6m109d/f1cbXsLqjjUkOpTL5US3LnKJbqqZdlSqV2c+oWT4+L2+Xi7uZhtRx3uVJf5c+XOW1CRWxjIzfEttREDHBPVpY4kpU1TmRDE9g3gBM0sjFQmTNk5gSdWYXmCMYssD1lD97smhR9gwKymRwYPAgC8NVQD/Sk4OpJXszEukVtNohCg0jgDCEJUFhQOFB4UARQRKWYmFAYEtKAgJjWxxgnY8WxEW7wr9ZH19AtPH5yNXTnYFsz3gh6bN1G5Mob1+E36FKLLnxrjAODHxk0EMXtgZsQV1Z7OE4e/EGnJZaN7NStlFghpd7tPHlne4OhiIuIELRoqMewiF9011CSp16My1MylPdswTDL/tBh3n8ghth/xXhrqNb15wn9bznfAgbX0wF3DdTWibI/3yp8biY269htUAAtMR9UjAN0y6tyLv9tEhJUH+dr8wedKMPA7FWN6/fzL0kAkzs= |
706,080 | Gadgets of Doraland | In Doraland, people have unique Identity Numbers called D-id. Doraemon owns the most popular gadget shop in Doraland. Since his gadgets are in high demand and he has only K gadgets left he has decided to sell his gadgets to his most frequent customers only. N customers visit his shop and D-id of each customer is given in an array array[ ].In case two or more people have visited his shop the same number of time he gives priority to the customer with higher D-id. Find the D-ids of people he sells his K gadgets to.
Examples:
Input:
N = 6
array[] = {1, 1, 1, 2, 2, 3}
K = 2
Output:
1 2
Explanation:
Customers with D-id 1 and 2 are most
frequent.
Input:
N = 8
array[] = {1, 1, 2, 2, 3, 3, 3, 4}
K = 2
Output:
3 2
Explanation:
People with D-id1 and 2 have
visited shop 2 timesTherefore, in this
case, the answer includes the D-id2 as 2 > 1.
Constraints:
1 ≤N ≤10**5
1≤D-id ≤10**4 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"ArrayList<Integer> TopK(ArrayList<Integer> array, int k)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nclass GfG\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 ArrayList<Integer> arr = new ArrayList<Integer>();\n ArrayList<Integer> res = new ArrayList<Integer>();\n for(int i=0; i<n; i++)\n {\n int x = sc.nextInt();\n arr.add(x);\n }\n int k = sc.nextInt();\n \n Solution obj = new Solution();\n res = obj.TopK(arr,k);\n \n for(int i=0; i<res.size();i++)\n {\n System.out.print(res.get(i) + \" \");\n }\n System.out.println(); \n \n \n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GfG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution\n{\n ArrayList<Integer>TopK(ArrayList<Integer> array, int k)\n {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"TopK(self, array, k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n n = int(input())\n array = [int(x) for x in input().strip().split()]\n k = int(input())\n obj = Solution()\n res = obj.TopK(array, k)\n for each in res:\n print(each, end=' ')\n print()\n\n print(\"~\")\n",
"solution": "class Solution:\n def TopK(self, array, k):\n # create an empty dictionary to store the count of each element in the array\n dicti = {}\n\n # iterate over the array\n for i in array:\n # if the element is already present in the dictionary, increment its count\n if i in dicti:\n dicti[i] += 1\n # if the element is not present in the dictionary, add it and set its count to 1\n else:\n dicti[i] = 1\n\n # create an empty list to store the count and element pairs\n listi = []\n\n # create a set of unique elements in the array\n st = set(array)\n\n # iterate over the unique elements\n for i in st:\n # append the count and element pair to the list\n listi.append([dicti[i], i])\n\n # sort the list in ascending order based on count\n listi.sort()\n\n # sort the list in descending order to get the elements with highest counts first\n listi = sorted(listi, reverse=True)\n\n # create an empty list to store the top k elements\n res = []\n\n # iterate over the list and append the top k elements to the result list\n for i in range(k):\n res.append(listi[i][1])\n\n # return the result list\n return res\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def TopK(self, array, k):\n # code here\n\n"
} | eJztl8tu1DAUhlnwBDyBlXWF7ON7n4NFpQ5iAbNgE7qYSkiIqg9R3reO/Tf5S3EoMxWiZXK+zxqpvsR1juNcv/5x/uZVvc7elR/n34bP48XlbjhVg9mMM8OJGrZfL7Yfd9tPH75c7u6qqM14Vf76/UT91FAX1YM4oC8pYWu4FpvRdvtypZp0+/Ob0asWrS+LmMaodyndnn2p1ulXpvvUKtdIiFgilPCKhyx37leGSKWDqVlnoDCNUy7VylyuuUi1WJsBNer0b+vazdVWF63W6vRT/h+16LTtLrdu81NLgcmpNr/JCAP00EELBRqomynDBCMM0EMHLRRooG7GDBOMMEAPHbRQoIG6GTJMMMIAPXTQQoEG6qbPMMEIA/TQQQsFmsmWiyuPAi1SpIVxtBjdNBdNe4Yg7P2cn5MoICLiLt0ywmjCEEJYwhGeCEQkEpEXRBOGEMISjvBEICKRiLxgNWEIISzhCE8EIhKJyAtOE4YQwhKO8EQgIpGIvOD1zOpWqmv9VLvq7qd/6cmzstcEpra6vlFW34/3XrQq7vuyfWZZOG1ex0R8KYnYO5llk/wjT2fuz0999rBjX02/X+Wf+h8S8Jh9T5t98ffpN5/J98hDt/IWeZJjdzieu/+tc7fMC/CoDce1bfbwU8tU3ZiVr/DjZ1591F7a8/bgO+/9zdtbgCXy5Q== |
705,636 | Adventure in a Maze | You have gota maze, which is a n*nGrid. Every cell of the maze contains these numbers 1, 2 or 3.
If it contains1 : means we can go Right from that cell only.
If it contains2 : means we can go Down from that cell only.
If it contains3 : means we can go Right and Down to both paths from that cell.We cant go out of the maze at any time.
Initially, 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).
You need to find the total number of paths from Entry to Exit Point.
There may be many paths but you need to select that path which contains the maximum number of Adventure.
The Adventure on a path is calculated by taking the sum of all the cell values thatlies in the path.
Examples:
Input:
matrix = {{1,1,3,2,1},{3,2,2,1,2},
{1,3,3,1,3},{1,2,3,1,2},{1,1,1,3,1}}
Output:
{4,18}
Explanation:
There are total 4 Paths Available
out of which The Max Adventure is 18. Total
possible Adventures are 18,17,17,16. Of these
18 is the maximum.
Constraints:
1 <= n <= 100 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int[] FindWays(int[][] matrix)"
],
"initial_code": "//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",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730436740,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public int[] FindWays(int[][] matrix)\n {\n // Code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"FindWays(self, matrix)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n n = int(input())\n matrix = []\n for _ in range(n):\n cur = list(map(int, input().split()))\n matrix.append(cur)\n obj = Solution()\n ans = obj.FindWays(matrix)\n for _ in ans:\n print(_, end=\" \")\n print()\n",
"solution": "def modulo(p):\n return (p % 1000000007)\n\n\n# Initialize right and down variables\nright, down = 1, 2\n\n\nclass Solution:\n # Function to find the number of ways and maximum advantage.\n def FindWays(self, maze):\n n = len(maze)\n\n # Initialize advantage matrix and path count matrix.\n adv = [[0]*n for _ in range(n)]\n adv[0][0] = maze[0][0]\n\n pts = [[0]*n for _ in range(n)]\n pts[0][0] = 1\n\n # Loop to compute advantage and path count for the first row.\n for j in range(1, n):\n if maze[0][j-1] == down:\n break\n adv[0][j] = adv[0][j-1] + maze[0][j]\n pts[0][j] = 1\n\n # Loop to compute advantage and path count for the first column.\n for i in range(1, n):\n if maze[i-1][0] == right:\n break\n adv[i][0] = adv[i-1][0] + maze[i][0]\n pts[i][0] = 1\n\n # Loop to compute advantage and path count for the remaining cells.\n for i in range(1, n):\n for j in range(1, n):\n if maze[i-1][j] != right and pts[i-1][j]:\n adv[i][j] = adv[i-1][j] + maze[i][j]\n pts[i][j] = pts[i-1][j]\n if maze[i][j-1] != down and pts[i][j-1]:\n adv[i][j] = max(adv[i][j], adv[i][j-1] + maze[i][j])\n pts[i][j] += pts[i][j-1]\n\n # If there is no path to reach the destination, return (0,0).\n if not pts[-1][-1]:\n return (0, 0)\n\n # Return the number of ways and maximum advantage modulo 10^9+7.\n return (modulo(pts[-1][-1]), adv[-1][-1])\n",
"updated_at_timestamp": 1727776457,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef FindWays(self, matrix):\n\t\t# Code here"
} | eJzVVUsKwjAQdeHCYwxZi3QSq+BJBBUX2oWb6qKCIIKH0Puaz8QfM8VUUWzSfKa8eZP5pMf2Oe+0/DPu2cVkr1blZlupESiclrYb1QVV7DbFoiqW8/W2il/BwLRUhy48QrRFgR0MoIjsS0gNYRCQGWQs0jg62x4nQckAMGe19J3lvtUsEi3L/XFCS1k2cQBpMNFayQEaULNaMLse8779tTA9Xoag5FP3RofepG7jM502Yq5pZHkGUSPFy0fPCojLBC7HFqQ68AU5WYfRDjFdhqD5UnvjpOaVGkPgS8ydtOZC4W8UD6pDMTAgnO3fz+rfpbV0Kb8Yb7qE347xE1dKUrk5mdKravbT+YS1KJPWu0gH1g96gg+0i6lc3NC0umen3gUcLA5t |
703,137 | String Reversal | Given a string, say S, print it in reverse manner eliminating the repeated characters and spaces.
Examples:
Input:
S = "GEEKS FOR GEEKS"
Output:
"SKEGROF"
Input:
S = "I AM AWESOME"
Output:
"EMOSWAI"
| geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public String reverseString(String s)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\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());\n while(t-->0)\n {\n String s = br.readLine();\n Solution ob = new Solution();\n System.out.println(ob.reverseString(s));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GfG",
"solution": "class Solution {\n public String reverseString(String s) {\n String ans = \"\";\n int present[] = new int[26];\n Arrays.fill(present, 0);\n for (int i = s.length() - 1; i >= 0; i--) {\n if (s.charAt(i) == ' ' || present[s.charAt(i) - 'A'] == 1) continue;\n present[s.charAt(i) - 'A'] = 1;\n ans += s.charAt(i);\n }\n return ans;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public String reverseString(String s)\n {\n //code here.\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"reverseString(self, s)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n s = input().strip()\n ob = Solution()\n ans = ob.reverseString(s)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n def reverseString(self, s):\n ans = '' # initialize an empty string to store the reversed string\n # initialize a list to keep track of the presence of each letter\n present = [0]*26\n for i in reversed(s): # iterate through the string in reversed order\n # if the character is a space or already present, skip it\n if i == ' ' or present[ord(i)-ord('A')] == 1:\n continue\n present[ord(i)-ord('A')] = 1 # mark the presence of the character\n ans += i # add the character to the reversed string\n return ans # return the reversed string\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def reverseString(self, s):\n # code here\n"
} | eJy1Vk1v00AQ5cCNPzGKxK1Canvjtl6v7XH2y/vhL4I4QA9cTA9FQkIgfgT8X2adAFGJ27RKLcuxd2PPm3nvze6P57/OXjybj/4l3bz5uvo4XX++Wb2G1eVmqoSUBjrjZL6ZQiWgicjXkDnTaShMD3VU1oNphYM0Ldk4QG7KzcQynouirLBeS6WNbZwPse36YVydwerqy/XV+5urD+8+fb7ZRcslfVRUm+n7ZipNPoxMiiq41lsV677QXbbm2MzT49B3bQzeNdZoJdc1VmUhcp6xeXr17Qz20rggMKCYBgZWzj+caSbB0lXRGz5aQs+ZxMKxEiX6gFz0FmkkNxxN9AuQmdJW8jmmjwZ5LpntRShdcQjHOQG/61gIMi7kFCr0QCeDIHwAHxzqkjhxkEcrkTMapsy1IV7cn+kOQwVOWEGzOfCKOcaDcEsJehEYR2lj7kxR6i053onAWZVb7EptFjJNYnAMNdDpbbopmJSeeEAtBzB6lgvxgXohtqb6W1KAGZQv3EIRbsvx1vNmSvqkTGeBsr/yhMPDC0h6Q+pzSX6x2ZenE23S5kIFGMuSBURRlGVVIdb1ei2lUlobY23TOOd9CDG2bdf1/TAsC+BBar/c1p5TCUjTHekjgMJcY1kFWJzZTEZzkchikMkoQBmi6MDY1tiQnA3J2pC8DcnckNwNi/YOVYk6V8x33DgxI9dGiSgzhvxxrraMuFYDZET8LOwCW0E8jkKDxCaSFepYkgk89pR2IrkwhkS4Yz9aCAa8EHNdMkz2WFKjL2PtTINSizFviyp0fTaoNWd2mwp5ISOxekNeUbUsSB+O93eY48hGmh7oDxIF8dWxgT53GOBAjAqUha4CyXN0szR7Em1z0p6Yn7gpngDItqBHwDnfg+OPwnMA0H8A2LGlYCl4in3c4oD6uOVB42MaUHi6DnTfOveghW63BzmdTMxC9Ivd1uPhejlZG5rN7k/QiHxaNu9tRI+A/kRI70C4Zf3Ajuap+sW/LY9We4JwCegO49ufr34DPGFiFg== |
702,662 | Find Unique pair in an array with pairs of numbers | Given an array arr where every element appears twice except a pair (two elements). Return the elements of this unique pair in sorted order.
Examples:
Input:
arr[] = [2, 2, 5, 5, 6, 7]
Output:
[6, 7]
Explanation:
We can see we have [2, 2, 5, 5, 6, 7]. Here 2 and 5 are coming two times. So, the answer will be 6 7.
Input:
arr[] = [1, 3, 4, 1]
Output:
[3, 4]
Explanation:
1 is appearing two times and 3 and 4 appear one times.
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ 10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1617216538,
"func_sign": [
"public ArrayList<Integer> findUniquePair(int arr[])"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass Main {\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 ArrayList<Integer> array1 = new ArrayList<Integer>();\n String line = read.readLine();\n String[] tokens = line.split(\" \");\n for (String token : tokens) {\n array1.add(Integer.parseInt(token));\n }\n ArrayList<Integer> v = new ArrayList<Integer>();\n int[] arr = new int[array1.size()];\n int idx = 0;\n for (int i : array1) arr[idx++] = i;\n\n v = new Solution().findUniquePair(arr);\n\n for (int i = 0; i < v.size(); i++) System.out.print(v.get(i) + \" \");\n\n System.out.println();\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n public ArrayList<Integer> findUniquePair(int arr[]) {\n int n = arr.length;\n // Initializing XOR with the first element of the array\n int XOR = arr[0];\n // Performing XOR operation on all the elements of the array\n for (int i = 1; i < n; i++) XOR = XOR ^ arr[i];\n // Finding the rightmost set bit in XOR\n int set_bit_no = XOR & ~(XOR - 1);\n // Initializing x and y with 0\n int x = 0, y = 0;\n // Dividing the numbers into two groups based on the rightmost set bit and\n // performing XOR operation\n for (int i = 0; i < n; i++) {\n int c = arr[i] & set_bit_no;\n if (c > 0) x = x ^ arr[i];\n else y = y ^ arr[i];\n }\n // Creating an ArrayList to store the unique pair of numbers\n ArrayList<Integer> v = new ArrayList<Integer>();\n // Adding the smaller number first and the larger number second in the ArrayList\n if (x < y) {\n v.add(x);\n v.add(y);\n } else {\n v.add(y);\n v.add(x);\n }\n // Returning the ArrayList with the unique pair of numbers\n return v;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n\n public ArrayList<Integer> findUniquePair(int arr[]) {\n\n // Complete the function\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1617216538,
"func_sign": [
"findUniquePair(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n arr = list(map(int, input().split()))\n ob = Solution()\n ans = ob.findUniquePair(arr)\n print(*ans)\n print(\"~\")\n t -= 1\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def findUniquePair(self, arr):\n n = len(arr)\n # XOR each element and get XOR of two unique elements(ans)\n XOR = arr[0]\n for i in range(1, n):\n XOR = XOR ^ arr[i]\n\n # Now XOR has XOR of two missing elements. Any set bit in it\n # must be set in one missing and unset in other missing number\n # Get a set bit of XOR (We get the rightmost set bit)\n set_bit_no = XOR & ~(XOR - 1)\n\n # Now divide elements in two sets by comparing rightmost set bit\n # of XOR with bit at same position in each element.\n x = 0\n y = 0 # Initialize missing numbers\n for i in range(0, n):\n if (arr[i] & set_bit_no):\n # XOR of first set in arr[]\n x = x ^ arr[i]\n else:\n # XOR of second set in arr[]\n y = y ^ arr[i]\n ans = []\n if (x < y):\n ans.append(x)\n ans.append(y)\n else:\n ans.append(y)\n ans.append(x)\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def findUniquePair(self, arr): \n \n # Complete the function"
} | eJylVM1OwzAM5oDEa1g9TyhO4jTlSZAY4gA9cBk7bNIkBOIh4Dm5cSZ2zGCo3trNiT9FtWsn/ns7//i6OBO6/iyHm+fmcbFcr5oraHC+QEDwZYWyItB80cyg6TfL/n7VP9w9rVeqKrLXIn6ZwT8LDngTb+/AE+/gZBPv6HijY4KOyfQiUlH1znDHGhkqoly8XK2sVFYLuawOOtBLoekpiNB4kNy2PKZyUI7KVDg5Z5reyoet+xBLrARTmzsniBVNm1XLskkS2orxD6YtomIrXzKj6avqIHZkJgGZoKJngsCk58gExFTPdhbkL9G0k+HcbvVAZlJsmdSX2rGeJZpaf4O+PHH5/iY8UOWozIkl2p94kQ8Xbm4TQUWGqMgQgMHrmY92KYi06o/uyKO7MWs3WumRPjRrVqTTgj0+2vJDi2aJygvNq1XxmB7NP03qsLRp1j71tukUXMzh8Pw6PAz2T7jyCNHbN0zxpBxI+MckQrSjnYup4yIdPS+Gw0tT4yuNeHqAd6fXpKo/ZdSJK7nQ7fvlNyJ9CdA= |
701,733 | Common Elements | Given two lists V1 and V2 of sizes n and m respectively. Return the list of elements common to both the lists and return the list in sorted order. Duplicates may be there in the output list.
Examples:
Input:
n = 5
v1[] = {3, 4, 2, 2, 4}
m = 4
v2[] = {3, 2, 2, 7}
Output:
2 2 3
Explanation:
The common elements in sorted order are {2 2 3}
Constraints:
1 ≤ n, m ≤ 10**5
1 ≤ V
i≤ 10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1731518154,
"func_sign": [
"public static ArrayList<Integer> commonElement(int a[], int b[])"
],
"initial_code": "// Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String[] args) {\n\n // taking input using Scanner class\n Scanner sc = new Scanner(System.in);\n\n // taking total count of testcases\n int t = sc.nextInt();\n sc.nextLine();\n while (t-- > 0) {\n // taking total count-1 of elements\n String temp[] = sc.nextLine().trim().split(\" \");\n int n = temp.length;\n\n // Declaring and Initializing an ArrayList-1\n int a[] = new int[n];\n\n // adding elements to the ArrayList-1\n for (int i = 0; i < n; i++) {\n a[i] = Integer.parseInt(temp[i]);\n }\n\n temp = sc.nextLine().trim().split(\" \");\n int m = temp.length;\n\n // Declaring and Initializing an ArrayList-1\n int b[] = new int[m];\n\n // adding elements to the ArrayList-1\n for (int i = 0; i < m; i++) {\n b[i] = Integer.parseInt(temp[i]);\n }\n Solution ob = new Solution();\n // calling the method common_element\n // and passing ArrayList 1, 2 as arguments\n // and storing the results in a new ArrayList\n ArrayList<Integer> ans = ob.commonElement(a, b);\n\n // printing the elements of the new ArrayList\n for (int i : ans) System.out.print(i + \" \");\n\n System.out.println();\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1731518154,
"user_code": "// User function Template for Java\n\nclass Solution {\n public static ArrayList<Integer> commonElement(int a[], int b[]) {\n // Your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1731518154,
"func_sign": [
"common_element(self,a,b)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n # n=int(input())\n a = list(map(int, input().split()))\n # m=int(input())\n b = list(map(int, input().split()))\n ob = Solution()\n ans = ob.commonElement(a, b)\n for i in ans:\n print(i, end=\" \")\n print()\n",
"solution": "# Backend complete function Template for python3\n\nclass Solution:\n # Function to find the common elements in two arrays.\n def commonElement(self, v1, v2):\n # Creating dictionaries to store the count of elements in each array.\n d = dict()\n d1 = dict()\n\n # Iterating over the first array and updating its count in dictionary d.\n for i in v1:\n if i not in d:\n d[i] = 1\n else:\n d[i] += 1\n\n # Iterating over the second array and updating its count in dictionary d1.\n for i in v2:\n if i not in d1:\n d1[i] = 1\n else:\n d1[i] += 1\n\n # Creating a list to store the common elements.\n ans = []\n\n # Iterating over the sorted dictionary d.\n for i in sorted(d):\n # Checking if the element is present in dictionary d1.\n if i in d1:\n # Appending the common element to the ans list, minimum of the counts.\n l = [i] * min(d[i], d1[i])\n ans += l\n\n # Returning the list of common elements.\n return ans\n",
"updated_at_timestamp": 1731518154,
"user_code": "#User function Template for python3\n\nclass Solution:\n def common_element(self,a,b):\n #code here"
} | eJylVEtOwzAQZQH3eMq6Qv7FSTgJEkUsIAs2oYtUqoSQOASckB2n4HmcVAXsUofYicafeTNvPnk9f/+8OJPn+oPCzXP1OGy2Y3WFSq+Hw1mtUPW7TX8/9g93T9txvgUevazwXdFSBQZWJIcaPgtgkwA1J6YhIJOUAalzIOIFXFClC54gjmuDPKE0lFYRK6BZQZQRD+bN2WN/hG4KnBDTp0BJPFLo0KKREanxpF0PYe3FF6Gbz55Ks6WGrqEdNBEZLY29KYlhNL9fxpBCQeUtmbSlkF2q0hKBOsIEQCtyw9dGS4krRcEy6qAUqN+QShc4BWZGWBKejD10A91C046agvxzG4ZQLAWSdlkvTDqyoa4LC28uspju/+X7ePXNgTpVWWUuntyJzjK4C5oxzuDxotYs/JnFbihqTbG+NCF1QQp+5W/4I4G3b5dfbZGm+Q== |
712,234 | Prefix to Infix Conversion | You are given a string Sof size N that represents the prefix form of a valid mathematical expression. The string S contains only lowercase and uppercase alphabets as operands and the operators are +, -, *, /, %, and ^.Convert it to its infix form.
Examples:
Input:
*-A/BC-/AKL
Output:
((A-(B/C))*((A/K)-L))
Explanation:
The above output is its valid infix form.
3<=|S|<=10**4 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1666246418,
"func_sign": [
"static String preToInfix(String pre_exp)"
],
"initial_code": "// Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.math.*;\nimport java.io.*;\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 sc.nextLine();\n String s = sc.next();\n Solution obj = new Solution();\n String ans = obj.preToInfix(s);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n static String preToInfix(String pre_exp) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1666250303,
"func_sign": [
"preToInfix(self, pre_exp)"
],
"initial_code": "# Initial Template for Python 3\n\n# Position this line where user code will be pasted.\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n prefix = input()\n ob = Solution()\n res = ob.preToInfix(prefix)\n print(res)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nfrom collections import deque\n\n\nclass Solution:\n # Function to convert prefix expression to infix expression.\n def preToInfix(self, s):\n def isOperator(x):\n return (x in '+-*/^%')\n\n stack = deque()\n n = len(s)\n\n # iterating over the prefix expression from right to left.\n for i in range(n - 1, -1, -1):\n ch = s[i]\n\n # if current character is an operator, pop the last two elements\n # from stack and create the infix expression for the current\n # operator and operands and push it back to the stack.\n if isOperator(ch):\n op1 = stack.pop()\n op2 = stack.pop()\n temp = '(' + op1 + ch + op2 + ')'\n stack.append(temp)\n else:\n # if current character is not an operator, push it to the stack.\n stack.append(ch)\n\n # return the infix expression obtained after converting the prefix expression.\n return stack.pop()\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def preToInfix(self, pre_exp):\n # Code here"
} | eJytk81OwzAQhHMofY7IUiT/1Fi9crPX7jMgEcwBcuASekglpArEQ8DzwiYpQj2MI1X47Jn5drz+WH2tr6rp3H6vquruKJ77/WEQN7XYtn32OWSKYlOL7nXfPQ7d08PLYThdkD7LkCXlqJRq+/e2F2+b+tzB+QDVLiBVw7kEdQ2nEkzUxgeLmaU3QWlJNmKHArOGzDwpRsajZk5zMWFcTswyugRxreE7xYFl0NwXT4zQm/GhqUAxPzWbNFExCirOjjYumrTDNHY20jyTTGaHV2dsJi1WA2FCuZeAZHSZjvy8OadYqKdF/d+/m5wwCrJigriwEVHZeSmK3aeLy//9w8Uqt6iKf6jufBunHpeLvP+8/gHlO4Mr |
712,384 | Assign Cookies | Assume you are an awesome parent of some children and want to give your children some cookies. But, you should give each child at most one cookie.Each child i has a greed factor greed[i], which is the minimum size of cookie that the child will be content with and each cookie j has a size cookie[j]. If cookie[j] >= greed[i], we can assign the cookie j to the child i**th, and the child i will be content.Find the maximum number of child that can be content.
Examples:
Input:
greed[] = [1, 2, 3], cookie = [1, 1]
Output:
1
Explanation:
You can only assign cookie 0 or 1 to child 0.
Input:
greed[] = [1, 2], cookie = [1, 2, 3]
Output:
2
Explanation:
You can assign cookie 0 to child 0 and cookie 1 to child 1.
Constraints:
1 ≤ greed.size() ≤ 10**5
1 ≤ cookie.size() ≤ 10**5
1 ≤ greed[i] , cookie[i] ≤ 10**9 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1666675622,
"func_sign": [
"public int maxChildren(int[] greed, int[] cookie)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.math.*;\nimport java.util.*;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n sc.nextLine(); // consume the newline\n for (int tc = 0; tc < t; tc++) {\n String[] greedStr = sc.nextLine().split(\" \");\n String[] cookieStr = sc.nextLine().split(\" \");\n\n int[] greed = Arrays.stream(greedStr).mapToInt(Integer::parseInt).toArray();\n int[] cookie =\n Arrays.stream(cookieStr).mapToInt(Integer::parseInt).toArray();\n\n Solution obj = new Solution();\n System.out.println(obj.maxChildren(greed, cookie));\n System.out.println(\"~\");\n }\n sc.close();\n }\n}",
"script_name": "Main",
"solution": "class Solution {\n public int maxChildren(int[] greed, int[] cookie) {\n // Sorting the greed factor and cookie size arrays\n Arrays.sort(greed);\n Arrays.sort(cookie);\n int i = 0, j = 0, ans = 0;\n while (i < greed.length && j < cookie.length) {\n if (cookie[j] >= greed[i]) {\n i++; // when the child gets the cookie, move to the next child\n ans++;\n }\n j++;\n }\n return ans;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "\nclass Solution {\n public int maxChildren(int[] greed, int[] cookie) {\n // Your code goes here.\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1666504140,
"func_sign": [
"maxChildren(self, greed, cookie)"
],
"initial_code": "# Initial Template for Python 3\n# Position this line where user code will be pasted.\n\ndef main():\n t = int(input().strip())\n for _ in range(t):\n greed = list(map(int, input().strip().split()))\n cookie = list(map(int, input().strip().split()))\n\n obj = Solution()\n print(obj.maxChildren(greed, cookie))\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def maxChildren(self, greed, cookie):\n # Sorting the greed factor and cookie size arrays\n greed.sort()\n cookie.sort()\n i, j, ans = 0, 0, 0\n while i < len(greed) and j < len(cookie):\n if cookie[j] >= greed[i]:\n i += 1 # when the child gets the cookie, move to the next child\n ans += 1\n j += 1\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def maxChildren(self, greed, cookie):\n #Your code goes here.\n"
} | eJxrYJnay8oABhFtQEZ0tVJmXkFpiZKVgpJhTB4QGSnpKCilVhSkJpekpsTnl5YgZOti8pRqdRRQtRgBdeHQYoBDi6EBDCCzSbQXoVEB2TxLGFAg32QFKMTtM5xakXSTqNVUAQqRmDiMMMXpcCMFYwUTiBEmQKYRTlfgMgJkAAiaQEwDm4fDCGPcwQeOEnAEQGKBsJfwxIUBZuCAJcAMQ1IjF8ODhqT7EDOQyAgleEoBeon01IIeLpQHDHr6I8M/hmg5AM4kNzcYGhKVH0zwZWTCTiM3r0NyB458R0wmhIVl7BQ9AMPTlDI= |
703,705 | Sum-string | Given a string of digits, the task is to check if it is a ‘sum-string’. A string S is called a sum-string when it is broken down into more than one substring and the rightmost substring can be written as a sum of two substrings before it and the same is recursively true for substrings before it. Please note that, the rightmost substring shouldnot contain leading zeroes.
Examples:
Input:
S = "12243660"
Output:
1
Explanation:
"12243660" can be broken down as {"12", "24", "36", "60"}.
We can get 60 from 24 and 36 as 24 + 36 = 60. Similarly 36 can be written as 12 + 24.
Input:
1111112223
Output:
1
Explanation:
"1111112223" can be broken down as {"1", "111", "112", "223"}.
We can get 223 from 111 and 112 as 111 + 112 = 223. Similarly 112 can be written as 1 + 111.
Constraints:
1 <= |S| <= 500
String consists of characters from '0' to '9'. | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int isSumString(String S)"
],
"initial_code": "//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 S = read.readLine();\n\n Solution ob = new Solution();\n System.out.println(ob.isSumString(S));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution{\n public int isSumString(String S){\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"isSumString(ob,S)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n S = str(input())\n ob = Solution()\n print(ob.isSumString(S))\n print(\"~\")\n",
"solution": "class Solution:\n def string_sum(self, str1, str2):\n if len(str1) < len(str2):\n str1, str2 = str2, str1\n\n m, n = len(str1), len(str2)\n ans = \"\"\n carry = 0\n\n for i in range(n):\n ds = ((ord(str1[m - 1 - i]) - ord('0')) +\n (ord(str2[n - 1 - i]) - ord('0')) +\n carry) % 10\n\n carry = ((ord(str1[m - 1 - i]) - ord('0')) +\n (ord(str2[n - 1 - i]) - ord('0')) +\n carry) // 10\n\n ans = chr(ds + ord('0')) + ans\n\n for i in range(n, m):\n ds = (ord(str1[m - 1 - i]) - ord('0') +\n carry) % 10\n carry = (ord(str1[m - 1 - i]) - ord('0') +\n carry) // 10\n ans = chr(ds + ord('0')) + ans\n\n if carry:\n ans = chr(carry + ord('0')) + ans\n return ans\n\n def checkSumStrUtil(self, string, beg, len1, len2):\n s1 = string[beg: beg + len1]\n s2 = string[beg + len1: beg + len1 + len2]\n s3 = self.string_sum(s1, s2)\n s3_len = len(s3)\n\n if s3_len > len(string) - len1 - len2 - beg:\n return False\n\n if s3 == string[beg + len1 + len2: beg + len1 + len2 + s3_len]:\n if beg + len1 + len2 + s3_len == len(string):\n return True\n return self.checkSumStrUtil(string, beg + len1, len2, s3_len)\n return False\n\n def isSumStr(self, string):\n n = len(string)\n\n for i in range(1, n):\n for j in range(1, n - i):\n if self.checkSumStrUtil(string, 0, i, j):\n return True\n return False\n\n def isSumString(self, S):\n return int(self.isSumStr(S))\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def isSumString (ob,S):\n # code here "
} | eJxrYJlazMIABhE5QEZ0tVJmXkFpiZKVgpJhTJ6hko6CUmpFQWpySWpKfH5pCVTKICavLiZPqVZHAU29EakacOowxGmFsamFobERLqfh1GcAhKS6zsDAyMDA2MCARLsMDMl1pSUEkOhOXO7DHU3GJIc6WdYgfERmDMBDEu4GnEGK1xUGQGyEO7Hh0mtJZnwYGiI0QwIBh1+ggUOi+aR6wwh3hBMONXLDjFCgxU7RAwBrWl5/ |
703,720 | Count divisors of product of array elements | Given an array arr, the task is to find the count of factors of a number x which is a product of all array elements
Examples:
Input:
arr[] = [2, 4, 6]
Output:
10
Explanation:
2 * 4 * 6 = 48, the factors of 48 are 1, 2, 3, 4, 6, 8, 12, 16, 24, 48 whose count is 10.
Input:
arr[] = [3, 5, 7]
Output:
8
Explanation:
3 * 5 * 7 = 105, the factors of 105 are 1, 3, 5, 7, 15, 21, 35, 105 whose count is 8.
Constraints:
2<= arr.size() <=10**4
1<= arr[i] <=10**2 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1617639273,
"func_sign": [
"public long countDivisorsMult(int[] arr)"
],
"initial_code": "import java.util.*;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n int t = Integer.parseInt(scanner.nextLine());\n\n while (t-- > 0) {\n String line = scanner.nextLine();\n String[] elements = line.split(\" \");\n int arr[] = new int[elements.length]; // Correctly declared as int[]\n\n for (int i = 0; i < elements.length; i++) {\n arr[i] = Integer.parseInt(elements[i]);\n }\n\n Solution ob = new Solution();\n System.out.println(ob.countDivisorsMult(arr));\n }\n scanner.close();\n }\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1727947200,
"user_code": "// User function Template for Java\n\nclass Solution {\n public long countDivisorsMult(int[] arr) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1617639273,
"func_sign": [
"countDivisorsMult(self, arr)"
],
"initial_code": "# Initial Template for Python 3\ndef main():\n T = int(input())\n\n while T > 0:\n a = list(map(\n int,\n input().strip().split())) # Convert input to list of integers\n print(Solution().countDivisorsMult(a))\n T -= 1\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "import math\nfrom collections import defaultdict\n\n\nclass Solution:\n def checkprimebysieve(self, largest, prime):\n isPrime = [True] * (largest + 1)\n p = 2\n while p * p <= largest:\n if isPrime[p]:\n for i in range(p * 2, largest + 1, p):\n isPrime[i] = False\n p += 1\n\n for p in range(2, largest + 1):\n if isPrime[p]:\n prime.append(p)\n\n def countDivisorsMult(self, a):\n largest = max(a)\n prime = []\n self.checkprimebysieve(largest, prime)\n\n mp = defaultdict(int)\n for num in a:\n for p in prime:\n while num > 1 and num % p == 0:\n num //= p\n mp[p] += 1\n if num != 1:\n mp[num] += 1\n\n res = 1\n for count in mp.values():\n res *= (count + 1)\n\n return res\n",
"updated_at_timestamp": 1727947200,
"user_code": "#User function Template for python3\n\nclass Solution:\n def countDivisorsMult(self, arr):\n #Code here\n \n \n \n \n"
} | eJydlDFOBDEMRSn2IF+pVyh2EifhJEgsooApaIYtdqWVEBKHgNPQcTI8w0iAZA+CqVLk237/x/O8eX3fnM3f5Zserh7D/bg/HsIFAu1GihElggsohi3CcNoPt4fh7ubheFhu5bgbw9MWP4WMhIIKIlBylJItJTFI2zXw3Dd5fbmwJU/o4IpGjozIUimjonqdTEJly2ACN6TiKLvY3mQ0kCAxJIO0AhdxSqRqmqR91eKEnFEKRFCVuaF3D1uiSdE7usoquqB7GJSyHRUmFJlg1D+eDFGqOTqnUqnmFN4LMRMmL1rnNiariuGVFM8tIRv4M3Om9dST/WC+r8Rfd+ILYn1wdrZxWeVpAFpfSrP/rJelQP5PBfrtN0LNN7xmworfbWa+fjn/AJ7RViU= |
702,890 | Left most and right most index | Given a sorted array with possibly duplicate elements. The task is to find indexes of first and last occurrences of an element X in the given array.
Examples:
Input:
N = 9
v[] = {1, 3, 5, 5, 5, 5, 67, 123, 125}
X = 5
Output:
2 5
Explanation:
Index of first occurrence of 5 is 2
and index of last occurrence of 5 is 5.
Input:
N = 9
v[] = {1, 3, 5, 5, 5, 5, 7, 123, 125}
X = 7
Output:
6 6
Constraints:
1 ≤ N ≤ 10**5
1 ≤ v[i], X ≤ 10**18 | geeksforgeeks | Easy | {
"class_name": null,
"created_at_timestamp": 1615292571,
"func_sign": [
"public pair indexes(long v[], long x)"
],
"initial_code": "//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nclass pair { \n long first, second; \n public pair(long first, long second) \n { \n this.first = first; \n this.second = second; \n } \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 long n = Long.parseLong(br.readLine().trim());\n long a[] = new long[(int)(n)];\n // long getAnswer[] = 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 long k = Long.parseLong(br.readLine().trim());\n \n Solution obj = new Solution();\n pair ans = obj.indexes(a, k);\n if (ans.first == -1 && ans.second == -1)\n System.out.println(-1);\n else\n System.out.println(ans.first+\" \"+ans.second);\n \n \nSystem.out.println(\"~\");\n}\n\t}\n}\n\n",
"script_name": "GFG",
"solution": "class Solution {\n // Binary search function to find the lower bound\n int lower_bound(long A[], int L, int R, long K) {\n int pos = R + 1;\n // binary search loop\n while (L <= R) {\n int M = (L + R) / 2;\n // if element at middle position is greater than or equal to K,\n // update pos to current middle position and move the right pointer to M-1\n if (A[M] >= K) {\n pos = M;\n R = M - 1;\n } else\n L = M + 1; // if element at middle position is less than K, move the left pointer to M+1\n }\n return pos; // return the lower bound position\n }\n\n // Binary search function to find the upper bound\n int upper_bound(long A[], int L, int R, long K) {\n int pos = -1;\n // binary search loop\n while (L <= R) {\n int M = (L + R) / 2;\n // if element at middle position is less than or equal to K,\n // update pos to current middle position and move the left pointer to M+1\n if (A[M] <= K) {\n pos = M;\n L = M + 1;\n } else\n R = M - 1; // if element at middle position is greater than K, move the right pointer to M-1\n }\n return pos; // return the upper bound position\n }\n\n // Function to find the indexes of an element in an array using lower bound and upper bound\n public pair indexes(long v[], long x) {\n // find the lower bound of x in the array\n int lb = lower_bound(v, 0, v.length - 1, x);\n // find the upper bound of x in the array\n int ub = upper_bound(v, 0, v.length - 1, x);\n // if lower bound is equal to array length or the element at lower bound position is not equal\n // to x,\n // return a pair of (-1,-1) indicating that the element is not found in the array\n if (lb == v.length || v[lb] != x) return new pair(-1, -1);\n // return a pair of lower bound and upper bound positions indicating the indexes of x in the\n // array\n return new pair(lb, ub);\n }\n}\n;\n",
"updated_at_timestamp": 1730269934,
"user_code": "//User function Template for Java\n\n/*\nclass pair { \n long first, second; \n public pair(long first, long second) \n { \n this.first = first; \n this.second = second; \n } \n}\n*/\n\nclass Solution {\n \n public pair indexes(long v[], long x)\n {\n // Your code goes here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"indexes(self, v, x)"
],
"initial_code": "# Initial Template for Python 3\n\ndef main():\n T = int(input())\n\n while T > 0:\n n = int(input())\n a = [int(x) for x in input().strip().split()]\n k = int(input())\n obj = Solution()\n ans = obj.indexes(a, k)\n if ans[0] == -1 and ans[1] == -1:\n print(-1)\n else:\n print(ans[0], end=' ')\n print(ans[1])\n\n T -= 1\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "def lower_bound(A, L, R, K):\n pos = R + 1\n while L <= R:\n M = (L + R) // 2\n if A[M] >= K: # find the lower bound of K in array A\n pos = M # stores the position of lower bound\n R = M - 1 # update the right boundary\n else:\n L = M + 1 # update the left boundary\n\n return pos\n\n\ndef upper_bound(A, L, R, K):\n pos = -1\n while L <= R:\n M = (L + R) // 2\n if A[M] <= K: # find the upper bound of K in array A\n pos = M # stores the position of upper bound\n L = M + 1 # update the left boundary\n else:\n R = M - 1 # update the right boundary\n\n return pos\n\n\nclass Solution:\n def indexes(self, Arr, K):\n # find the lower bound of K in Arr\n lb = lower_bound(Arr, 0, len(Arr) - 1, K)\n # find the upper bound of K in Arr\n ub = upper_bound(Arr, 0, len(Arr) - 1, K)\n\n if lb == len(Arr) or Arr[lb] != K: # K not found in Arr\n return [-1, -1]\n\n return [lb, ub] # returns the lower bound and upper bound of K in Arr\n",
"updated_at_timestamp": 1730269934,
"user_code": "#User function Template for python3\n\nclass Solution:\n def indexes(self, v, x):\n # Your code goes here\n "
} | eJytlU1OwzAQhVkgcY1R1gXF49hxOAkSRiwgCzami1RCQiAOAbdkxwWwJzWYtOOU1MlUqvLzzbzx8+Tt9OPr7ISOq0//5/q5enDrzVBdQiWsE7X/wc7pL1pXraDqn9b93dDf3z5uhu1bNXTWvfrbLyvYB0OQ0IACDS0Y6ICu1iyum8UhIQM0YJV1yMIEyCxsPBOgdZKFeQGzQmUq1rqGhVHhe2GYyIzIUSzJJbimBG2uWhXy769WjdInfYzQfN18E+Rkef7WnCagJOSF4AYKXw/6sE7xa+kfa7ieqdRpMZP55f+kkB5CoUBoEC0IQ9FlTRleZp1kopMw8breUTmziXA5Xh/Fj0u3XT5hMLRQaNpXQjDAc3G8DbC4D4p5sNMLsk9minX5ecK2MDfo8P+Tjt3uPkrundnZUcAzukVT3DXJd6qkhw7/5i1uzEGyozFu3i++AeZuDK8= |
709,986 | Smallest window containing 0, 1 and 2 | Given a string S consisting of the characters 0, 1 and 2. Your task is to find the length of the smallest substring of string S that contains all the three characters 0, 1 and 2. If no such substring exists, then return -1.
Examples:
Input:
S = 10212
Output:
3
Explanation:
The substring 102 is the smallest substring
that contains the characters 0, 1 and 2.
Input:
S = 12121
Output:
-1
Explanation:
As the character 0 is not present in the
string S, therefor no substring containing
all the three characters 0, 1 and 2
exists. Hence, the answer is -1 in this case.
Constraints:
1 ≤ length( S )≤ 10**5
All the characters of String S lies in the set {'0', '1', '2'} | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1645891581,
"func_sign": [
"public int smallestSubstring(String S)"
],
"initial_code": "// 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 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 Solution ob = new Solution();\n int ans = ob.smallestSubstring(S);\n\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n public int smallestSubstring(String S) {\n // Set a flag to check if an answer exists\n boolean answerExist = false;\n \n // Initialize variables to keep track of the last positions\n int lastZero = -1, lastOne = -1, lastTwo = -1;\n \n // Initialize the answer length to be the length of the input string\n int ans = S.length();\n \n // Iterate through each character in the input string\n for (int i = 0; i < S.length(); i++) {\n // Update the last positions based on the current character\n if (S.charAt(i) == '0') {\n lastZero = i;\n } else if (S.charAt(i) == '1') {\n lastOne = i;\n } else {\n lastTwo = i;\n }\n\n // Check if all three positions have been updated\n if (lastZero != -1 && lastOne != -1 && lastTwo != -1) {\n // Set the flag to indicate that an answer exists\n answerExist = true;\n \n // Calculate the length of the substring and update the answer length\n ans = Math.min(\n ans,\n 1 + i - Math.min(lastZero, Math.min(lastOne, lastTwo)));\n }\n }\n \n // Check if an answer exists and return the final answer\n if (answerExist) {\n return ans;\n }\n return -1;\n }\n};",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int smallestSubstring(String S) {\n // Code here\n }\n};\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1645891581,
"func_sign": [
"smallestSubstring(self, S)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for i in range(t):\n S = input()\n ob = Solution()\n ans = ob.smallestSubstring(S)\n\n print(ans)\n",
"solution": "class Solution:\n def smallestSubstring(self, S):\n answerExist = False\n lastZero, lastOne, lastTwo = -1, -1, -1\n ans = len(S)\n for i in range(len(S)):\n if S[i] == '0': # if current character is '0', then update lastZero position\n lastZero = i\n elif S[i] == '1': # if current character is '1', then update lastOne position\n lastOne = i\n else: # if current character is '2', then update lastTwo position\n lastTwo = i\n\n if lastZero != -1 and lastOne != -1 and lastTwo != -1: # if all three positions have been updated\n answerExist = True # set answerExist to True\n # calculate new substring length and update ans\n ans = min(ans, 1 + i - min(lastZero, min(lastOne, lastTwo)))\n\n if answerExist: # if answerExist is True, return ans\n return ans\n\n return -1 # if answer does not exist, return -1\n",
"updated_at_timestamp": 1727776457,
"user_code": "#User function Template for python3\n\nclass Solution:\n def smallestSubstring(self, S):\n # Code here"
} | eJxrYJlqwsoABhG6QEZ0tVJmXkFpiZKVgpJhTJ5BTJ6SjoJSakVBanJJakp8fmkJVFIXKKtUq6OAqt6QRPVGJKo3MMStwxirg4wMjEjWZGRoAESk6TGAA1KDzAAGSdUIdCXQnSQ60wgYIqT6DRweyIFJatjExEDSBjm6YPZDeEguIMs4kl0BTQsxhmhxjMZFhGwMUgIi1YFQaxAuBSEUf0OCgYigwWm3Cb4YQnY8mg9Jzg2Q7I0cYKTmdkPCLouJAbuN3DyEMB3TeFD44/V07BQ9AMNBkdo= |
717,670 | Two Swaps | Given a permutation of first n natural numbers as an array arr[]. Your task is to sortthearrayin exactly two swaps. If It is possible to sort the array then return true otherwise return false.
Examples:
Input:
arr[] = [4, 3, 2, 1]
Output:
true
Explanation:
swap(arr[1], arr[4]), now arr[] = [1, 3, 2, 4]
swap(arr[2], arr[3]), now arr[] = [1, 2, 3, 4]
Input:
arr[] = [4, 3, 1, 2]
Output:
false
Explanation:
Not possible to sort the array in 2 swaps.
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ arr.size() | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1697475696,
"func_sign": [
"boolean checkSorted(int arr[])"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\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());\n while (t-- > 0) {\n // int k = Integer.parseInt(br.readLine());\n String line = br.readLine();\n String[] tokens = line.split(\" \");\n\n // Create an ArrayList to store the integers\n ArrayList<Integer> array = new ArrayList<>();\n\n // Parse the tokens into integers and add to the array\n for (String token : tokens) {\n array.add(Integer.parseInt(token));\n }\n\n int[] arr = new int[array.size()];\n int idx = 0;\n for (int i : array) arr[idx++] = i;\n Solution obj = new Solution();\n Boolean ans = obj.checkSorted(arr);\n\n if (ans) {\n System.out.println(\"true\");\n } else {\n System.out.println(\"false\");\n }\n\n cout << \"~\" << endl;\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\nclass Solution {\n boolean checkSorted(int arr[]) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1697475696,
"func_sign": [
"checkSorted(self,arr)"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n arr = list(map(int, input().split()))\n ob = Solution()\n res = ob.checkSorted(arr)\n if res == True:\n print(\"true\")\n else:\n print(\"false\")\n t -= 1\n print(\"~\")\n",
"solution": "# User function Template for python3\nclass Solution:\n\n def checkSorted(self, arr):\n N = len(arr)\n cnt = 0\n\n # Step 1: Count the number of mismatches\n for i in range(N):\n if arr[i] != i + 1:\n cnt += 1\n\n # Step 2: Handle base cases\n if cnt == 0:\n return True # Already sorted\n if cnt > 4 or cnt < 3:\n return False # More than 4 or fewer than 3 mismatches cannot be fixed with a single swap\n if cnt == 3:\n return True # Special case when there are exactly 3 mismatches\n\n # Step 3: Verify if swapping will solve the problem\n for i in range(N):\n if arr[i] != i + 1:\n # Check if swapping the current element with its correct position would fix the array\n if arr[arr[i] - 1] != i + 1:\n return False\n\n return True # The array can be sorted with a single swap\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def checkSorted(self,arr): \n #code here"
} | eJyllE0KwjAQRl3o3p3bj6yLmL9GPYlgRUQrCBKLtiCI4iH0vqZpwVZpwTGrEPIyMy+T3LvPQa/jx6zvJvML29kkS9kUjEdWQ0BCgbMALD4n8TqNN8tDlpZbtqv9KY7sLbLsGqDOhtCOlO4ECs09qaBJbBGXwkpwR/rcCbTxdG5MIyRlrj0tKOwIE4xh8L/4nBeNBaTHrBkWPjTFvFFveZJkz3drc7O25F1RRnHmEpdKoqVdW2IbVX1o/zr4bEKeH04QQtJffz/0r+O7jnKlKId+z/rHn2XxGL4Aa2+JaQ== |
714,010 | Make the array beautiful | Given an array of negative and non-negative integers. You have to make the array beautiful. An array is beautiful if two adjacent integers, arr[i] and arr[i+1] are either negative or non-negative. And you can do the followingoperation any number of times until the array becomes beautiful.
Examples:
Input:
4 2 -2 1
Output:
4 1
Explanation:
As at indices 1 and 2 , 2 and -2 have
different sign, they are removed. And the the final
array is: 4 1.
Input:
2 -2 1 -1
Output:
[]
Explanation:
As at indices 0 and 1, 2 and -2 have
different sign, so they are removed. Now the array
is 1 -1.Now 1 and -1 are also removed as they have
different sign. So the final array is empty.
| geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1676012645,
"func_sign": [
"public static ArrayList<Integer> makeBeautiful(int[] arr)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass IntArray {\n public static int[] input(BufferedReader br, int n) throws IOException {\n String[] s = br.readLine().trim().split(\" \");\n int[] a = new int[n];\n for (int i = 0; i < n; i++) a[i] = Integer.parseInt(s[i]);\n\n return a;\n }\n\n public static void print(int[] a) {\n for (int e : a) System.out.print(e + \" \");\n System.out.println();\n }\n\n public static void print(ArrayList<Integer> a) {\n\n for (int e : a) 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 =\n new BufferedReader(new InputStreamReader(System.in));\n PrintWriter out = new PrintWriter(System.out);\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 int[] arr = IntArray.input(br, n);\n\n Solution obj = new Solution();\n ArrayList<Integer> res = obj.makeBeautiful(arr);\n for (int e : res) out.print(e + \" \");\n out.println();\n \nout.println(\"~\");\n}\n out.close();\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public static ArrayList<Integer> makeBeautiful(int[] arr) {\n // code here\n ArrayList<Integer> l = new ArrayList<>();\n for (int i = 0; i < arr.length; i++) {\n if (l.size() == 0) {\n l.add(arr[i]);\n } else {\n if (check(l.get(l.size() - 1), arr[i])) {\n l.remove(l.size() - 1);\n } else {\n l.add(arr[i]);\n }\n }\n }\n return l;\n }\n static boolean check(int a, int b) {\n return ((a < 0 && b >= 0) || (a >= 0 && b < 0));\n }\n}",
"updated_at_timestamp": 1730482207,
"user_code": "class Solution {\n public static ArrayList<Integer> makeBeautiful(int[] arr) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1676012645,
"func_sign": [
"makeBeautiful(self, arr: List[int]) -> List[int]"
],
"initial_code": "# Initial Template for Python\n\nif __name__ == \"__main__\":\n t = int(input())\n\n for _ in range(t):\n n = int(input())\n arr = list(map(int, input().split()))\n\n obj = Solution()\n res = obj.makeBeautiful(arr)\n print(*res)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nfrom typing import List\n\n\nclass Solution:\n def makeBeautiful(self, arr: List[int]) -> List[int]:\n # code here\n\n # Function to check if two consecutive elements have opposite signs\n def check(a, b):\n return (a < 0 and b >= 0) or (a >= 0 and b < 0)\n\n # Stack to store the result\n st = []\n\n # Iterating over the array\n for i in range(len(arr)):\n # If the last element in the stack and current element have opposite signs, pop the last element\n if len(st) > 0 and check(st[-1], arr[i]):\n st.pop()\n # If the last element in the stack and current element have the same sign or the stack is empty, append the current element to the stack\n else:\n st.append(arr[i])\n\n # Return the updated stack\n return st\n",
"updated_at_timestamp": 1730482207,
"user_code": "#User function Template for python3\n\nfrom typing import List\n\nclass Solution:\n def makeBeautiful(self, arr: List[int]) -> List[int]:\n # code here"
} | eJydVEEOwiAQ9NCHbDgXAwV68CUmYjxoD16whzYxMRofoa/z5ksEWhu0WVLaA2myO7szswv37PnOFv5bv+zP5kKOpm4bsgLCtWHaaENyINW5rvZNddid2qYPa3OzsWsOv5AOhWAYAiq0UUBVai+hDeVQABUo0oUwLAdaAA7FkNJ2FbYniAgYwSrP2DbuDpw2RwqUjrZTDBIUlGgB/o1jVZwE6Q2wmTEmAlAynHkTA0ETpGHzKP3uBGOZojKyTwhERYxN6UIlkj0uzWZco8EOPbIj2Y3A0+Rl/+MxmwbteUhuKw1sNOUmNixES/hixGX5XM9m+1h+AMS0fIw= |
705,122 | Find the Safe Position | There are n people standing in a circle (numbered clockwise 1 to n) waiting to be executed. The counting begins at point 1 in the circle and proceeds around the circle in a fixed direction (clockwise). In each step, a certain number of people are skipped and the next person is executed. The elimination proceeds around the circle (which is becoming smaller and smaller as the executed people are removed), until only the last person remains, who is given freedom.Given the total number of persons n and a number k which indicates that k-1 persons are skipped and k**th person is killed in circle. The task is to choose the place in the initial circle so that you are the last one remaining and so survive.
Examples:
Input:
n =
2,
k =
1
Output:
2
Explanation:
Here, n = 2 and k = 1, then safe position is
2 as the person at 1st position will be killed.
Input:
n =
4,
k =
2
Output:
1
Explanation:
The safe position is 1.
Constraints:
1 <= n,k <= 500 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int safePos(int n, int k)"
],
"initial_code": "import 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().split(\" \");\n \n int n = Integer.parseInt(S[0]);\n int k = Integer.parseInt(S[1]);\n\n Solution ob = new Solution();\n System.out.println(ob.safePos(n,k));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n \n // Function to find the position of the last remaining person in the Josephus problem\n static int josephus(int n, int k) {\n if (n == 1)\n return 1;\n else\n /*\n * The position returned by josephus(n - 1, k) is adjusted because the\n * recursive call josephus(n - 1, k) considers the original position\n * k%n + 1 as position 1\n */\n return (josephus(n - 1, k) + k-1) % n + 1;\n }\n \n // Function to find the safe position in the Josephus problem\n static int safePos(int n, int k) {\n return josephus(n,k);\n }\n}",
"updated_at_timestamp": 1730268730,
"user_code": "class Solution {\n static int safePos(int n, int k) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"safePos(self, n, k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n n, k = map(int, input().split())\n\n ob = Solution()\n print(ob.safePos(n, k))\n print(\"~\")\n",
"solution": "def josephus(n, k):\n if n == 1:\n return 1\n else:\n # The position returned by josephus(n - 1, k) is adjusted because the\n # recursive call josephus(n - 1, k) considers the original position\n # k%n + 1 as position 1\n return (josephus(n - 1, k) + k - 1) % n + 1\n\n\nclass Solution:\n def safePos(self, n, k):\n return josephus(n, k)\n",
"updated_at_timestamp": 1730268730,
"user_code": "#User function Template for python3\n\nclass Solution:\n def safePos(self, n, k):\n # code here "
} | eJytlM1KxDAQxz2IzzHkvEhmmmm33r35AIIVD24PXuoeuiCI4kPo+zr5APcjk3axhXxQMr/85z9Jvi5/7q4uwnd/K5OHd/MybHejuQHD3cBQdQNaoG6owXVDA438tBakmRWY/m3bP4/95ul1N6YoWfUpa076ug2D+VjB3h4eD+j3sH7waFLAGOJlYRjdOsuT3cl6kcSA1gOBOOIrhVtFeXtSW8yhxQNk4MBkLfsY6eocAEOuxcDTLZPZcaIFJ285eZPz+I8xVUA8YOXLJsIIQlfOhxQ9rm1BWiq45xT0EB1UPOtUykqYKiUbl7zRJHnPYL5px1JLh33WaXc4yVPE/1snL3leNKXxanrBs/QiZQ946aFa9qXKpIAp95mWN1y6ooteUjV4KrMzq9Mc1ebx+/oXtirpbw== |
714,128 | Maximum Number of coins | We have been given N balloons, each with a number of coins associated with it. On bursting a balloon i, the number of coins gained is equal to A[i-1]*A[i]*A[i+1].
Also, balloons i-1 and i+1 now become adjacent. Find the maximum possible profit earned after bursting all the balloons. Assume an extra 1 at each boundary.
Examples:
Input:
N=2
a[]={5, 10}
Output:
60
Explanation:
First Burst 5, Coins = 1*5*10
Then burst 10, Coins+= 1*10*1
Total = 60
Input:
N=4
a[] = {3,1,5,8}
Output:
167
Explanation:
nums = [3,1,5,8] --> [3,5,8] --> [3,8] --> [8] --> []
coins = 3*1*5 + 3*5*8 + 1*3*8 + 1*8*1 = 167.
Constraints:
1 <= N <= 400
0 <= a[i] <= 100
| geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1677586318,
"func_sign": [
"int maxCoins(int N, ArrayList<Integer> arr)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\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 N = Integer.parseInt(br.readLine());\n\t\t\tArrayList<Integer> arr = new ArrayList<>(N);\n\t\t\tString [] str = br.readLine().trim().split(\" \");\n\t\t\tfor(int i = 0; i < N; i++) {\n\t\t\t\tarr.add(Integer.parseInt(str[i]));\n\t\t\t}\n\t\t\tSolution obj = new Solution();\n\t\t\tSystem.out.println(obj.maxCoins(N, arr));\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n}",
"script_name": "GFG",
"solution": "class Solution{\n\tint maxCoins(int N, ArrayList<Integer> arr) {\n\t\tarr.add(1);\n arr.add(0, 1);\n N = arr.size();\n int [][] dp = new int[N][N];\n for(int i = 0; i < N; i++) {\n \tArrays.fill(dp[i], 0);\n }\n for(int i = N-3; i > -1; i--)\n for(int j = i+2; j < N; j++)\n for(int k = i+1; k < j; k++)\n dp[i][j] = Math.max(dp[i][j], dp[i][k] + dp[k][j] + arr.get(i) * arr.get(k) * arr.get(j));\n return dp[0][N-1];\n\t}\n}",
"updated_at_timestamp": 1730482296,
"user_code": "//User function Template for Java\n\nclass Solution{\n int maxCoins(int N, ArrayList<Integer> arr) {\n\t\t//Write your code here\n\t}\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1677586318,
"func_sign": [
"maxCoins(self, N, a)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n for _ in range(int(input())):\n n = int(input())\n a = [int(i) for i in input().split()]\n print(Solution().maxCoins(n, a))\n print(\"~\")\n",
"solution": "class Solution():\n def maxCoins(self, N, a):\n a.append(1) # Add 1 to the end of the array\n a.insert(0, 1) # Add 1 to the beginning of the array\n n = len(a) # Get the length of the array\n # Create a 2D array filled with zeros\n dp = [[0 for i in range(n)] for j in range(n)]\n for i in range(n-3, -1, -1): # Iterate backwards from n-3 to 0\n for j in range(i+2, n): # Iterate from i+2 to n\n for k in range(i+1, j): # Iterate from i+1 to j\n # Calculate maximum value and assign it to dp[i][j]\n dp[i][j] = max(dp[i][j], dp[i][k] + dp[k]\n [j] + a[i] * a[k] * a[j])\n\n return dp[0][n - 1] # Return the value at dp[0][n-1]\n",
"updated_at_timestamp": 1730482296,
"user_code": "#User function Template for python3\n\nclass Solution():\n def maxCoins(self, N, a):\n #your code goes here"
} | eJydVEsKwjAUdNGDhKyL5GM2nkQw4kKzcBO7aEEQxUPoWdx5NpM0/tB5mLalFF7nzXszQ07V5VaN0jW7ho/5nm9807V8yri0PjyC14y7XeNWrVsvt12bq8L6o/X8ULMviBQIFCoApgITK+VSiYtRfJhRR0aDSQ0JjLzlW+p+4KEjTwKcJTgAKwqYpYJgKTRkNsme/i40SQ8IBPz/x2rvOchBEq91i6X6p+VDDU/IEZtAPYzAisQalTzSQ0U6OMA5KQ0aVEYdYNwQCnE9j474svZDeKhVbrY4j++JW3C2 |
705,577 | Eulerian Path in an Undirected Graph | Given an adjacency matrix representation of an unweighted undirected graph namedgraph, which has N vertices. You have to find out if there is an eulerian path present in the graphor not.Note: The graph consists of a single component
Examples:
Input:
N = 5
graph = {{0, 1, 0, 0, 1},
{1, 0, 1, 1, 0},
{0, 1, 0, 1, 0},
{0, 1, 1, 0, 0},
{1, 0, 0, 0, 0}}
Output:
1
Explanation:
There is an eulerian path.
The path is 5->1->2->4->3->2.
Input:
N = 5
graph = {{0, 1, 0, 1, 1},
{1, 0, 1, 0, 1},
{0, 1, 0, 1, 1},
{1, 0, 1, 0, 0},
{1, 1, 1, 0, 0}}
Output:
0
Explanation:
There is no eulerian path in
the graph.
Constraints:
1 ≤ N ≤ 50 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int eulerPath(int N, int graph[][])"
],
"initial_code": "//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 \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n static int sum(int[] arr) {\n int answer = 0;\n for (int k : arr) answer += k;\n return answer;\n }\n\n static int eulerPath(int N, int graph[][]) {\n ArrayList<Integer> numofadj = new ArrayList<>();\n int ng[][] = new int[N][N];\n for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) ng[i][j] = graph[i][j];\n // Find out number of edges each vertex has\n for (int i = 0; i < N; i++) numofadj.add(sum(ng[i]));\n // Find out how many vertex has odd number edges\n int startpoint = 0, numofodd = 0;\n for (int i = N - 1; i >= 0; i--) {\n if (numofadj.get(i) % 2 == 1) {\n numofodd++;\n startpoint = i;\n }\n }\n // If number of vertex with odd number of edges\n // is greater than two return \"No Solution\".\n if (numofodd > 2) return 0;\n // If there is a path find the path\n // Initialize empty stack and path\n // take the starting current as discussed\n Stack<Integer> stack = new Stack<>();\n ArrayList<Integer> path = new ArrayList<>();\n int cur = startpoint;\n // Loop will run until there is element in the stack\n // or current edge has some neighbour.\n while (!stack.empty() || sum(ng[cur]) != 0) {\n // If current node has not any neighbour\n // add it to path and pop stack\n // set new current to the popped element\n if (sum(ng[cur]) == 0) {\n path.add(cur);\n cur = stack.peek();\n stack.pop();\n }\n // If the current vertex has at least one\n // neighbour add the current vertex to stack,\n // remove the edge between them and set the\n // current to its neighbour.\n else {\n for (int i = 0; i < N; i++) {\n if (ng[cur][i] == 1) {\n stack.push(cur);\n ng[cur][i] = 0;\n ng[i][cur] = 0;\n cur = i;\n break;\n }\n }\n }\n }\n return 1;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution{\n static int eulerPath(int N, int graph[][]){\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"eulerPath(self, N, graph)"
],
"initial_code": "# Initial Template for Python3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input().strip())\n graph = []\n for i in range(N):\n graph.append(list(map(int, input().strip().split())))\n\n ob = Solution()\n print(ob.eulerPath(N, graph))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python3\n\nclass Solution:\n # Function to find Eulerian Path in a graph.\n def eulerPath(self, N, graph):\n n = N\n numofadj = list()\n # Counting the number of adjacent nodes for each node.\n for i in range(n):\n numofadj.append(sum(graph[i]))\n startpoint = 0\n numofodd = 0\n # Finding the starting point and the number of nodes with odd degree.\n for i in range(n-1, -1, -1):\n if (numofadj[i] % 2 == 1):\n numofodd += 1\n startpoint = i\n # If there are more than 2 nodes with odd degree, there is no Eulerian path.\n if (numofodd > 2):\n return 0\n stack = list()\n path = list()\n cur = startpoint\n # Finding the Eulerian path using a stack to store the visited nodes.\n while(stack != [] or sum(graph[cur]) != 0):\n if (sum(graph[cur]) == 0):\n path.append(cur + 1)\n cur = stack.pop(-1)\n else:\n for i in range(n):\n if graph[cur][i] == 1:\n stack.append(cur)\n graph[cur][i] = 0\n graph[i][cur] = 0\n cur = i\n break\n return 1\n",
"updated_at_timestamp": 1729753320,
"user_code": "# User function Template for Python3\n\nclass Solution:\n def eulerPath(self, N, graph):\n # code here"
} | eJy1VEsOwiAQdWE8B2HdmEGNC09iYo0L7cJN7aImJkbjIfRu7ryKbYGBKZJS1H5SOp/34M3Abfh4jQbNtXxWg9WZ7/PiWPIF4yLNqwd4wnh2KrJtme02h2NpvNc055eE0ZRJlcLqVNY3c9pkqlwG6tMTZKZAMB/x6oFy9cScy0T5KlwJCR6PkB7Qv/oH4tmRkLALmx3pDCFhj1m7AEKvb60p2A4UmkY6JiMbcRGRbIEds210BCfmtjGmAO2WUi2K+DGyIqZwMLGqUfsH16zxft9tf2u3msET70ZCYKgRG9UWciCPtw6xwbcv6hlI6MjSC3NQfl9+X/DHictlR3aXDRHUaT4FA07qwL3X3Wbr+/gNguDYUQ== |
703,573 | Convert String to LowerCase | Given a string s. The task is to convert characters of string to lowercase.
Examples:
Input:
s = "ABCddE
"
Output:
"abcdde
"
Explanation:
A, B, C and E are converted to
a, b, c and e thus all uppercase characters of the string converted to lowercase letter.
Input:
s = "LMNOppQQ
"
Output:
"lmnoppqq
"
Explanation:
L, M, N, O, and Q are converted to l, m, n, o and q thus all uppercase characters of the string converted to lowercase letter.
Constraints:
1 <= |s| <= 10**6
Input only contains lowercase/uppercase English alphabets. | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1618996493,
"func_sign": [
"static String toLower(String s)"
],
"initial_code": "// Initial template for Java\n\nimport java.util.*;\nimport java.io.*;\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 Solution ob = new Solution();\n\n System.out.println(ob.toLower(s));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function for Java\nclass Solution {\n static String toLower(String s) {\n // converting uppercase to lowercase using inbuilt function toLowerCase()\n String Converted_S = s.toLowerCase();\n // returning converted string\n return Converted_S;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function template for Java\n\nclass Solution {\n static String toLower(String s) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1618996493,
"func_sign": [
"toLower(self , s : str) -> str"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n s = input()\n\n ob = Solution()\n print(ob.toLower(s))\n print(\"~\")\n",
"solution": "class Solution:\n def toLower(self, s: str) -> str:\n converted = s.lower()\n return converted\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def toLower (self , s : str)-> str :\n # code here "
} | eJzFVk1zmzAQ7aG3/omMz5nOJGkuvRGs2G4weADnY0rbUWCJlcBChHC+pp3+iPb/dgE74zgWaVJnykkS0tvdt09v9PPtb3j3pv6Ov9Lg811HYF6qzseNzk6Aoxs1ydB1zAMvwD4kSXaUySQK0MmZzUVnc6MD1zmECqJvWalmB/P6lMzCiyLAHwFOqoNXzUGaZjkgF/Ww831zYyHiVoCfykL5zPMFnmnQz2mHgkLRjlUY2wGaWQRHXFJwC0BVMw1USL+u6o2Ek9DeamEV6G6A+2PL8nzDPAiwyw4hoSpkgEMRysxj7qEIgWAM1xexCAVPBrZPf7nZFwgWM1zUFxSXSVIoHl7UkSOYzsFpllb4Bchpg08rXKpZCIGq2cPDCUVJgEvUkPIhwNBJR2MF0jMHzDYZ9dZ1ziRP04Hdo6jcN/YMj3nVUPHZJi1tKY1AFqEADBvCcpnVaPMEKpRTXsySrmaLu5fSI6UNB8esa9KBAD3frXPyoSAZ9DRJpOIaorA+QICFkvPI7droM8tyZlrMT/y+Y1PmPdcYDimmJtSSfht5Lxf8mHFjz4wg7vUH5xfJ0HbyS+n54+nV9ckt1chTaKrtDvb3mctsv6kFndTwzb4mE34aEuTZRBBkShfpUhaqJMib24YFQr2nJBJxDBJQ3a9glnIVTjTMeESAxY4ct0siQ8fvM9ckRWgyKajuBIiUhhOOmZqAvA/1+P4YljUejRrMekaUzg+Y3AOP2YXwB4esulSkhfEoQGZ3s5hkoHR0JEmZ5wthaWEBlhaqQQFYCCWmMLtRpJsyr8eAURZXemkRi5yrZaWxPJRQi37kgoC2dR146H91P1p7sFUDLRhi3RRtF9oM/R/8/O/s/Ek3X4vvusvGux7nfgX7liv8e/eFTqIv8oXG/x/YfR03bBhta1Hr86HtUj7jZaG78Kv9ZaXBvLCRa/GlB7bXbiLPeGztrJuUp9+rc9qeNMLX4fXLr/d/ALM7H3E= |
701,299 | Maximum Occuring Character | Given a stringstr of lowercase alphabets. The task is to find the maximum occurring character in the string str. If more than one character occurs the maximum number of time then print the lexicographically smaller character.
Examples:
Input:
str = testsample
Output:
e
Explanation:
e is the character which
is having the highest frequency.
Input:
str = output
Output:
t
Explanation:
t and u are the characters
with the same frequency, but t is
lexicographically smaller.
Constraints:
1 ≤ |s| ≤ 100 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1619110365,
"func_sign": [
"public static char getMaxOccuringChar(String line)"
],
"initial_code": "import java.lang.*;\nimport java.io.*;\nimport java.util.*;\nclass GFG\n{\n\tpublic static void main (String[] args) throws IOException\n\t{\n\t BufferedReader br=new BufferedReader(new InputStreamReader(System.in));\n\t int tc=Integer.parseInt(br.readLine().trim());\n\t \n\t while(tc-- >0)\n\t {\n\t String line=br.readLine().trim();\n\t \n\t Solution obj = new Solution();\n\t \n\t System.out.println(obj.getMaxOccuringChar(line));\n\t \n\t \nSystem.out.println(\"~\");\n}\n\t }\n}",
"script_name": "GFG",
"solution": "class Solution {\n // Function to find the maximum occurring character in a string.\n public static char getMaxOccuringChar(String line) {\n StringBuffer sb = new StringBuffer();\n char[] s = line.toCharArray();\n int[] arr = new int[26];\n int max = -1;\n char result = '\\u0000';\n\n // using hash table to store count of each character.\n for (int i = 0; i < s.length; i++) {\n char c = s[i];\n if (c != ' ') {\n arr[c - 'a']++;\n }\n }\n\n // iterating over the hash table.\n for (int i = 0; i < arr.length; i++) {\n // we keep storing the maximum value in hash\n // table and its corresponding character.\n if (arr[i] > max) {\n max = arr[i];\n result = (char)(i + 'a');\n }\n }\n // returning the character with maximum occurrences.\n return result;\n }\n}",
"updated_at_timestamp": 1730270817,
"user_code": "\nclass Solution\n{\n //Function to find the maximum occurring character in a string.\n public static char getMaxOccuringChar(String line)\n {\n // Your code here\n }\n \n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619110365,
"func_sign": [
"getMaxOccurringChar(self,s)"
],
"initial_code": "# Initial Template for Python 3\n\nimport atexit\nimport io\nimport sys\n\n_INPUT_LINES = sys.stdin.read().splitlines() # Ignore the first line\ninput = iter(_INPUT_LINES).__next__\n\n_OUTPUT_BUFFER = io.StringIO()\nsys.stdout = _OUTPUT_BUFFER\n\n\n@atexit.register\ndef write():\n sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())\n\n\nif __name__ == '__main__':\n t = int(input())\n for i in range(t):\n s = str(input())\n print(Solution().getMaxOccurringChar(s))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n\n # Function to find the maximum occurring character in a string.\n def getMaxOccurringChar(self, s):\n\n # using hash table to store count of each character.\n occurences = [0 for i in range(256)]\n\n for char in s:\n occurences[ord(char)] += 1\n\n max_occurence = 0\n character = '~'\n\n # iterating over the hash table.\n for i in range(256):\n # we keep storing the maximum value in hash\n # table and its corresponding character.\n if occurences[i] > max_occurence:\n character = chr(i)\n max_occurence = occurences[i]\n\n # returning the character with maximum occurrences.\n return character\n",
"updated_at_timestamp": 1730270817,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to find the maximum occurring character in a string.\n def getMaxOccurringChar(self,s):\n #code here"
} | eJxrYJm6loUBDCKWARnR1UqZeQWlJUpWCkqGMXmJSjoKSqkVBanJJakp8fmlJVCpxJi8upg8pVodBTT1SckpqSTqqYIDHBqrcFqWmAzEKVCaRGsrKqsqK3DoqcBlY2JSUnIyOWGSlp6RmZWdk5uXX1BYVFxSWlYOtJ9Eg5KSSY4OGEgi1arEvETSIx8WqoRsNcSZEjBjley0AQx0eKhDQxx3kKcSNIZUncDIIiZt4w4KcrNDEpn5AeJmfBkYl1sTwVopivmkRHiiw5PwYLpjp+gBAI+Bm90= |
703,420 | Not a subset sum | Given a sorted array arr[] of positive integers, find the smallest positive integer such that it cannot be represented as the sum of elements of any subset of the given array set.
Examples:
Input:
arr[] = [1, 2, 3]
Output:
7
Explanation:
7 is the smallest positive number for which no subset is there with sum 7.
Input:
arr[] = [3, 6, 9, 10, 20, 28]
Output:
1
Explanation:
1 is the smallest positive number for which no subset is there with sum 1.
Constraints
1 <= arr.size()
<= 10**6
1 <= arr[i] <= 10**8
| geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public long findSmallest(int[] arr)"
],
"initial_code": "// Initial Template for Java\nimport java.util.*;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n sc.nextLine(); // Consume the newline character\n while (t-- > 0) {\n String input = sc.nextLine();\n String[] inputArr = input.split(\" \");\n int[] arr = new int[inputArr.length];\n for (int i = 0; i < inputArr.length; i++) {\n arr[i] = Integer.parseInt(inputArr[i]);\n }\n\n Solution ob = new Solution();\n long ans = ob.findSmallest(arr);\n System.out.println(ans);\n System.out.println(\"~\");\n }\n sc.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public long findSmallest(int[] arr) {\n // Your code goes here\n int n = arr.length;\n long s = 0;\n for (int i = 0; i < n; i++) {\n s += arr[i]; // compute sum of all elements\n }\n boolean[] dp = new boolean[(int)s + 1]; // initialize dp array with false values\n dp[0] = true; // a subset with sum 0 can always be formed\n for (int i = 0; i < n; i++) {\n for (int j = (int)s; j >= arr[i]; j--) {\n if (dp[j - arr[i]]) { // if it's possible to form a subset with sum j-arr[i]\n dp[j] = true; // then it's also possible to form a subset with sum j\n }\n }\n }\n for (int i = 1; i <= s; i++) {\n if (!dp[i]) { // find the smallest positive integer that cannot be formed\n return (long)i;\n }\n }\n return s + 1;\n }\n}",
"updated_at_timestamp": 1730470951,
"user_code": "class Solution {\n public long findSmallest(int[] arr) {\n // Your code goes here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"findSmallest(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n\ndef main():\n t = int(input())\n for _ in range(t):\n arr = list(map(int, input().split()))\n ob = Solution()\n ans = ob.findSmallest(arr)\n print(ans)\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def findSmallest(self, arr):\n n = len(arr)\n res = 1\n\n # Traverse the array and increment 'res' if arr[i] is\n # smaller than or equal to 'res'.\n for i in range(n):\n if arr[i] <= res:\n res += arr[i]\n\n return res\n",
"updated_at_timestamp": 1730470951,
"user_code": "#User function Template for python3\n\nclass Solution:\n def findSmallest(self, arr):\n # code here"
} | eJyllE0OgjAQhV1wkJeuiekPIHoSEzEulIUbZAGJidF4CL2gO2/htEIAE2KmQBdNm2/mzcyDe/B8BzP3rF+02VzEsSjrSqwgVFbQEiFEfi7zfZUfdqe6ai51Vtzo8hpiSNC5wjimRjAlHff7suMYG0Yj9gMVDBukVBoGERawRTDp6Ks3QuqFSmgJIxHxMyf9hsd8nuqOkVDVKZb8cbtlQzDtZVq2wbmJrT35ztB+1nDfgoeJtaKO9qukjT32EN9NOXZjNjbwBI9O950TlQ2G6ES1zcqM5P5zkk7X3wZtH/MPcO+FcA== |
710,283 | Geek in a Maze | 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 cellshe 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.
Examples:
Input:
N = 3, M = 3
R = 1, C = 0
U = 1, D = 1
mat = {{'.', '.', '.'},
{'.', '#', '.'},
{'#', '.', '.'}}
Output:
5
Explanation:
Geek can reach
(1, 0), (0, 0), (0, 1), (0, 2), (1, 2)
Input:
N = 3, M = 4
R = 1, C = 0
U = 1, D = 2
mat = {{'.', '.', '.'},
{'.', '#', '.'},
{'.', '.', '.'},
{'#', '.', '.'}}
Output:
10
Explanation:
Geek can reach all the
cells except for the obstacles.
Constraints:
1 ≤ N*M ≤ 10**6
mat[i][j] = '#" or '.'
0 ≤ R ≤ N-1
0 ≤ C ≤ M-1 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1648717203,
"func_sign": [
"public static int numberOfCells(int n, int m, int r, int c, int u, int d, char mat[][])"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n//Position this line where user code will be pasted.\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",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730436740,
"user_code": "//User function Template for Java\n\nclass Solution{\n\n\tpublic static int numberOfCells(int n, int m, int r, int c, int u, int d, char mat[][])\n\t{\n\t\t// code here\n\t\t\n\t\t\n\t}\n\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1648717203,
"func_sign": [
"numberOfCells(self,n, m, r, c, u, d, mat)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n\n for tcs in range(t):\n n, m, r, c, u, d = [int(x) for x in input().split()]\n\n mat = []\n for i in range(n):\n matele = [x for x in input()]\n mat.append(matele)\n\n obj = Solution()\n print(obj.numberOfCells(n, m, r, c, u, d, mat))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nimport heapq as hq\n\n\nclass Solution:\n # Function to check if the given row and column indices are valid.\n def isValid(self, row, col, n, m):\n if 0 <= row < n and 0 <= col < m:\n return True\n\n # Function to count the number of cells that can be visited.\n def numberOfCells(self, n, m, r, c, u, d, mat):\n # If the starting cell is blocked, return 0.\n if mat[r][c] == '#':\n return 0\n pque = []\n vis = [[0 for i in range(m)] for j in range(n)]\n\n # Creating and initializing a priority queue and visited matrix.\n hq.heappush(pque, ((0, 0), (r, c)))\n vis[r][c] = 1\n\n # Performing a BFS to visit all reachable cells.\n while pque:\n up, down = pque[0][0][0], pque[0][0][1]\n x, y = pque[0][1][0], pque[0][1][1]\n hq.heappop(pque)\n\n # Checking and updating the neighboring cells if they can be visited.\n if self.isValid(x - 1, y, n, m):\n if up + 1 <= u and not vis[x - 1][y] and down <= d and mat[x - 1][y] == '.':\n hq.heappush(pque, (((up + 1), down), (x - 1, y)))\n vis[x - 1][y] = 1\n\n if self.isValid(x + 1, y, n, m):\n if down + 1 <= d and not vis[x + 1][y] and up <= u and mat[x + 1][y] == '.':\n hq.heappush(pque, ((up, (down + 1)), (x + 1, y)))\n vis[x + 1][y] = 1\n\n if self.isValid(x, y - 1, n, m):\n if down <= d and not vis[x][y - 1] and up <= u and mat[x][y - 1] == '.':\n hq.heappush(pque, ((up, down), (x, y - 1)))\n vis[x][y - 1] = 1\n\n if self.isValid(x, y + 1, n, m):\n if down <= d and not vis[x][y + 1] and up <= u and mat[x][y + 1] == '.':\n hq.heappush(pque, ((up, down), (x, y + 1)))\n vis[x][y + 1] = 1\n\n # Counting the number of visited cells.\n ans = 0\n for i in range(n):\n for j in range(m):\n if vis[i][j] == 1:\n ans += 1\n\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def numberOfCells(self,n, m, r, c, u, d, mat):\n # code here"
} | eJztVs1OwzAM5sCNl7CS6xSlNFklngSJAgfogUvYoZOQ0KY9BLwvdrKk7SDVvB+GJuyqaZP2s+vms726/GyuLrzcPuDF3bt4cbN5K25AFLWzYOE6aO0UCQ3SDxK1uyMRExDN26x5apvnx9d52+EsaycWExiCT2EKJWoBxRogwAbcOG7Oj1oyGVMGKtBoTkMZIWTtZJA4o9JMBl5n0AsNeFCsyg5/bUMFRJWCdNQFruMW8KhQ0fk+aAp6X9RZP8ENHW5bHRShmDt/8DJ3txFl6NVIG88Nf8oA2REgonbwwvOAgJDXTI9o5xtUDSZliT6zhndMLzfJZdMf+/Ps+k3PKZ8e1dvTf9Dp/7Thl7L/LPv9kR0qe/VT4PV+TUQ+9Wb7CIa1/XoWKioHM7Fzxt66c+papzi3ZUnJVkheqpHZlQMscBLpSD0Xi/sP9QUup74T |
702,930 | Check if actual binary representation of a number is palindrome | Given a non-negative integer N. Check whether the Binary Representation of the number is Palindrome or not.Note: No leading 0’s are being considered.
Examples:
Input:
N = 5
Output:
1
Explanation:
The Binary Representation of
5 is 101 which is a Palindrome.
Input:
N = 10
Output:
0
Explanation:
The Binary Representation of
10 is 1010 which is not a Palindrome.
| geeksforgeeks | Easy | {
"class_name": "Sol",
"created_at_timestamp": 1615292571,
"func_sign": [
"int binaryPalin(long N)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nclass GfG\n{\n public static void main (String[] args)\n {\n \n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n long n = sc.nextLong();\n \t\tSystem.out.println (new Sol().binaryPalin (n));\n \nSystem.out.println(\"~\");\n}\n \n }\n}\n\n// Contributed By: Pranay Bansal\n",
"script_name": "GfG",
"solution": "// Back-end complete function Template for Java\nclass Sol {\n int binaryPalin(long n) {\n if (n == 0) return 1;\n long left = (long) (Math.log(n) / Math.log(2)); // position of leftmost set bit\n long right = 0; // position of the rightmost bit\n\n left = ((long) 1 << left); // generating the number with only leftmost bit set\n right = ((long) 1 << right); // generating the number with only rightmost bit set\n while (left > right) {\n // if both the bits are different, we return 0.\n if ((n & left) == 0 && (n & right) != 0) return 0;\n if ((n & left) != 0 && (n & right) == 0) return 0;\n // moving the left one step back\n left >>= 1;\n // moving the right one step ahead\n right <<= 1;\n }\n return 1;\n }\n}\n// Contributed By: Pranay Bansal\n",
"updated_at_timestamp": 1730469334,
"user_code": "//User function Template for Java\n\nclass Sol\n{\n int binaryPalin (long N)\n {\n // Your Code Here \n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"binaryPalin(self, N)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n for tc in range(t):\n n = int(input())\n ob = Solution()\n print(ob.binaryPalin(n))\n\n # Contributed By: Pranay Bansal\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def binaryPalin(self, n):\n if n == 0:\n return 1\n import math\n left = math.log2(n)\n left = int(left) # position of leftmost set bit\n right = 0 # position of the rightmost bit\n\n left = (1 << left) # generating the number with only leftmost bit set\n # generating the number with only rightmost bit set\n right = (1 << right)\n\n while left > right:\n # if both the bits are different, we return 0.\n if ((n & left) == 0 and (n & right) != 0):\n return 0\n if ((n & left) != 0 and (n & right) == 0):\n return 0\n\n # moving the left one step back\n left >>= 1\n # moving the right one step ahead\n right <<= 1\n return 1\n",
"updated_at_timestamp": 1730469334,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef binaryPalin (self, N):\n\t\t# Your Code Here"
} | eJxrYJnKwsIABhF/mRkYoquVMvMKSkuUrBSUDGPyzJV0FJRSKwpSk0tSU+LzS0sQUkq1Ogqoig1NSVFtTIpiCxyKDbCabEiSO0hzCEl+NDIlUTlJ4W1qSJJHzXEZjiMQwe4hKXAMTfH6Gas9QE/giwSsesAaSPI7zGWGeXiSB1a7jEwp8BiS/0j1I1w7OBrINMSCJK/HTtEDACVHPHc= |
703,562 | Red OR Green | Given a string of length N, made up of only uppercase characters 'R' and 'G', where 'R' stands for Red and 'G' stands for Green.Find out the minimum number of characters you need to change to make the whole string of the same colour.
Examples:
Input:
N=5
S="RGRGR"
Output:
2
Explanation:
We need to change only the 2nd and
4th(1-index based) characters to 'R',
so that the whole string becomes
the same colour.
Input:
N=7
S="GGGGGGR"
Output:
1
Explanation:
We need to change only the last
character to 'G' to make the string
same-coloured.
Constraints:
1<=N<=10**5
S consists only of characters 'R' and 'G'. | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1618600716,
"func_sign": [
"static int RedOrGreen(int N, String S)"
],
"initial_code": "// initial template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n // Position this line where user code will be pasted.\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();\n Solution ob = new Solution();\n System.out.println(ob.RedOrGreen(N, S));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "//User function template for Java\n\nclass Solution {\n static int RedOrGreen(int N, String S) {\n //code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1618600716,
"func_sign": [
"RedOrGreen(self,N,S)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n S = input()\n\n ob = Solution()\n print(ob.RedOrGreen(N, S))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to find the minimum count of 'R' and 'G' characters\n def RedOrGreen(self, N, S):\n Red, Green = 0, 0\n # Traversing through the given string S\n for i in range(N):\n # if the current character is 'R', increment Red count\n if S[i] == 'R':\n Red = Red + 1\n # if the current character is 'G', increment Green count\n else:\n Green = Green + 1\n # returning the minimum count of 'R' and 'G' characters\n return min(Red, Green)\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def RedOrGreen(self,N,S):\n #code here"
} | eJxrYJl6g5UBDCIuAhnR1UqZeQWlJUpWCkqGMXmGBjF5QVDg7h6Tp6SjoJRaUZCaXJKaEp9fWgJVaRSTVweUrNVRQNVuBNTuDgJBqACnQaY4DDIESgS5o0CcZpjjMgNoBE5NBrg14fY2Lk1GoEAjRxeeIMZnF25dhnjswu1CXLqMQf4izzL3mBgsyYmM2IBECCUhjOQQ/I4j35noqZXM5IrwKwGHkpOsQYZTEiZASWgsEExP+F2Bu5AwJNtjsBQSQ2kKIRgQMfjDi6wkDjMIEbBIRgIFgDgmhjgPxk7RAwAyReYA |
701,595 | Reverse a String | You are given a string s. You need to reverse the string.
Examples:
Input:
s = "Geeks"
Output:
"skeeG"
Input:
s = "for"
Output:
"rof"
Constraints:
1 <= |s| <= 10**4 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1617249096,
"func_sign": [
"public static String reverseString(String s)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass Driver {\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 str = read.readLine();\n System.out.println(new Solution().reverseString(str));\n\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "Driver",
"solution": "None",
"updated_at_timestamp": 1730827653,
"user_code": "// User function Template for Java\n\nclass Solution {\n public static String reverseString(String s) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1617249096,
"func_sign": [
"reverseString(self, s: str) -> str"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n s = input()\n ob = Solution()\n print(ob.reverseString(s))\n t -= 1\n print(\"~\")\n",
"solution": "class Solution:\n def reverseString(self, s: str) -> str:\n rev = \"\"\n for i in range(len(s) - 1, -1, -1):\n rev += s[i]\n return rev\n",
"updated_at_timestamp": 1730827653,
"user_code": "#User function Template for python3\n\nclass Solution:\n def reverseString(self, s: str) -> str:\n # code here"
} | eJytVMlOwzAQ5YD4jmnaY4Wa7uVUiUvFuQckipDjOHtsZ18QiI+A/8UJFLWHCa1gDnGkN28845k3b5cfd1cXrd3fqp+HZ83lMku1G9D0HSfaEDRWSkZTZj6JLP2GyI6/7rj2MoRj/5hQRkmMsL5RhNtb9weD/rqHkPcwwiYGNZllO67nByEXMoqTNMuLsqqReHVVFnmWJnEkBQ8D33Md22ImNbDacAL2SGhKWA0QEg4EZNAelHASgFTfEL1CEYgE5U+oYih/2R4hYFXo48l0Nl8sVyMk5Gi1XMxn08lYx7JUZiijykxlSJwGalwa14aCRNs6DKLMpT4YsSg4WKIELwtlAiJnMaQKDkhdgSls5CJbmFDV6qWYk0LMcgGJDDMPSmEBL0RsgE/dLFLwFslhQzgnDhLeacANwsQFwvF6EQqe389cwB8GA36bjKZJBzI8ocV6R1+dzkKdjv3RrIim99gSUR3eu500ocTomFGDnDSlR8LpHBdUNfCP4kZ7+KWm82R14NQmdbYA9SNxPb5ffwIanyO0 |
701,419 | Count ways to N'th Stair | There are n stairs, and a person standing at the bottom wants to reach the top. The person can climb either 1 stair or 2 stairs at a time. Count the number of ways, the person can reach the top (order does not matter).
Examples:
Input:
n = 4
Output:
3
Explanation:
You can reach 4th stair in 3 ways.
3 possible ways are:
1, 1, 1, 1
1, 1, 2
2, 2
Here, note that {1, 1, 2}, {1, 2, 1} and {2, 1, 1} are considered same as their order does not matter.
Input:
n = 5
Output:
3
Explanation:
You may reach the 5th stair in 3 ways.
The 3 possible ways are:
1, 1, 1, 1, 1
1, 1, 1, 2
1, 2, 2
Constraints:
1 <= N <= 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1617868826,
"func_sign": [
"Long countWays(int n)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String[] args) {\n\n // taking input using Scanner class\n Scanner sc = new Scanner(System.in);\n\n // taking total testcases\n int t = sc.nextInt();\n\n while (t-- > 0) {\n\n // taking total number of stairs\n int n = sc.nextInt();\n\n // creating an object of class DynamicProgramming\n Solution obj = new Solution();\n\n // calling method of class countWays()\n // of class DynamicProgramming\n System.out.println(obj.countWays(n));\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730267757,
"user_code": "\nclass Solution {\n // Function to count number of ways to reach the nth stair\n // when order does not matter.\n Long countWays(int n) {\n // your code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1617868826,
"func_sign": [
"countWays(self, n)"
],
"initial_code": "# Initial Template for Python 3\nimport atexit\nimport io\nimport sys\n\n# Contributed by : Nagendra Jha\n\nif __name__ == '__main__':\n test_cases = int(input())\n for cases in range(test_cases):\n n = int(input())\n ob = Solution()\n print(ob.countWays(n))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n\n # Function to count number of ways to reach the nth stair\n # when order does not matter.\n def countWays(self, n):\n\n dp = [0 for i in range(n + 1)]\n\n # base cases\n dp[0] = 1\n dp[1] = 1\n\n # storing number of ways to reach the ith index as\n # number of ways to reach (i-2)th index +1.\n for i in range(2, n + 1):\n dp[i] = dp[i - 2] + 1\n\n # returning the result.\n return dp[n]\n",
"updated_at_timestamp": 1730267757,
"user_code": "#User function Template for python3\nclass Solution:\n\n #Function to count number of ways to reach the nth stair\n #when order does not matter.\n def countWays(self, n):\n\n mod = 1000000007\n # code here\n"
} | eJylU0EKwjAQ9NCHlJyLZFsj1JcIRjxoD15iDy0IUvER+jxvPsQ0TbSVTLS4lxSW2Z3ZmV6i2yOamFre9cfqxPaqrCu2iBlJRVwqlsSsOJbFtip2m0Nd2e5cqrNuNkk8hKQCQigDGIHXpGgPcQwShEEBFIcwLAldAQsCiGw0IjcVkMONWniI8C10ecVxc47WMYT1ZyIoESajOyUpKenLhBDXl/NjSNOAeJ/HRwOTgtn1CftPqp0asAX/E91u0X9GauqFwhExr3Qx06Js/3cDcgsxMW9nedx8BxkSnjnG6+v0CRWvjZo= |
703,054 | Jumping Caterpillars | Given n leaves numbered from 1 to n.A caterpillar at leaf 1. The array contains the jump power of the caterpillar. The caterpillarjumps from leaf to leaf in multiples of arr[j], j is specific to the caterpillar. Whenever a caterpillar reaches a leaf, it eats it a little bit. You have to find out how many leaves are left uneaten after all caterpillars have reached the end. Each caterpillar has its own jump factor denoted by arr[j], and each caterpillar starts at leaf number 1.
Examples:
Input:
n = 10, arr[] = [2, 3, 5]
Output:
2
Explanation:
The leaves eaten by the first caterpillar are (2, 4, 6, 8, 10). The leaves eaten by the second caterpilllar are (3, 6, 9). The leaves eaten by the third caterpilllar are (5, 10). Ultimately, the uneaten leaves are 1, 7 and their number is 2.
Input:
n = 5, arr[] = [2]
Output:
3
Explanation:
The leave eaten are (2,4). The leaves (1,3,5) are uneaten.
Constraints:
1 ≤ arr.size() ≤ 10**3**
1 ≤ arr[i] ≤ 10**4** | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int uneatenLeaves(int[] arr, int n)"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\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());\n while (t-- > 0) {\n String line = br.readLine();\n String[] tokens = line.split(\" \");\n\n // Create an ArrayList to store the integers\n ArrayList<Integer> array = new ArrayList<>();\n\n // Parse the tokens into integers and add to the array\n for (String token : tokens) {\n array.add(Integer.parseInt(token));\n }\n int k = Integer.parseInt(br.readLine());\n\n int[] arr = new int[array.size()];\n int idx = 0;\n for (int i : array) arr[idx++] = i;\n Solution obj = new Solution();\n int res = obj.uneatenLeaves(arr, k);\n\n System.out.println(res);\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "import java.util.*;\n\nclass Solution {\n public int uneatenLeaves(int[] arr, int n) {}\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"uneatenLeaves(self, arr, n)"
],
"initial_code": "# Initial Template for Python 3\n# Position this line where user code will be pasted.\n\nif __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n arr = list(map(int, input().split()))\n k = int(input())\n ob = Solution()\n res = ob.uneatenLeaves(arr, k)\n print(res)\n print(\"~\")\n t -= 1\n",
"solution": "class Solution:\n\n def uneatenLeaves(self, arr, n):\n visited = [False] * (n + 1)\n\n for i in range(len(arr)):\n for j in range(arr[i], n + 1, arr[i]):\n # Traversing the multiples and marking visited.\n visited[j] = True\n\n count = 0\n for i in range(1, n + 1):\n # Counting unvisited leaves\n if not visited[i]:\n count += 1\n\n return count\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def uneatenLeaves(self, arr, n):\n \n"
} | eJzFlL1OAzEMxxkQz2HdXKE4dj7MK7AxIVHEAB1Yjg6thIRAPAS8L3ZzS9U6PXUhkq27xPnJ/9jJ9+Xv3dXFbtzf6sfDx/A6rreb4QYGXI4YdAAWQIFIEGWaGhYwrN7Xq+fN6uXpbbuZdtRIvBy/luPwuYBDEigHAakB25xDyuyBkoEIgQowAhNwaZMOiamWTk4BIqT9xOYojZRjTylBBgGMgAmw9qXm7JBKsvQSJD05xdiPodVYTRdbiMMt0QKOgkUHiBRjapbBlAe0rzitOkyR5MmuJtu4O/3q0Fw0R23Vy1My9QvUjkGB6qI5MsfmUr9MIhW7bNSO1XpzArUMagXU6kns7OpLYyG69U8inVuDZ/UnF+ofak84+1wMVMTTfng1rUztek7L2iBuylyTB/63RsgzDqQGOYb29xwGzo7tPYBnvD1MEnp9st/J4WQrWy9PuMef6z8YMbTR |
707,364 | Split Array Largest Sum | Given an array arr[] of N elements and a number K., split the given array into K subarrays such that the maximum subarray sum achievable out of K subarrays formed is minimum possible. Find that possible subarray sum.
Examples:
Input:
N = 4, K = 3
arr[] = {1, 2, 3, 4}
Output:
4
Explanation:
Optimal Split is {1, 2}, {3}, {4}.
Maximum sum of all subarrays is 4,
which is minimum possible for 3 splits.
Input:
N = 3, K = 2
A[] = {1, 1, 2}
Output:
2
Explanation:
Splitting the array as {1,1} and {2} is optimal.
This results in a maximum sum subarray of 2.
Constraints:
1 ≤ N ≤ 10**5
1 ≤ K ≤ N
1 ≤ arr[i] ≤ 10**4 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1620401189,
"func_sign": [
"static int splitArray(int[] arr , int N, int K)"
],
"initial_code": "import 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 \n String St[] = read.readLine().split(\" \");\n \n int N = Integer.parseInt(St[0]);\n int K = Integer.parseInt(St[1]);\n \n String S[] = read.readLine().split(\" \");\n \n int[] arr = new int[N];\n \n for(int i=0 ; i<N ; i++)\n arr[i] = Integer.parseInt(S[i]);\n\n Solution ob = new Solution();\n System.out.println(ob.splitArray(arr,N,K));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution {\n // Function to check if mid can\n // be maximum sub - arrays sum\n static boolean check(int mid, int array[], int n, int K)\n {\n \n int count = 0;\n int sum = 0;\n for (int i = 0; i < n; i++) {\n \n // If individual element is greater\n // maximum possible sum\n if (array[i] > mid)\n return false;\n \n // Increase sum of current sub - array\n sum += array[i];\n \n // If the sum is greater than\n // mid increase count\n if (sum > mid) {\n count++;\n sum = array[i];\n }\n }\n count++;\n \n // Check condition\n if (count <= K)\n return true;\n return false;\n }\n \n static int splitArray(int[] arr , int N, int K) {\n \n int start = 1;\n for (int i = 0; i < N; ++i) {\n if (arr[i] > start)\n start = arr[i];\n }\n int end = 0;\n \n for (int i = 0; i < N; i++) {\n end += arr[i];\n }\n \n // Answer stores possible\n // maximum sub array sum\n int answer = 0;\n while (start <= end) {\n int mid = (start + end) / 2;\n \n // If mid is possible solution\n // Put answer = mid;\n if (check(mid, arr, N, K)) {\n answer = mid;\n end = mid - 1;\n }\n else {\n start = mid + 1;\n }\n }\n \n return answer;\n }\n};",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n static int splitArray(int[] arr , int N, int K) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1620401189,
"func_sign": [
"splitArray(self, arr, N, K)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N, K = map(int, input().split())\n arr = list(map(int, input().split()))\n\n ob = Solution()\n print(ob.splitArray(arr, N, K))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to check if mid can\n # be maximum sub - arrays sum\n def check(self, mid, array, n, K):\n count = 0\n sum_val = 0\n for i in range(n):\n # If individual element is greater\n # maximum possible sum\n if array[i] > mid:\n return False\n # Increase sum of current sub - array\n sum_val += array[i]\n # If the sum is greater than\n # mid increase count\n if sum_val > mid:\n count += 1\n sum_val = array[i]\n # Check condition\n return count <= K\n\n def splitArray(self, arr, N, K):\n start = max(arr)\n end = sum(arr)\n # Answer stores possible\n # maximum sub array sum\n answer = 0\n while start <= end:\n mid = (start + end) // 2\n # If mid is possible solution\n # Put answer = mid;\n if self.check(mid, arr, N, K):\n answer = mid\n end = mid - 1\n else:\n start = mid + 1\n return answer\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def splitArray(self, arr, N, K):\n # code here "
} | eJy1lM9KxDAQxj0IvsZHzoskk07a9UkEVzxoD17qHrogiOJD6Ct48x3NJFRxdfpnoy18Xdjky8xvZvJ8/Pp+cpSe87f44+LB3HbbXW/OYNymcxCx8dl0ZgXT3m/b6769ubrb9cOq/O9TXPC4wt52C04m+6/qRrqTszkUkIgXqURYJIjUIo3IWqQgboaXuAkeFRgBNRqsIVHE6AnOw1VwrLr7oFjTkEi0a6JtiPZVPIYSmJ8H6vF75QQGJVDCSTAJJYGkOgWVQ40qlS/R/P4Z4+r03Fnim/XqLaJF20jRONU9libnT5wZeE4cVFNmtRcI4ZDGi52SlEabkA8YnrJx0GPRyvYL1/lgaTTBIYmFWfB4Ip9LSq4SpNrMv07+vJL/UcrpCSwYQWuV5VMtJewWTWveMkFbx+3sAuJ50xf2fLkWz5EtGKTLl9MP6LH6jw== |
702,802 | Ishaan's Internship | Ishaan wants to intern at GeeksForGeeks but for that he has to go through a test. There are n candidates applying for the internship including Ishaan and only one is to be selected.
Since he wants to qualify he asks you to help him. The test is as follows.
The candidates are asked to stand in a line at positions 1 to n and given a number k. Now, every kth candidate remains and the rest are eliminated. This is repeated until the number of candidates are less than k.
Out of the remaining candidates, the one standing at smallest position is selected. You need to tell Ishaan at position he must stand to get selected.
Examples:
Input:
n = 30
k = 3
Output:
27
Explanation
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
3 6 9 12 15 18 21 24 27 30
9 18 27
27
Input:
n = 18
k = 3
Output:
9
Explanation
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
3 6 9 12 15 18
9 18 (less than k)
9
Constraints
1 <= n <= 10**5
2 <= k <= 10 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int getCandidate(int n, int k)"
],
"initial_code": "//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\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 while (t-- > 0)\n {\n int n = sc.nextInt();\n int k = sc.nextInt();\n \n Solution sol = new Solution();\n System.out.println(sol.getCandidate(n, k));\n \nSystem.out.println(\"~\");\n}\n }\n}\n\n",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n // This method calculates the highest power of k that divides n\n int getCandidate(int n, int k) {\n int i = 0;\n while (n >= k) {\n // Divide n by k until it is no longer divisible\n n = n / k;\n i++;\n }\n // Calculate the highest power of k using exponential function\n int ans = (int) Math.pow(k, i);\n return ans;\n }\n}\n",
"updated_at_timestamp": 1730468663,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n int getCandidate(int n, int k){\n //complete the function here\n }\n}\n"
} | {
"class_name": null,
"created_at_timestamp": 1615292571,
"func_sign": [
"getCandidate(n, k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n\n for _ in range(t):\n n, k = map(int, input().split())\n\n print(getCandidate(n, k))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\n# Function to calculate the candidate number\ndef getCandidate(n, k):\n i = 0\n # Loop to calculate the power of k in n\n while (n >= k):\n n = n // k\n i = i + 1\n # Calculating the candidate number using k raised to the power i\n ans = int(pow(k, i))\n return ans\n",
"updated_at_timestamp": 1730468663,
"user_code": "#User function Template for python3\n\ndef getCandidate(n, k):\n #complete the function here"
} | eJylkz1uwzAMhTvkIITmoKB+SEk5SYCo6NB66OJmcIAAQYscIr1et9yjtusGNtDnwXmTB33kI/l8Xn1dVw+9tt/tx+5k3ur9oTEbMrbUljuRK7VZk6mO++qlqV6f3w/N8EZFvJb6s33wsaYpnDuRZQj31QEsfWPBrKgTwA6uPYQlc8gIdj4IRci6wBYNnKLKwmVJ8M5SwPOqTwGwsRMpZIOqoL5Jg2NKkPUuakKeO1GemVfRqm5tMQ078z22R/AkKaXMmkGjjMrh20WG67/F3JayIOkDjn8Tz5D9tU0Lb/9H8z03mN2aZBf538hPb9inH5cZXe7p8vgDVbJ56A== |
703,713 | Extract the Number from the String | Given a sentence containing several words and numbers. Find the largest number among them which does not contain 9.If no such number exists, return -1.
Examples:
Input:
sentence="This is alpha 5057 and 97"
Output:
5057
Explanation:
5057 is the only number that does not have a 9.
Input:
sentence="Another input 9007"
Output:
-1
Explanation:
Since there is no number that does not contain a 9,output is -1.
**n is the length of a given sentence. | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"long ExtractNumber(String sentence)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nimport java.util.regex.*;\n\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 String S = read.readLine();\n Solution ob = new Solution();\n System.out.println(ob.ExtractNumber(S));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n long ExtractNumber(String sentence) {\n // Define regex to find numbers\n Pattern pattern = Pattern.compile(\"\\\\d+\");\n Matcher matcher = pattern.matcher(sentence);\n\n List<String> numbers = new ArrayList<>();\n\n // Extract all numbers from the string\n while (matcher.find()) {\n numbers.add(matcher.group());\n }\n\n long ans = -1;\n long maxVal = Long.MIN_VALUE;\n\n // Find the largest number that does not contain '9'\n for (String num : numbers) {\n if (!num.contains(\"9\")) {\n long numValue = Long.parseLong(num);\n if (maxVal < numValue) {\n ans = numValue;\n maxVal = numValue;\n }\n }\n }\n\n return ans;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n long ExtractNumber(String sentence) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"ExtractNumber(self,sentence)"
],
"initial_code": "t = int(input())\n\nfor _ in range(t):\n S = input()\n ob = Solution()\n ans = ob.ExtractNumber(S)\n print(ans)\n print(\"~\")\n",
"solution": "import re\n\n\nclass Solution:\n # Function to extract the maximum number from a string\n def ExtractNumber(self, sentence):\n # Compiling the regular expression pattern to find numbers\n r = re.compile('\\d+')\n\n # Finding all the numbers in the given string\n m = r.findall(sentence)\n\n ans = -1\n lens = -1\n\n # Checking if there is at least one number found\n if len(m) > 0:\n # Iterating through all the numbers\n for j in range(len(m)):\n # Checking if the number does not contain '9' and is greater than current maximum\n if '9' not in m[j] and lens < int(m[j]):\n # Updating the maximum number and its length\n ans = m[j]\n lens = int(ans)\n\n # Returning the maximum number found\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def ExtractNumber(self,sentence):\n #code here"
} | eJy1VcFunDAQ7aFSf2PEmUSGZRecD6iUHNJLpVZqqoqF2cXqYq9sIxpVrfoR7Y/11r/p2LBRosRkiRJOyIPfe37zxvx6/effm1f++fiXXj59j4TcdzY6gyi5ku8bhL0WFUJfGihynsO6syBVD8KCoCXGrmQUQ4Tf9lhZrL+ozo77fe0nlX/EcBf2A8JGdbIGDhJ7MLRVoAEhIWVpMlJIHBcWQYah+CCFU94LKYXcguzaNWoDPWp0gDFkLIuhJAErtgqi+9qD4DxjS3d6qSxYIqpUjV51smS0HkSkcgDxrdKERJBulxYtShtDyknqgi8GqRnPoKQDGLGVYiOqUtog0UkS4Dlvy60gZ53qwRZI0kW2XOUFP5yoIZvmI1+OJu/EV6RYFMyLzlnOvOrOYO36uVfahg1y+wL4F6qRYCqlCSfhzGM110ZUxhMlhV+qGmyFsfo63IMgw7kk4IKC8U73uNtBr5VFKNfKNZalAw0vwsgsnQijRtJeg8WWGlzaTuMYyJOEsRiWbOhyyqHGrUacSFFwrgaPZrX5jpfOQJrt0UMXvwkfH5vtG8KXHfLjjX2ap0ErjxqX4dPpSL9opm+pP/4wVJp1KYSyQP2Ze43cj4+fTJehJ+bncapwQDcHholwhuBvXekz/0fP8Qc4qPr8+/Q/AyGGXQ== |
707,054 | IPL 2021 - Match Day 6 - Semi Final | IPL 2021 knockouts are over, teams MI, CSK, DC, and RCB are qualified for the semis.
Examples:
Input:
s = "ababcababcd"
Output:
ab*c*d
Explanation:
We can encrypt the string
in following way : "ababcababcd"->
"ababc*d" -> "ab*c*d"
Input:
s = "zzzzzzz"
Output:
z*z*z
Explanation:
The string can be encrypted
in 2 ways: "z*z*z" and "z**zzz". Out of
the two "z*z*z" is smaller in length.
Constraints:
1 ≤ |s| ≤ 10**5 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1618213837,
"func_sign": [
"public String compress(String s)"
],
"initial_code": "//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\npublic class Main {\n\tpublic static void main(String[] args) throws IOException {\n\t\tBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\n\t\tint tc = Integer.parseInt(br.readLine());\n\t\twhile (tc--> 0) {\n\t\t\tString s = br.readLine().trim();\n\t\t\tSolution sln = new Solution();\n\t\t\tString ans = sln.compress(s);\n\t\t\tSystem.out.println(ans);\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution {\n\tpublic String compress(String s) {\n\t\t// Your code goes here\n\t}\n}\n\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1618213837,
"func_sign": [
"compress(self, s)"
],
"initial_code": "# Initial Template for Python 3\nt = int(input())\nfor _ in range(0, t):\n s = input()\n obj = Solution()\n ans = obj.compress(s)\n print(ans)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def fillarray(self, s, a):\n a[0] = 0\n for i in range(1, len(s)):\n series = a[i-1]\n while(series):\n if(s[series] == s[i]):\n a[i] = series + 1\n break\n series = a[series-1]\n if(series == 0):\n a[i] = (int(s[i] == s[0]))\n return a\n\n def compress(self, s):\n a = [0]*len(s)\n\n # ith element of array a stores the length of longest\n # proper suffix which is also a proper prefix\n # for substr s[0] to s[i]\n a = self.fillarray(s, a)\n # print(a)\n shortened = []\n n = len(s)\n i = n - 1\n\n # for even index, string length is odd\n # hence it cannot be divided into two\n # so we simply push ith character in stack\n while(i > 0):\n if(i % 2 == 0):\n shortened.append(s[i])\n i = i - 1\n continue\n\n # star_here will be made TRUE if substring s[0] to s[i]\n # can be divided into identical halves\n star_here = False\n\n # suffix and substring length are also meant for\n # substring s[0] to s[i]\n suffix = a[i]\n substrlen = i + 1\n\n # these conditions, if true, imply that, substring\n # can be divided into 2 identical halves\n if(suffix * 2 >= substrlen):\n if(substrlen % (substrlen - suffix) == 0):\n if((substrlen / (substrlen - suffix)) % 2 == 0):\n star_here = True\n\n # adding * to stack and moving index as required\n if(star_here == True):\n shortened.append('*')\n i = (i // 2) + 1\n\n # else, simply adding character to stack\n else:\n shortened.append(s[i])\n i = i - 1\n\n ret = \"\"\n ret = ret + s[0]\n n = len(shortened)\n\n # since we analysed input string from end to start\n # removing elements from stack and pushing back to\n # output string will reverse them back to required order\n while(n):\n ret = ret + shortened[n-1]\n shortened.pop()\n n = n - 1\n return ret\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def compress(self, s):\n # Your code goes here"
} | eJzdVtsOgjAM9cF3fwH3ZBpj4qtfYiLGyMQrDlRQwGj8CP1fAY23UAYDnbp2hKTbeklP20P5VKuUotWuBj+dLZkwy7FJSyFNlfVJXSG6a+nU1gc907Gvor7K9ioju7rycl4TJ0yVBjdGtVJhRrVSgOjzBk/FI8ENhevJI8Rs14NHRgz3pS7EdB/uhNhtmGwkayNWhyKI+eDoGejD0XgynRlzZlqL5cp21hvX8z8lwTGIXIigicgk4DUVJYA6XGhFzbEwlXAhGaVNOEg3DnZh3SdD76Aa5b1WrLeBo80/8DNne84TphQlNCfApFR2gIvhqVIjbcIBPJ/kPS+582X17hegVGjuZ/aLZ10cYYLEVheaLvqwyASzyD6ofHuif2LEEo6ctJEiWcwDkgbJ96+OdY+NM8f1wOM= |
713,968 | Shortest Path Using Atmost One Curved Edge | Given an undirected connected graph of n vertices and list of m edges in a graph and for each pair of vertices that are connected by an edge.
Examples:
Input:
n = 4, m = 4
a = 2, b = 4
edges = {{1, 2, 1, 4}, {1, 3, 2, 4},
{1, 4, 3, 1}, {2, 4, 6, 5}}
Output:
2
Explanation:
We can follow the path 2 -> 1 -> 4.
This gives a distance of 1+3 = 4 if we follow
all straight paths. But we can take the curved
path from 1 -> 4, which costs 1. This
will result in a cost of 1+1 = 2
Input:
n = 2, m = 1
a = 1, b = 2
edges = {{1, 2, 4, 1}}
Output:
1
Explanation:
Take the curved path from 1 to 2 which costs 1.
Constraints:
1 ≤ n,m ≤ 10**5
1 ≤ a,b ≤ n
weight of edges ≤ 10**4 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1675767177,
"func_sign": [
"static int shortestPath(int n, int m, int a, int b, ArrayList<ArrayList<Integer>> edges)"
],
"initial_code": "import 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().split(\" \");\n int n = Integer.parseInt(S[0]);\n int m = Integer.parseInt(S[1]);\n \n String S1[] = read.readLine().split(\" \");\n int a = Integer.parseInt(S1[0]);\n int b = Integer.parseInt(S1[1]);\n \n ArrayList<ArrayList<Integer>> edges = new ArrayList<ArrayList<Integer>>();\n \n for(int i=0; i<m; i++)\n {\n String S2[] = read.readLine().split(\" \");\n int u = Integer.parseInt(S2[0]);\n int v = Integer.parseInt(S2[1]);\n int x = Integer.parseInt(S2[2]);\n int y = Integer.parseInt(S2[3]);\n \n ArrayList<Integer> edge = new ArrayList<>();\n edge.add(u);\n edge.add(v);\n edge.add(x);\n edge.add(y);\n \n edges.add(edge);\n }\n\n Solution ob = new Solution();\n System.out.println(ob.shortestPath(n,m,a,b,edges));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "//Back-end function Template for Java\n\nclass Solution {\n static class pair implements Comparable<pair> {\n\t\tint to;\n\t\tint number;\n \n\t\tpair(int t, int n) {\n\t\t\tnumber = n;\n\t\t\tto = t;\n\t\t}\n \n\t\t@Override\n\t\tpublic int compareTo(pair o) {\n\t\t\treturn Integer.compare(number, o.number);\n\t\t}\n \n\t}\n\t\n\tstatic int[] dijkstra(int u, int b, int n, ArrayList<pair>[] adj) {\n\t int[] dis = new int[n+1];\n\t for(int i=0; i<=n; i++)\n\t dis[i] = 1000000001;\n\t \n\t PriorityQueue<pair> pq = new PriorityQueue<>();\n\t dis[u] = 0;\n\t pq.add(new pair(u, 0));\n\t \n\t while (!pq.isEmpty())\n\t\t{\n\t\t\tpair cur = pq.poll();\n\t\t\tint v = cur.to;\n\t\t\tfor (pair vs : adj[v])\n\t\t\t{\n\t\t\t int y = vs.to;\n\t\t\t int w = vs.number;\n\t\t\t\tif (dis[y] > dis[v] + w)\n\t\t\t\t{\n\t\t\t\t\tdis[y] = w + dis[v];\n\t\t\t\t\tpq.add(new pair(y,dis[y]));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\treturn dis;\n\t}\n\t\n static int shortestPath(int n, int m, int a, int b, ArrayList<ArrayList<Integer>> edges) {\n ArrayList<pair>[] adj = new ArrayList[n+1];\n ArrayList<ArrayList<Integer>> curved = new ArrayList<>();\n \n for(int i=0; i<=n; i++)\n\t\t\tadj[i] = new ArrayList<>();\n\t\t\t\n\t\tfor(int i=0; i<m; i++)\n\t\t{\n\t\t int u = edges.get(i).get(0);\n\t\t int v = edges.get(i).get(1);\n\t\t int w = edges.get(i).get(2);\n\t\t int cw = edges.get(i).get(3);\n\t\t adj[u].add(new pair(v, w));\n\t\t\tadj[v].add(new pair(u, w));\n\t\t\t\n\t\t\t// curved edge weight\n ArrayList<Integer> temp = new ArrayList<>();\n temp.add(u);\n temp.add(v);\n temp.add(cw);\n curved.add(temp);\n\t\t}\n\t\t\n\t\tint[] da = dijkstra(a, b, n, adj);\n int[] db = dijkstra(b, a, n, adj);\n \n int ans = da[b];\n \n // ans = min distance from a -> b with at max one curved edge \n // current ans without curved edge from a -> b = da[b]\n \n for(int i=0; i<m; i++)\n {\n int u = curved.get(i).get(0);\n int v = curved.get(i).get(1);\n int cw = curved.get(i).get(2);\n \n ans = Math.min(ans, da[u] + cw + db[v]);\n ans = Math.min(ans, da[v] + cw + db[u]);\n }\n \n if(ans>=1000000001) return -1;\n return ans;\n }\n};",
"updated_at_timestamp": 1730482016,
"user_code": "//User function Template for Java\n\nclass Solution {\n static int shortestPath(int n, int m, int a, int b, ArrayList<ArrayList<Integer>> edges) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1675767177,
"func_sign": [
"shortestPath(self, n, m, a, b, edges)"
],
"initial_code": "# Initial Template for Python 3\n\nfrom heapq import *\nimport sys\nsys.setrecursionlimit(10**6)\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n n, m = map(int, input().split())\n a, b = map(int, input().split())\n edges = []\n for i in range(m):\n edge = list(map(int, input().split()))\n edges.append(edge)\n\n ob = Solution()\n print(ob.shortestPath(n, m, a, b, edges))\n print(\"~\")\n",
"solution": "# Back-end function Template for python3\n\nclass Solution:\n def dijkstra(self, u, b, n, adj):\n unused = []\n dis = [float('inf')] * (n + 1)\n\n dis[u] = 0\n unused.append((0, u))\n heapify(unused)\n\n while unused:\n x, v = heappop(unused)\n\n if x > dis[v]:\n continue\n\n for edge in adj[v]:\n u = edge[0]\n w = edge[1]\n\n if dis[v] + w < dis[u]:\n dis[u] = dis[v] + w\n heappush(unused, (dis[u], u))\n\n return dis\n\n def shortestPath(self, n, m, a, b, edges):\n adj = [[] for i in range(n + 1)]\n curved = []\n\n for i in range(m):\n u = edges[i][0]\n v = edges[i][1]\n w = edges[i][2]\n cw = edges[i][3]\n\n adj[u].append((v, w))\n adj[v].append((u, w))\n\n # curved edge weight\n curved.append([u, v, cw])\n\n da = self.dijkstra(a, b, n, adj)\n db = self.dijkstra(b, a, n, adj)\n\n ans = da[b]\n\n # ans = min distance from a -> b with at max one curved edge\n # current ans without curved edge from a -> b = da[b]\n\n for i in range(m):\n u = curved[i][0]\n v = curved[i][1]\n cw = curved[i][2]\n\n ans = min(ans, da[u] + cw + db[v])\n ans = min(ans, da[v] + cw + db[u])\n\n if ans >= 1000000001:\n return -1\n return ans\n",
"updated_at_timestamp": 1730482016,
"user_code": "#User function Template for python3\n\nclass Solution:\n def shortestPath(self, n, m, a, b, edges):\n # code here "
} | eJzFlk1u20AMhbvooscgtDYKk/Mn5yQBOkUXjRfdKFnYQIAgQQ6RHC27HKZ8pKZuAE8jB20jA9aMhhx+fKTGvv/4+Pzpg13nTzr4cjP8mK72u+GMBq4Tr4mlToFGHZNQIl7XSShQpIDnUR/mOkVdCaQOiTKNpC6Zin7UpmBOsU4jbXRRbTa6iY4FWyY4wk3nWBM4YWlY0bC9vtp+320vvl3udzOTctzp4u2KXoImKnBOjinYE5RC4pSMJ9HCIS1LQGATPVzQBQPoxA2duIU2cM4eNx/iRo9rmyNuaeokLOWWJqtNdK/k7sFs+iTcIRmtNNwqFaAFbvkgwYwirniGCI4SYYxCpVaV4kwopmVSvHQ9ptSB0lIzghaH4qaP0Xn3RIeycgDKbABlIgAqtO6Z6ws6cbq5C4tn2aGLHThWoIRYLI4Xm2ZWUOCl1jal4eWmmTQ80xV4I4zn5k7+7rAT6p2liTvrLkZt+COqgzgbt+nkId1EyCrfr8+64yj+MkirzuldFyw9/xKkzq6gj/jX6MRtIxRi/8K2eh12nifW023Cv09OCQblOvZHLJdb/8/mf1P3Hzm56J2OriNtuEi+PytU69ID4j24+M1g2oO1Lu9ZtV3esv/w58z+OPz108WGr+z69eHzTzJOWXo= |
702,664 | Adding One | Given a non-negative integer(without leading zeroes) represented as an array arr. Your task is to add 1 to the number (increment the number by 1). The digits are stored such that the most significant digit is at the starting index of the array.
Examples:
Input:
arr[] = [5, 6, 7, 8]
Output:
[5, 6, 7, 9]
Explanation:
5678 + 1 = 5679
Input:
arr[] = [9, 9, 9]
Output:
[1, 0, 0, 0]
Explanation:
999 + 1 = 1000
Constraints:
1 ≤ arr.size() ≤ 10**6
0 ≤ arr[i] ≤ 9
There are no leading zeros in the input number. | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"Vector<Integer> addOne(int[] arr)"
],
"initial_code": "import java.util.*;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n int t = Integer.parseInt(scanner.nextLine());\n\n while (t-- > 0) {\n String line = scanner.nextLine();\n String[] elements = line.split(\" \");\n int[] arr = new int[elements.length]; // Changed to int[]\n\n for (int i = 0; i < elements.length; i++) {\n arr[i] = Integer.parseInt(elements[i]);\n }\n\n Solution ob = new Solution();\n Vector<Integer> result = ob.addOne(arr);\n\n // Print the result vector\n for (int num : result) {\n System.out.print(num + \" \");\n }\n System.out.println();\n }\n scanner.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n // Function for adding one to the number represented by the array\n Vector<Integer> addOne(int[] arr) {\n int n = arr.length; // Get the size of the array\n int carry = 1; // Initialize carry to 1\n // Iterate backwards through the array\n for (int i = n - 1; i >= 0; i--) {\n carry += arr[i]; // Add the current element of the array to carry\n arr[i] = carry % 10; // Store the remainder in the array element\n carry = carry / 10; // Update carry by dividing it by 10\n }\n Vector<Integer> ans = new Vector<>(); // Create a vector to store the result\n if (carry > 0) {\n ans.add(carry); // If carry is still greater than 0, add it to the vector\n }\n for (int i = 0; i < n; i++) {\n ans.add(arr[i]); // Add each element of the array to the vector\n }\n return ans; // Return the result vector\n }\n}\n",
"updated_at_timestamp": 1727947200,
"user_code": "// User function Template for Java\n\nclass Solution {\n // Function for adding one to the number represented by the array\n Vector<Integer> addOne(int[] arr) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"addOne(self, arr)"
],
"initial_code": "# Initial Template for Python 3\ndef main():\n T = int(input())\n\n while T > 0:\n # Convert input to list of integers\n a = list(map(int, input().strip().split()))\n print(\" \".join(map(str, Solution().addOne(a))))\n T -= 1\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "# Function for adding one to a number\nclass Solution:\n # Function to add one to a number represented as an array\n def addOne(self, arr):\n n = len(arr)\n carry = 1\n\n # Traverse the array from right to left\n for i in range(n - 1, -1, -1):\n # Add carry to the current digit and update carry\n arr[i] += carry\n carry = arr[i] // 10\n arr[i] = arr[i] % 10\n\n ans = []\n\n # If carry is 1 after the loop, append it to the answer array\n if carry == 1:\n ans.append(carry)\n\n # Append the modified digits from the array to the answer array\n ans.extend(arr)\n\n # Return the answer array\n return ans\n",
"updated_at_timestamp": 1727947200,
"user_code": "#User function Template for python3\n\n# function for adding one to number \nclass Solution:\n # Function to add one to a number represented as an array\n def addOne(self, arr):\n # code here"
} | eJzdVsEKwjAM9eDdXwg9i7ha5+qXCCoedAcv08MEQQQ/Qv/Qmz9hNvQw17hYzRT3KOtG0/S9pE0PzdOl1cif0Rk7451aJutNqoaggkliIYIBhNAHAz3QEEAXmP9UG1S8XcfzNF7MVpv0Nqn/jLgctW9DcYHZUFEQNKT9OslaEMaXyCLcsdUYeoMpEGIqRLhA1OWT/0i6kn4tRVZc4zrwvQyqAcSmlD8OiaOvnGp8xzxrgjFLLJIxx1q7HEfAAuGYZ23dUrNASs2Bk7H3vmEP/KX69kSewod+UWhd6Pdkj1/jZcbeVpzICsfUeFkR+f1uWf3jGu+h8i/t5ienbB2XO2zGryRYnKKcrZS274TZM8oS+J+bW1Vpub+qC7bOm6aL80PK1ZLWvpe8zCanMT12ruyGGmU= |
702,781 | Count Occurences of Anagrams | Given a word patand a text txt. Return the count of the occurrences of anagrams of the word in the text.
Examples:
Input:
txt = forxxorfxdofr
pat = for
Output:
3
Explanation:
for, orf
and
ofr
appears
in the
txt,
hence answer is 3.
Input:
txt = aabaabaa
pat = aaba
Output:
4
Explanation:
aaba
is present 4 times
in
txt
.
| geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1619175296,
"func_sign": [
"int search(String pat, String txt)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n // Driver code\n public static void main(String[] args) throws Exception {\n BufferedReader br =\n new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine().trim());\n while (t-- > 0) {\n String txt = br.readLine().trim();\n String pat = br.readLine().trim();\n\n int ans = new Solution().search(pat, txt);\n\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\n\nclass Solution {\n final int MAX = 256;\n\n // This function returns true if contents\n // of arr1[] and arr2[] are same, otherwise\n // false.\n boolean compare(char arr1[], char arr2[]) {\n for (int i = 0; i < MAX; i++)\n if (arr1[i] != arr2[i]) return false;\n return true;\n }\n\n // This function search for all permutations\n // of pat[] in txt[]\n int search(String pat, String txt) {\n int M = pat.length();\n int N = txt.length();\n\n // countP[]: Store count of all\n // characters of pattern\n // countTW[]: Store count of current\n // window of text\n char[] countP = new char[MAX];\n char[] countTW = new char[MAX];\n for (int i = 0; i < M; i++) {\n (countP[pat.charAt(i)])++;\n (countTW[txt.charAt(i)])++;\n }\n int ans = 0;\n // Traverse through remaining characters\n // of pattern\n for (int i = M; i < N; i++) {\n // Compare counts of current window\n // of text with counts of pattern[]\n if (compare(countP, countTW)) ans++;\n\n // Add current character to current\n // window\n (countTW[txt.charAt(i)])++;\n\n // Remove the first character of previous\n // window\n countTW[txt.charAt(i - M)]--;\n }\n\n // Check for the last window in text\n if (compare(countP, countTW)) ans++;\n return ans;\n }\n}",
"updated_at_timestamp": 1730267670,
"user_code": "// User function Template for Java\n\nclass Solution {\n\n int search(String pat, String txt) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619175296,
"func_sign": [
"search(self,pat, txt)"
],
"initial_code": "# Initial Template for Python 3\n# Driver code\nif __name__ == \"__main__\":\n tc = int(input())\n while tc > 0:\n txt = input().strip()\n pat = input().strip()\n ob = Solution()\n ans = ob.search(pat, txt)\n print(ans)\n tc = tc - 1\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n # This function returns true\n # if contents of arr1[] and arr2[]\n # are same, otherwise false.\n def compare(self, arr1, arr2):\n MAX = 256\n for i in range(MAX):\n if arr1[i] != arr2[i]:\n return False\n return True\n\n # This function search for all\n # permutations of pat[] in txt[]\n def search(self, pat, txt):\n MAX = 256\n M = len(pat)\n N = len(txt)\n\n # countP[]: Store count of\n # all characters of pattern\n # countTW[]: Store count of\n # current window of text\n countP = [0] * MAX\n countTW = [0] * MAX\n\n for i in range(M):\n countP[ord(pat[i])] += 1\n countTW[ord(txt[i])] += 1\n\n ans = 0\n # Traverse through remaining\n # characters of pattern\n for i in range(M, N):\n # Compare counts of current\n # window of text with\n # counts of pattern[]\n if self.compare(countP, countTW):\n ans += 1\n\n # Add current character to current window\n countTW[ord(txt[i])] += 1\n\n # Remove the first character of previous window\n countTW[ord(txt[i - M])] -= 1\n\n # Check for the last window in text\n if self.compare(countP, countTW):\n ans += 1\n return ans\n",
"updated_at_timestamp": 1730267670,
"user_code": "#User function Template for python3\nclass Solution:\n\n\t\n\tdef search(self,pat, txt):\n\t # code here"
} | eJy1VN1OgzAU9sL4HITrxbjpjT6JiTULlALl51AYLQWj8SH08bzzQexgEkk8c+uwTZrTtP369fQ73+v5++fFWd/uP0zw8ORyELJ27xx3ScDzacBCM0YxT9Ish0IQEGVFwF04LtOC0ZoF60LWuzNXBF7M4vPCmQJ1Xde2rda6aRqllJTSgHve0TgDoS2b3yICuu0sMNFOYBgRxNUNBun5PqVBwFgYRlEcc54kaZpleU4AoDiaYvpH63egqNcY7PY/y2pTS9WYxE0m/ZfNmcq+DzvwfN5i8ml1o2S9qUpRQJ6lCY+jkAXU7zVkBIBCLhHEbzmPL/45GTODM7UlevrVh5UG3YWnF8fgAOKfLGCvydj6w4jl2dOd1oaaoThm04aFOIaDcs5SRyyO23ocTnG/DA9+wePb5RfzQois |
709,901 | Longest Possible Route in a Matrix with Hurdles | Given an Nx Mmatrix, 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.
Examples:
Input:
{xs,ys} = {0,0}
{xd,yd} = {1,7}
matrix = 1 1 1 1 1 1 1 1 1 1
1 1 0 1 1 0 1 1 0 1
1 1 1 1 1 1 1 1 1 1
Output:
24
Explanation:
Input:
{xs,ys} = {0,3}
{xd,yd} = {2,2}
matrix =
1 0 0 1 0
0 0 0 1 0
0 1 1 0 0
Output:
-1
Explanation:
We can see that it is impossible to
reach the cell (2,2) from (0,3).
Constraints:
1 <= N,M <= 10 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1650428085,
"func_sign": [
"public static int longestPath(int[][] mat,int n,int m,int xs,int ys,int xd,int yd)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\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<Integer> a)\n {\n for(int e : a)\n System.out.print(e + \" \");\n System.out.println();\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<ArrayList<Integer>> 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 \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Pair\n{\n boolean found = false;\n int value = 0;\n Pair(boolean f, int val)\n {\n this.found = f;\n this.value = val;\n }\n}\nclass Solution {\n static int dx[] = {0, 0, 1, -1};\n static int dy[] = {1, -1, 0, 0};\n \n static Pair findLongestPathUtil(int [][]mat, int i, int j, int x,\n int y, boolean [][]visited)\n {\n\n \n\n // if not a valid cell, return false\n if (i < 0 || i >= mat.length || j < 0 || j >= mat[0].length || mat[i][j] == 0 || visited[i][j])\n {\n Pair p = new Pair(false, Integer.MAX_VALUE);\n return p;\n }\n // if (i, j) itself is destination, return true\n if (i == x && j == y)\n {\n Pair p = new Pair(true, 0);\n return p;\n }\n // include (i, j) in current path i.e.\n // set visited(i, j) to true\n visited[i][j] = true;\n\n // res stores longest path from current cell (i, j) to\n // destination cell (x, y)\n int res = Integer.MIN_VALUE;\n\n // go left from current cell\n for (int k = 0; k < 4; k++)\n {\n int ii = i + dx[k];\n int jj = j + dy[k];\n Pair sol = findLongestPathUtil(mat, ii, jj, x, y, visited);\n if (sol.found)\n res = Math.max(res, sol.value);\n }\n\n // Backtrack\n visited[i][j] = false;\n\n // if destination can be reached from current cell,\n // return true\n if (res != Integer.MIN_VALUE)\n {\n Pair p = new Pair(true, 1 + res);\n return p;\n }\n else // if destination can't be reached from current cell return false\n {\n\n Pair p = new Pair(false, Integer.MAX_VALUE);\n return p;\n }\n }\n \n public static int longestPath(int[][] mat,int n,int m,int xs,int ys,int xd,int yd) {\n int N = mat.length;\n int M = mat[0].length;\n boolean [][] visited = new boolean[N+1][M+1];\n\n Pair p = findLongestPathUtil(mat, xs, ys, xd, yd, visited);\n\n return p.found ? p.value : -1;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public static int longestPath(int[][] mat,int n,int m,int xs,int ys,int xd,int yd) {\n // code here\n }\n}\n \n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1650428085,
"func_sign": [
"longestPath(self,mat : List[List[int]],n : int, m : int, xs : int, ys : int, xd : int, yd : int) -> int"
],
"initial_code": "class IntArray:\n\n def __init__(self) -> None:\n pass\n\n def Input(self, n):\n arr = [int(i) for i in input().strip().split()] # array input\n return arr\n\n def Print(self, arr):\n for i in arr:\n print(i, end=\" \")\n print()\n\n\nclass IntMatrix:\n def __init__(self) -> None:\n pass\n\n def Input(self, n, m):\n matrix = []\n # matrix input\n for _ in range(n):\n matrix.append([int(i) for i in input().strip().split()])\n return matrix\n\n def Print(self, arr):\n for i in arr:\n for j in i:\n print(j, end=\" \")\n print()\n\n\nif __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n\n a = IntArray().Input(2)\n\n b = IntArray().Input(4)\n\n mat = IntMatrix().Input(a[0], a[0])\n\n obj = Solution()\n res = obj.longestPath(mat, a[0], a[1], b[0], b[1], b[2], b[3])\n\n print(res)\n\n print(\"~\")\n",
"solution": "import sys\nfrom typing import List\nsys.setrecursionlimit(10**5)\n\n\nclass Solution:\n def isSafe(self, pos, n, m, visited, mat):\n return (pos[0] >= 0 and pos[0] < n and pos[1] >= 0 and pos[1] < m and\n mat[pos[0]][pos[1]] != 0 and (pos[0], pos[1]) not in visited)\n\n def util(self, start, end, mat, visited, n, m, res, d):\n visited.add((start[0], start[1]))\n if start[0] == end[0] and start[1] == end[1]:\n if res[0] < d:\n res[0] = d\n visited.remove((start[0], start[1]))\n return\n path = [[0, 1], [1, 0], [0, -1], [-1, 0]]\n for p in path:\n if self.isSafe((start[0] + p[0], start[1] + p[1]), n, m, visited, mat):\n self.util((start[0] + p[0], start[1] + p[1]),\n end, mat, visited, n, m, res, d + 1)\n visited.remove((start[0], start[1]))\n return\n\n def longestPath(self, mat: List[List[int]], n: int, m: int, xs: int, ys: int, xd: int, yd: int) -> int:\n # code here\n # if mat[xs][ys]==0 or mat[xd][yd]==0:\n # return -1\n visited = set()\n visited.add((xs, ys))\n # q=Queue()\n res = [0]\n\n if mat[xs][ys] == 0:\n return -1\n self.util((xs, ys), (xd, yd), mat, visited, n, m, res, 0)\n if res[0] != 0:\n return res[0]\n return -1\n",
"updated_at_timestamp": 1729753320,
"user_code": "\n\nclass Solution:\n def longestPath(self,mat : List[List[int]],n : int, m : int, xs : int, ys : int, xd : int, yd : int) -> int:\n # code here\n \n"
} | eJzVVr1OwzAQZmDjJU6eC7pr0ojwJEgYMUAGFtMhlZAQCDYeAN4Xx26D7fiCA7FakiHO5fx99++8Hn++nxyZ6/JNL66exL1ab1pxAYKkKqCQCgFhCUupCPTdPdA+zJtYgGge181t29zdPGza7eZSqhf98XkBPuIKVhaxhNJioIPqIFvpVgboSRnOc4bTUHWcxp0epUN2+SzbGAEhw0B6J1qOGmrHVvB8CW8aauK3Zb1WsiaDmc5OrJCJSFExEamgspwm4QG+ZwH63kRcowBgcnYc//WCBTilJADeAh4gqI9hMvCfC6dGpJ8DuJsD5Ld5yvKvaWDKP9ooGG8+p0p94W60BcKB5q8bepY2jRdm2uRHM1rnK6I8qjmL+Me2nsOo/QrzhuSQPM0Uk9EDY6hbk5SxIysdgTcwaln3azTZurQNk8rh0JKMueoBxwJ+/XH2BVi0rs8= |
702,953 | Check if a given string is a rotation of a palindrome | Given a string s, check if it can be rotated to form a palindrome.
Examples:
Input:
s = aaaab
Output:
1
Explanation:
"aaaab" can be rotated to
form "aabaa" which is a palindrome.
| geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int isRotatedPalindrome(String s)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\nclass GfG\n{\n public static void main (String[] args)\n {\n \n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n \n String s = sc.next();\n \n int answer = new Solution().isRotatedPalindrome(s);\n \t\tSystem.out.println(answer);\n }\n \n }\n}\n\n",
"script_name": "GfG",
"solution": "None",
"updated_at_timestamp": 1730894205,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n int isRotatedPalindrome(String s)\n {\n // Your Code Here \n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"isRotatedPalindrome(self, s)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n T = int(input())\n\n for _ in range(T):\n s = input()\n ob = Solution()\n answer = ob.isRotatedPalindrome(s)\n print(answer)\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def isPalindrome(self, string):\n # Start from leftmost and rightmost corners of str\n l = 0\n h = len(string) - 1\n\n # Keep comparing characters while they are same\n while h > l:\n l += 1\n h -= 1\n if string[l - 1] != string[h + 1]:\n return False\n\n # If we reach here, then all characters were matching\n return True\n\n # Function to check if a given string is a rotation of a\n # palindrome.\n def isRotatedPalindrome(self, string):\n # If string itself is palindrome\n if self.isPalindrome(string):\n return 1\n\n # Now try all rotations one by one\n n = len(string)\n for i in range(n - 1):\n string1 = string[i + 1:n]\n string2 = string[0:i + 1]\n\n # Check if this rotation is palindrome\n string1 += string2\n if self.isPalindrome(string1):\n return 1\n\n return 0\n",
"updated_at_timestamp": 1730894205,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef isRotatedPalindrome(self, s):\n\t\t#code here"
} | eJxrYJn6kYMBDCJeARnR1UqZeQWlJUpWCkpGMXmJSclJiUAKBJKUdBSUUisKUpNLUlPi80tLoMoMY/IMYvKUanUUkPQax+QVJSanJicWxeQBiVQgB2RMEh5DIAjNHKBIRUVlZQVubWgaTGLyqvAAsJdSUtPSM2LykoDuARqP13QDHO4Chk1OallqTkxeXn5+Hl5PYfookWjfgBTjCjLMQAepJtHsZFzqsZoOCit8mCS7Y2KAtqNHFxGWwNXiTGNkRDX2wKSFEyuo60Z0q0HOpka0xIDYpHg8GYvPIUkMnCxpGQbUcHPiQDmapomrihqpC80BRKUt3DUCPTIQ4frGAFa0Uy1iMHTSPo6JzP64kwKVXEQ4QojwETWzFhDn4a4KwXpip+gBALiWcko= |
706,459 | Rank The Permutations | Given a string, find the rank of the string amongst its permutations sorted lexicographically.Example 1:
Examples:
Input:
S = "abc"
Output:
1
Explanation:
The order permutations with letters
'a', 'c', and 'b' :
abc
acb
bac
bca
cab
cba
Input:
S = "acb"
Output:
2
Constraints:
1 ≤ |S| ≤ 18 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public long findRank(String S)"
],
"initial_code": "//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 \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "// Backend complete function Template for Java\nclass Solution {\n public long findRank(String str) {\n // Calculating factorial values\n long[] fact = new long[20];\n fact[0] = 1l;\n long p = 1l;\n for (int i = 2; i <= 18; i++) {\n p *= i;\n fact[i - 1] = p;\n }\n int len = str.length();\n long mul = fact[len - 1];\n long rank = 1l;\n // all elements of count[] are initialized with 0\n long[] count = new long[26];\n Arrays.fill(count, 0l);\n // Populate the count array such that count[i]\n // contains count of characters which are present\n // in str and are smaller than i\n for (int i = 0; i < len; ++i) ++count[str.charAt(i) - 'a'];\n for (int i = 1; i < 26; ++i) count[i] += count[i - 1];\n for (int i = 0; i < len; ++i) {\n mul /= (len - i);\n // count number of chars smaller than str[i]\n // fron str[i+1] to str[len-1]\n int x = (str.charAt(i) - 'a') - 1;\n if (x >= 0) rank += count[x] * mul;\n // Reduce count of characters greater than str[i]\n for (int j = str.charAt(i) - 'a'; j < 26; ++j) --count[j];\n }\n return rank;\n }\n}\n",
"updated_at_timestamp": 1730272355,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public long findRank(String S)\n {\n // Code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"findRank(self, S)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n str = input().strip()\n obj = Solution()\n ans = obj.findRank(str)\n print(ans)\n print(\"~\")\n",
"solution": "# Backend complete function Template for python3\n\nclass Solution:\n def findRank(self, str):\n # Calculating factorial values\n fact = []\n fact.append(1)\n p = 1\n for i in range(2, 19):\n p *= i\n fact.append(p)\n\n l = len(str)\n mul = fact[l-1]\n rank = 1\n\n # all elements of count[] are initialized with 0\n count = [0]*26\n\n # Populate the count array such that count[i]\n # contains count of characters which are present\n # in str and are smaller than i\n for i in range(l):\n count[ord(str[i])-97] += 1\n\n for i in range(1, 26):\n count[i] += count[i-1]\n\n for i in range(l):\n mul //= (l - i)\n # count number of chars smaller than str[i]\n # from str[i+1] to str[len-1]\n x = ord(str[i]) - 98\n if x >= 0:\n rank += count[x] * mul\n # Reduce count of characters greater than str[i]\n for j in range(ord(str[i])-97, 26):\n count[j] -= 1\n\n return rank\n",
"updated_at_timestamp": 1731597563,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef findRank(self, S):\n\t\t#Code here"
} | eJyVkt0KgjAUx7vwQWTXFnMLN3uPIGgR7sPUyrxQCKPoIep9E0Oii6OcXQ12Dr//x57eW3mz/mzW3WV7I3lZNTVZ+SRUZUICn7hr5Uzt7P7S1L+nhyrJPfD/51vsPARgwEKCJSQauaDRkrSxLj1kORJU5NkhddaAQB4xKSmdwhZI7vl0nERHjAnKKExvwao5pLeXiw0p0YNNDflcRoyD0O+2UhmwDPnrEgLDCRmYChxLPKqwGOlRQOb6IqealCIUImaSg6KHj4RuxlilXAr++/lgefdafABHLW9n |
705,108 | A Simple Fraction | Given a fraction. Convert it into a decimal.If the fractional part is repeating, enclose the repeating part in parentheses.
Examples:
Input:
numerator = 1, denominator = 3
Output:
"0.(3)"
Explanation:
1/3 = 0.3333... So here 3 is
recurring.
Input:
numerator = 5, denominator = 2
Output:
"2.5"
Explanation:
5/2 = 2.5
Constraints:
1 ≤ numerator, denominator ≤ 2000 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615931384,
"func_sign": [
"public String fractionToDecimal(int numerator, int denominator)"
],
"initial_code": "//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 numerator = Integer.parseInt(S[0]);\n int denominator = Integer.parseInt(S[1]);\n Solution ob = new Solution();\n String ans = ob.fractionToDecimal(numerator, denominator);\n System.out.println(ans);\n }\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public String calculateFraction(int a, int b) {\n // If the numerator is zero, answer is \"0\"\n if (a == 0) return \"0\";\n // If exactly one of the numerator or denominator\n // is negative, then result will be negative\n String res = (a < 0) ^ (b < 0) ? \"-\" : \"\";\n\n a = Math.abs(a);\n b = Math.abs(b);\n // Calculate and Append the part before decimal point\n res += Integer.toString(a / b);\n int rem = a % b;\n // If completely divisible, return res\n if (rem == 0) return res;\n\n res += \".\";\n HashMap<Integer, Integer> mp = new HashMap<>();\n while (rem > 0) {\n // If this remainder is already seen,\n // then there exists a repeating fraction.\n if (mp.containsKey(rem)) {\n res = res.substring(0, mp.get(rem)) + \"(\" + res.substring(mp.get(rem)) + \")\";\n break;\n }\n // If the remainder is seen for the first time,\n // store its index\n mp.put(rem, res.length());\n\n rem = rem * 10;\n // Calculate quotient, append it to result and\n // calculate next remainder\n res += Integer.toString(rem / b);\n rem = rem % b;\n }\n return res;\n }\n}\n",
"updated_at_timestamp": 1730986589,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public String fractionToDecimal(int numerator, int denominator)\n {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615931384,
"func_sign": [
"fractionToDecimal(self, numerator, denominator)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n numerator, denominator = input().split()\n numerator = int(numerator)\n denominator = int(denominator)\n ob = Solution()\n ans = ob.fractionToDecimal(numerator, denominator)\n print(ans)\n",
"solution": "class Solution:\n\n # Function to convert a fraction to decimal.\n def fractionToDecimal(self, numerator, denominator):\n # Dictionary to keep track of remainder and their corresponding position in the decimal.\n mp = {}\n\n # Calculating the integral part and remainder.\n first = numerator // denominator\n rem = numerator % denominator\n\n S = str(first) # Storing the integral part in a string.\n\n # If remainder is zero, the number is a whole number and we can return the string representation.\n if rem == 0:\n return S\n\n S += \".\" # Adding a period to represent the decimal part.\n\n # Looping until the remainder becomes zero.\n while rem != 0:\n # If the remainder is already present in the dictionary, it means the decimal is repeating.\n # We insert a parenthesis around the repeating part and return the string.\n if rem in mp:\n S = S[:mp[rem]] + \"(\" + S[mp[rem]:]\n S += ')'\n return S\n\n # If the remainder is not present in the dictionary, we add it along with its position in the string.\n else:\n mp[rem] = len(S)\n # Calculating the next decimal digit.\n xyz = (rem * 10) // denominator\n S += str(xyz) # Adding the digit to the string.\n # Updating the remainder for the next iteration.\n rem = (rem * 10) % denominator\n\n return S # Returning the final decimal representation.\n",
"updated_at_timestamp": 1730986589,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef fractionToDecimal(self, numerator, denominator):\n\t\t# Code here"
} | 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 |
702,029 | Search in a 2D Matrix | Given amatrix[][],with the following two properties:
Examples:
Input:
matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
Output:
true
Explanation:
the numner 3 exists in the matrix.
Input:
matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
Output:
false
Constraints:
1 <= number of rows, number of columns <= 10**3
-10**4
<= matrix[i][j], target <= 10**4 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1729521069,
"func_sign": [
"public boolean searchMatrix(int[][] mat, int target)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\n\npublic class Main {\n public static void main(String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\n int t = Integer.parseInt(br.readLine().trim()); // Read number of test cases\n while (t-- > 0) {\n String[] dimensions = br.readLine().split(\" \");\n int n = Integer.parseInt(dimensions[0]);\n int m = Integer.parseInt(dimensions[1]);\n\n int[][] matrix = new int[n][m];\n for (int i = 0; i < n; i++) {\n String[] row = br.readLine().split(\" \");\n for (int j = 0; j < m; j++) {\n matrix[i][j] = Integer.parseInt(row[j]);\n }\n }\n\n int target = Integer.parseInt(br.readLine().trim());\n Solution sol = new Solution();\n boolean found = sol.searchMatrix(matrix, target);\n System.out.println(found ? \"true\" : \"false\");\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1730467645,
"user_code": "class Solution {\n public boolean searchMatrix(int[][] mat, int target) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1729521069,
"func_sign": [
"searchMatrix(self, mat, target)"
],
"initial_code": "if __name__ == '__main__':\n t = int(input()) # Number of test cases\n for _ in range(t):\n n, m = map(int, input().split()) # Dimensions of the matrix\n matrix = [\n list(map(int, input().split()))\n for _ in range(n)\n ] # Matrix input\n target = int(input()) # Target to search for\n\n # Call the function and print the result\n ob = Solution()\n result = ob.searchMatrix(matrix, target)\n print('true' if result else 'false')\n print(\"~\")\n",
"solution": "class Solution:\n def searchMatrix(self, matrix, target):\n if not matrix or not matrix[0]:\n return False\n\n rows = len(matrix)\n cols = len(matrix[0])\n\n # Binary search for the correct row\n low, high = 0, rows - 1\n while low < high:\n mid = (low + high) // 2\n if matrix[mid][cols - 1] < target:\n low = mid + 1\n else:\n high = mid\n\n row = high # The row where the target might be\n low, high = 0, cols - 1\n\n # Binary search within the row\n while low <= high:\n mid = (low + high) // 2\n if matrix[row][mid] == target:\n return True\n elif matrix[row][mid] < target:\n low = mid + 1\n else:\n high = mid - 1\n\n return False\n",
"updated_at_timestamp": 1730467645,
"user_code": "class Solution:\n def searchMatrix(self, mat, target):\n #code here"
} | eJztlt2K1EAQRr3wyqdocr2RdKd/fRLBiIiOIEhcdAYEUXwIfTHvfBvPV73CwjI6k7kRMdCd2U2dnlT1qd79cv/bjwf37Hr8nQ9PPg6v1+vDfnjkhjFN07IOV27YfbjevdjvXj57e9jfPBw+XblbsX5Zk0vLOvqJy42Ny+Zqc7E585xbsh+izbPNwWbfHxtdja5GV6Nrp6vR1ehqdDW6droaXYwuRhejS6dLOprQq+dv3u+W9TMBd1Lzk/OTbpMLjJkRGdTHZUZhVEabFKeieYV6xXoFe0V7hXvFewFehG99SZBgqwsJQoKQICQICUKCkND6G4DMQmZ7IyGzkFnILGQWMguZW39hkCgkComWhZAoJAqJQqKQ2Hp+IElIEpKEJMtcSBKShCQhqfVygGQhWUgWkoVkq5aQLCQLya1XD6QIKUKKkCKkCClWYSFFSGm92CBVSBVShVQhVUgVUm1XhNTW9wakCWlCmpAmpAlpQpqQZjv5ayuV/zRttMaZOl0I3Y6ssX93+O0S480a4yWL6B025wB+Qde44GYXXXLZFVdd679l5UB30Bt0Bn1BV9ATdAT9oG6gF+gE+oAuoAfoAPzHftyX+XiP9TiP8fiO7biO6Xguy3Ecw/Ebu3Ebs/Eaq3FaRuMzNuMyJuMxFuMwBuOv7MVdzMVbrMVZjMVXbMVVmYqnWIqjGIqf2ImbmImXshInMRIfsREXMREPsRAHZSD+YR/uYR7eYR3OYZx8k20bNvh/oc8vtJ+29AOZqtBk5EovvFdJrZIUSYdwT+3cbTza2HfiTgwcdVqf+udbwdpskHFZdECfC24imx2MthcbvvuP23HJftw+N1M71xT756Tlk/P49zr4bzkrn359+BMPrqQ3 |
713,586 | Length of the longest subarray with positive product | Given an arrayarr[]consisting of nintegers, findthe lengthof the longest subarray withpositive (non zero) product.
Examples:
Input:
arr[] ={0, 1, -2, -3, -4}
Output:
3
Explanation:
The longest subarray with positive product is:
{1, -2, -3}.
Therefore, the required length is 3.
Input:
arr[]={-1, -2, 0, 1, 2}
Output:
2
Explanation:
The longest subarray with positive products
are: {-1, -2}, {1, 2}. Therefore, the required
length is 2.
| geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1673952636,
"func_sign": [
"int maxLength(int arr[], int n)"
],
"initial_code": "//Initial Template for Java\n\nimport java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass Geeks\n{\n public static void main(String args[])throws IOException\n {\n BufferedReader in=new BufferedReader(new InputStreamReader(System.in));\n PrintWriter out=new PrintWriter(System.out);\n int t = Integer.parseInt(in.readLine().trim());\n \n while(t-- > 0)\n {\n int n =Integer.parseInt(in.readLine().trim());\n int arr[] = new int[n];\n String s[]=in.readLine().trim().split(\" \");\n for(int i = 0; i < n; i++)\n arr[i] = Integer.parseInt(s[i]);\n \n out.println(new Solution().maxLength(arr, n)); \n \nout.println(\"~\");\n}\n out.close();\n }\n}",
"script_name": "Geeks",
"solution": "//Back-end complete function Template for Java\n\nclass Solution{\n /* Function to return the length of the\n longest subarray with ppositive product */\n int maxLength(int arr[], int n) { \n int pos = 0,neg = 0,ans = 0;\n for(int i = 0;i<n;i++){\n if(arr[i]==0){\n // If current element is 0, reset positive and negative counters to 0\n pos = 0;\n neg = 0;\n } else if (arr[i] > 0){\n // If current element is positive, increment positive counter\n pos+=1;\n if(neg > 0){\n // If negative counter is non-zero, increment it as well\n neg+=1;\n }\n } else if(arr[i]<0){\n // If current element is negative, swap positive and negative counters\n int temp = pos;\n if(neg > 0){\n pos = 1+neg;\n // If negative counter is non-zero, increment positive counter by one more than it\n } else {\n pos = 0;\n }\n neg = 1 + temp;\n // Increment negative counter by 1\n }\n ans = Math.max(ans,pos);\n // Update ans with the maximum value of positive counter encountered so far\n }\n return ans;\n }\n \n}",
"updated_at_timestamp": 1730481897,
"user_code": "//User function Template for Java\n\nclass Solution{\n /* Function to return the length of the\n longest subarray with ppositive product */\n int maxLength(int arr[], int n) { \n //code here\n }\n \n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1673952636,
"func_sign": [
"maxLength(self,arr,n)"
],
"initial_code": "def main():\n T=int(input())\n while(T>0):\n \n n=int(input())\n\n arr=[int(x) for x in input().strip().split()]\n \n \n obj = Solution()\n print(obj.maxLength(arr,n))\n \n T-=1\n\n\n print(\"~\")\nif __name__ == \"__main__\":\n main()",
"solution": "#Back-end complete function Template for Python 3\n\nclass Solution:\n #Function to find the maximum length of subarray with consecutive elements.\n def maxLength(self,arr,n):\n #Initializing variables\n pos = 0 #Number of positive elements in current subarray\n neg = 0 #Number of negative elements in current subarray\n ans = 0 #Answer, representing the maximum length of subarray\n \n #Iterating over the array\n for i in range(n):\n #If current element is 0, reset positive and negative counts\n if arr[i] == 0:\n pos,neg = 0,0\n #If current element is positive, increment positive count and update negative count if needed\n elif arr[i] > 0 :\n pos+=1\n if neg > 0:\n neg+=1\n #If current element is negative, update positive count and negative count\n else:\n temp = pos\n if neg > 0:\n pos = neg + 1\n else:\n pos = 0\n neg = temp + 1\n #Update the answer with the maximum length of subarray\n ans = max(ans,pos)\n #Return the maximum length of subarray\n return ans\n",
"updated_at_timestamp": 1730481897,
"user_code": "#User function Template for python3\nclass Solution:\n def maxLength(self,arr,n):\n #code here"
} | eJxrYJkaxcIABhHBQEZ0tVJmXkFpiZKVgpJhTB4QGcTkKekoKKVWFKQml6SmxOeXlkDlgTJ1QMlaHQUMTYY4NRni1qSLWxcuq4yA7lMg3YVAbYZ4tOFyoxHIjeRah9tzRnitwxMquDQaQ9yJx0pcPjSB6iTDXtzBgmmNLtFW4QpSBXjiJNGTeOzCmijRnEmybeSGCVLi1jUkPXzABpKih4A9eNxLwJbYKXoAD8ZcMQ== |
712,225 | Burst Balloons | You are given Nballoons, indexed from 0 to n - 1. Each balloon is painted with a number on it represented by an array arr. You are asked to burst all the balloons.
If you burst the ithballoon, you will get arr[ i - 1 ] * arr[ i ] * arr[ i + 1] coins. If i - 1, or i + 1 goes out of the bounds of the array, consider it as if there is a balloon with a 1 painted on it.
Return the maximum coins you can collect by bursting the balloons wisely.
Examples:
Input:
arr[] = [5, 10]
Output:60
Explanation:
[5, 10] -> [10] -> []. coins = 1*5*10 + 1*10*1 = 60.
Input:
arr[] = [3, 1, 5, 8]
Output: 167
Explanation:
[3, 1, 5, 8] -> [3, 5, 8] -> [3, 8] -> [8] -> []. coins = 3*1*5 + 3*5*8 + 1*3*8 + 1*8*1 = 167.
Constraints:
1 ≤ N ≤ 300
0≤ arr [ i ] ≤ 100 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1731737459,
"func_sign": [
"public static int maxCoins(int[] arr)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.math.*;\nimport java.util.*;\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 a[] = new int[n];\n for (int i = 0; i < n; i++) {\n a[i] = sc.nextInt();\n }\n Solution obj = new Solution();\n int ans = obj.maxCoins(a);\n System.out.println(ans);\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution {\n public static int maxCoins(int[] arr) {\n // code here\n // creating an array of size n+2 and initializing the first and last element to\n // 1, while copying the values from the given array in between.\n int n = arr.length;\n int a[] = new int[n + 2];\n n = a.length;\n a[0] = a[n - 1] = 1;\n for (int i = 1; i < n - 1; i++) a[i] = arr[i - 1];\n\n dp = new int[n][n];\n for (int e[] : dp) Arrays.fill(e, -1); // initializing dp array with -1\n\n return fun(a, 0, n - 1); // returning the result of the recursive function\n }\n\n static int dp[][];\n\n static int fun(int a[], int l, int r) {\n if (r - l <= 1)\n return 0; // base case, if there are no elements between l and r return 0\n if (dp[l][r] != -1)\n return dp[l][r]; // if the value is already calculated, return it\n\n int ans = 0;\n for (int m = l + 1; m < r; m++) {\n // calculating the maximum number of coins that can be obtained by bursting\n // balloons from l to r through m\n int temp = a[l] * a[m] * a[r] + fun(a, l, m) + fun(a, m, r);\n ans = Math.max(ans, temp); // updating the value of ans if temp is greater\n }\n\n return dp[l][r] = ans; // memoizing the result and returning it\n }\n}",
"updated_at_timestamp": 1731737459,
"user_code": "// User function Template for Java\n\nclass Solution {\n public static int maxCoins(int[] arr) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1731737459,
"func_sign": [
"maxCoins(self, arr : List[int]) -> int"
],
"initial_code": "class IntArray:\n\n def __init__(self) -> None:\n pass\n\n def Input(self, n):\n arr = [int(i) for i in input().strip().split()] # array input\n return arr\n\n def Print(self, arr):\n for i in arr:\n print(i, end=\" \")\n print()\n\n\nif __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n N = int(input())\n arr = IntArray().Input(N)\n\n obj = Solution()\n res = obj.maxCoins(arr)\n print(res)\n\n print(\"~\")\n",
"solution": "from typing import List\n\n\nclass Solution:\n\n def maxCoins(self, arr: List[int]) -> int:\n n = len(arr)\n arr = [1] + arr\n arr.append(1)\n dp = [[0] * (len(arr) + 1) for _ in range(len(arr))]\n for le in range(1, n + 1):\n for left in range(1, n - le + 2):\n right = left + le - 1\n for k in range(left, right + 1):\n dp[left][right] = max(\n dp[left][right],\n arr[left - 1] * arr[k] * arr[right + 1] +\n dp[left][k - 1] + dp[k + 1][right])\n return dp[1][n]\n",
"updated_at_timestamp": 1731737459,
"user_code": "from typing import List\nclass Solution:\n def maxCoins(self, arr : List[int]) -> int:\n # code here\n \n"
} | eJytVMFKAzEQ9SD05jc89iwymSSTjF8iuOJBe/Cy9tCCIIofof/rZLeKhc7aii0bhuzy5uW9N3k7/ThbnIy/q4UV18/dw7DarLtLdKEfcj8oikASOEBLd45u+bRa3q2X97ePm/X2SxFNmvrhtR+6l3PsYkg/BASi3cdBYgoUiRyoYC9iBhunimRFRBajta2DhxpYhEkc1GrAAZxg0CkgKySiMKoLRyWQRI8k2xMbn5gaMWMopRGuCrWTc9vP4gnAKaTqCcD2YjquYVgHAzbUbNS5GTQ12YrB285WT5uuPDmVGf9CC4HC7P9l8dCVzNIwY2kmJEIkcAtHW+O4Y/tCDmqqhWROpkltNWIMjdAEzdAxLVpHyi2GMDdgdkBgUjq9qkau7gnY9DGXj/t77ivlv9rQmHxHpFFyHYmaiN0hm8RzpThmNA+ZTYtezbnMXB7eFLp+/FTBvWcOcLMtjn8W0MMczaLFGWfsuXro18unSq4SY/2nNM6F0SO+d8AK24gdMGPekBUyoUTZtXVqOVYp931kM3gvAfojg1C+RL15v/gEe5zZ0g== |
705,696 | Biconnected Graph | Given a graph with n vertices, e edges and an array arr[] denoting the edges connected to each other, check whether it is Biconnected or not.Note: The given graph is Undirected.
Examples:
Input:
n =
2,
e =
1
,
arr =
{0, 1}
Output:
1
Explanation:
0
/
1
The above graph is Biconnected.
Input:
n =
3,
e =
2
,
arr =
{0, 1, 1, 2}
Output:
0
Explanation:
0
/
1
\
2
The above graph is not Biconnected.
Constraints:
1 <= e <= 100
2 <= n <= 100 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int biGraph(int[] arr, int n, int e)"
],
"initial_code": "//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 S[] = read.readLine().split(\" \");\n int n = Integer.parseInt(S[0]);\n int e = Integer.parseInt(S[1]);\n \n String S1[] = read.readLine().split(\" \");\n int[] arr = new int[2*e];\n \n for(int i=0; i<2*e; i++)\n arr[i] = Integer.parseInt(S1[i]);\n\n Solution ob = new Solution();\n System.out.println(ob.biGraph(arr,n,e));\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730479065,
"user_code": "//User function Template for Java\n\nclass Solution {\n static int biGraph(int[] arr, int n, int e) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"biGraph(self, arr, n, e)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n n, e = map(int, input().split())\n arr = list(map(int, input().split()))\n\n ob = Solution()\n print(ob.biGraph(arr, n, e))\n print(\"~\")\n",
"solution": "class Solution:\n def biGraph(self, arr, n, e):\n # Initializing the arrays and dictionaries\n discover = [-1 for i in range(n)]\n ancestor = [-1 for i in range(n)]\n adj = {}\n for i in range(n):\n adj[i] = []\n\n # Building the adjacency list\n for i in range(0, len(arr), 2):\n u, v = arr[i], arr[i+1]\n adj[u].append(v)\n adj[v].append(u)\n\n step = 0\n cut_vertex = []\n\n def findCutVertex(node, parent):\n nonlocal adj, step, discover, ancestor, cut_vertex\n\n # Marking the current node as discovered and assigning an ancestor value\n discover[node] = step\n ancestor[node] = step\n step += 1\n\n child_count = 0\n # Looping through the neighbors of the current node\n for neighbor in adj[node]:\n if neighbor == parent:\n continue\n\n # If the neighbor is not yet discovered, recursively call the function on it\n if discover[neighbor] == -1:\n child_ancestor = findCutVertex(neighbor, node)\n ancestor[node] = min(ancestor[node], child_ancestor)\n child_count += 1\n else:\n ancestor[node] = min(ancestor[node], discover[neighbor])\n\n # Checking if the current node is a cut vertex\n if discover[node] == 0:\n if child_count > 1:\n cut_vertex.append(node)\n elif discover[node] <= ancestor[node] and parent != 0:\n cut_vertex.append(node)\n\n return ancestor[node]\n\n # Calling the findCutVertex function on the root node (0)\n findCutVertex(0, None)\n\n # Checking if the graph is a biconnected graph\n if step < n or len(cut_vertex) > 0:\n return 0\n else:\n return 1\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def biGraph(self, arr, n, e):\n # code here "
} | eJxrYJn6lpUBDCKeARnR1UqZeQWlJUpWCkqGMXlGCkDCAEQo6SgopVYUpCaXpKbE55eWINTUASVrdRRQNRorGIM1AqEREBqQbIAJqgHGOA0wwGmACYoBQEi6K0wxDTEh2SWmCqYYhgAh6a4xw26QKckuMlMww2oQEJLuKkMDBUtcpgEtUjAHQgsgtCTZmUCTDQ2IMhoIqRW5JIYmbmsxLUTkJhBNejATHxhg9WRFJUkBjjuscNmACAL8aZC8MILHKIX5FSNdkBc2pKcm1JKTnKITajMebUq1sVP0AFpfpys= |
712,574 | Print Longest Increasing Subsequence | Given an integer n and an array of integers arr, return the Longest Increasing Subsequence which is Index-wise lexicographically smallest.Note -A subsequenceS1isIndex-wiselexicographically smallerthan a subsequenceS2if in the first position where S1 and S2 differ, subsequenceS1has an element that appearsearlier in the array arr than the corresponding element inS2.LIS of a given sequence is defined as that longest possible subsequence all of whose elements are in increasing order. For example, the length of LIS for {10, 22, 9, 33, 21, 50, 41, 60, 80} is 6 and the LIS is {10, 22, 33, 50, 60, 80}.
Examples:
Input:
n = 16
arr = [0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15]
Output:
0 4 6 9 13 15
Explanation:
longest Increasing subsequence is 0 4 6 9 13 15 and the length of the longest increasing subsequence is 6.
Input:
n = 1
arr = [1]
Output:
1
| geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1668705304,
"func_sign": [
"public ArrayList<Integer> longestIncreasingSubsequence(int n, int arr[])"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\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[] arr = new int[N];\n for (int i = 0; i < N; i++) {\n arr[i] = sc.nextInt();\n }\n Solution obj = new Solution();\n ArrayList<Integer> ans = obj.longestIncreasingSubsequence(N, arr);\n for (int i = 0; i < ans.size(); i++) {\n System.out.print(ans.get(i) + \" \");\n }\n System.out.println();\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n public ArrayList<Integer> longestIncreasingSubsequence(int N, int arr[]) {\n // initialize dp array and hash array with size N\n int[] dp = new int[N];\n int[] hash = new int[N];\n // fill dp array with 1 for each index\n Arrays.fill(dp, 1);\n // fill hash array with 1 for each index\n Arrays.fill(hash, 1);\n // find the longest increasing subsequence\n for (int i = 0; i <= N - 1; i++) {\n // set the hash value of current index as the index itself\n hash[i] = i;\n // iterate through previous indices to find the maximum dp value\n for (int j = 0; j <= i - 1; j++) {\n // if current element is greater than previous element\n // and current dp value plus 1 is greater than previous dp value\n if (arr[j] < arr[i] && dp[j] + 1 > dp[i]) {\n // update dp value and hash value\n dp[i] = dp[j] + 1;\n hash[i] = j;\n }\n }\n }\n // find the maximum dp value and its corresponding index\n int ans = -1;\n int lastIndex = -1;\n for (int i = 0; i <= N - 1; i++) {\n if (dp[i] > ans) {\n ans = dp[i];\n lastIndex = i;\n }\n }\n // create an ArrayList to store the longest increasing subsequence\n ArrayList<Integer> temp = new ArrayList<>();\n // add the last element to the ArrayList\n temp.add(arr[lastIndex]);\n // use the hash array to backtrack and add the rest of the elements to the\n // ArrayList\n while (hash[lastIndex] != lastIndex) {\n lastIndex = hash[lastIndex];\n temp.add(arr[lastIndex]);\n }\n // reverse the ArrayList to get the correct order\n Collections.reverse(temp);\n // return the longest increasing subsequence\n return temp;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public ArrayList<Integer> longestIncreasingSubsequence(int n, int arr[]) {\n // Code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1667710061,
"func_sign": [
"longestIncreasingSubsequence(self, N, arr)"
],
"initial_code": "# Initial Template for Python 3\n\n# Position this line where user code will be pasted.\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n arr = list(map(int, input().split()))\n ob = Solution()\n res = ob.longestIncreasingSubsequence(N, arr)\n for val in res:\n print(val, end=' ')\n print()\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def longestIncreasingSubsequence(self, n, arr):\n # Initializing dp and pos arrays with all ones.\n dp = [1] * n\n pos = [1] * n\n\n # iterating over the array.\n for i in range(n):\n # setting the current position to i\n pos[i] = i\n\n # iterating over previous indices.\n for prev_index in range(i):\n # checking if the element at previous index is smaller\n # than the current element and the length is greater than\n # the current length.\n if arr[prev_index] < arr[i] and (1 + dp[prev_index] > dp[i]):\n # updating the length and the position.\n dp[i] = 1 + dp[prev_index]\n pos[i] = prev_index\n\n ans = lastIndex = -1\n # finding the maximum length and its index.\n for i in range(n):\n if (dp[i] > ans):\n ans = dp[i]\n lastIndex = i\n\n temp = []\n temp.append(arr[lastIndex])\n\n # creating the longest increasing subsequence by traversing\n # through the positions array.\n while(pos[lastIndex] != lastIndex):\n lastIndex = pos[lastIndex]\n temp.append(arr[lastIndex])\n\n return temp[::-1]\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def longestIncreasingSubsequence(self, N, arr):\n # Code here"
} | eJztmc1uXEUQhVnwIKVZR6ir/5snQYoRC/CCjcnCkSIhUB4i7LPLa+Z8NROEldyJ7Sh4Yo/lxdxx3e6qc079dPv19/+8s+/i56e3+vD8z93vVy9eXu9+tJ1fXHm6uGrmNq1Yt2HVsi3j290z212+enH56/Xlb7/88fL6wzsHQ4zs4upvGf71zG4umvV60VJdi01re1vXS17NtZubF/Nurm+meTZflre33C81D8vsl/j3Zd7c9KMRoGVCKsWyW0tW3Xqyqa+bZXk4LE/LMkhWFFzGslQrzUq3MqwImmX1CCKxwx1X23K5AF0iUIVVwkm924hZHyerg5c+FLYRGtomV/bQ3trjgAwk1aBJdpuus+J/l8Plyiob3jV5V5tVrV0DS4UyrUo24igDrSJTfEQZ3hB3DQxyLJ7YBYRGoNVwna0z5Chi0QmpI8JoQXYJDx1IltwdCkweEJb5ZmB7J9smzJ4UCWsm9A5IS3HYGqi1a4vVAK+iOv3NVo79HUdWwqO5cG1OfJwDZ2eAPxvuz0ocsxDQzEQ2nRBnaGUsgh6T6McAhtHBYzSAGRWERhAyMpgNB7yRQLGHlPsE1z4AuHeQ7g3IewX7XiChZ9joflC8+GkLotoM9kSahNUDpwaHrUJmK7DaMuC1bYAVjZGXLYrBh9z04Kp8OklhOAfb9c7ZgrJyqKzaQYAjpLf2fm7yjGJvCLXH+/WhFIuvgFuAuwUBYkKUiJsebIk28Scie1ArjkW2WB+hAwlCypBERohG6pGMpKcZCpPUpDmJb4YcpUsJVEpdoV2JGDFXxC2RS+wS/VqRBZ7wF5XL+6QgkmJJCikpsqQAk+yCYnKA8GRHsFHPZQcCAAEewJLRguwyaMhOyLkAdOHoUcTIH9kVmgGikV0BPNlRxgpFTHaFIkfZl50I84q6ZFfBWnaVrkIWyq5tF+m9Ss7IfzXkt2eBFOWWcAl6BAAtwCgBTFRUQQVgI8BrAWQJUKNmCmbAHgF8CxJKEBJVURRB1AjSWhBYgsyoe6IXkkcQ3oL8EkJwO6nC8Fh04ALWha8LZm80AqYXMKBLyk6EuHhx0eNiyTuzoOw6HYMeCmSyE60udl0ku7h2Ue5i3gcdltYiuwHCAC07ScUnw4zsov/Kjp5Md6ZP07Hp3XRx+vmiO8tOYnRp0iVNXzQrutWxce/x5Owj4epo9xeUihRHIA5gCZycVfD4BpdkMJksLHAVahmnye8Wk1ownZkRRYWQIhCI54laIOCICx3oqVMhhCNhIgumN+qGYCVqVFI4GpWYxgAB0RQmTbEq0MEEDcFxiiEvxWSJpkqcoBj5PGbOOE6hlRgAc0yjMYbFMWA/DoIpGiwxrzIc1phgoyqhhRgVW8y2UazgPAbHvp96+15Tg9oo0uEEDdc4PNQYSOEITdeYeqU6iQLO0LieJHOpUCKBQzSvJ8leqpRo4JQc0JPSQCqViOCYnNCT0qLGSAzn5EiN2Vkqlsjoo+RMXZs5+7EGvnJybTVD/R45teQ7Hqjz8RP1Fxypt8/UT2GirufB7qFG6jPsn5mn73Fz0ceNu4ueb319ET3/6dxg+BO9u6jlXGtPIunPtfakau1JXXd/4X33J/7N47f6P89mfbrFUPq/TaX3vGXy075mOt8zfct3F72er5q+Ibruf8300G2i+D0aBW8dLeyHyt765y8cEljfsrp/XNtvFPaf3/zwHkrQcWQ= |
704,354 | Trail of ones | Given a number n, find the number of binary strings of length n that contain consecutive 1's in them. Since the number can be very large, return the answer after modulo with 1e9+7.
Examples:
Input:
n = 2
Output:
1
Explanation:
There are 4 strings of
length 2, the strings are
00, 01, 10, and 11. Only
the string 11 has
consecutive 1's.
Input:
n = 3
Output:
3
Explanation:
There are 8 strings of length 3, the strings are 000, 001, 010, 011, 100, 101, 110 and 111. The strings with consecutive 1's are 011, 110 and 111.
Input:
n = 5
Output:
19
Explanation:
There are 19 strings
having consecutive 1's.
Constraints
2 <=
n
<= 10**5 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int numberOfConsecutiveOnes(int n)"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\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 int N = Integer.parseInt(read.readLine());\n\n Solution ob = new Solution();\n System.out.println(ob.numberOfConsecutiveOnes(N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n // Function to calculate power with modulo\n private static long power(long a, long b, long mod) {\n long ans = 1;\n while (b > 0) {\n if ((b & 1) == 1) {\n ans = (ans * a) % mod;\n }\n a = (a * a) % mod;\n b >>= 1;\n }\n return ans;\n }\n\n // Function to calculate the number of binary strings without consecutive ones\n static int numberOfConsecutiveOnes(int n) {\n long mod = 1000000007;\n if (n == 0) return 0; // Special case for n = 0\n\n long[] a = new long[n];\n long[] b = new long[n];\n a[0] = 1;\n b[0] = 1;\n\n // Generating the count of strings ending with 0 and strings ending with 1\n for (int i = 1; i < n; i++) {\n a[i] = (a[i - 1] + b[i - 1]) % mod;\n b[i] = a[i - 1];\n }\n\n // Subtracting the count of strings with consecutive ones from 2^N\n return (int)((power(2, n, mod) + mod - (a[n - 1] + b[n - 1]) % mod) % mod);\n }\n}",
"updated_at_timestamp": 1730474486,
"user_code": "// User function Template for Java\nclass Solution {\n static int numberOfConsecutiveOnes(int n) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"numberOfConsecutiveOnes(ob,n)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n\n ob = Solution()\n print(ob.numberOfConsecutiveOnes(N))\n\n print(\"~\")\n",
"solution": "class Solution:\n\n def power(self, a, b, mod):\n ans = 1\n while b > 0:\n if b & 1:\n ans *= a\n ans %= mod\n a *= a\n a %= mod\n b >>= 1\n return ans\n\n def numberOfConsecutiveOnes(self, n):\n mod = int(1e9 + 7)\n\n # If n is 1, then there are only two strings: \"0\" and \"1\"\n if n == 1:\n return 1\n\n a = [0] * n\n b = [0] * n\n a[0] = b[0] = 1\n\n # Generating the count of strings ending with 0 and strings ending with 1\n for i in range(1, n):\n a[i] = (a[i - 1] + b[i - 1]) % mod\n b[i] = a[i - 1]\n\n # Subtracting the count of strings with consecutive ones from 2^N\n return (self.power(2, n, mod) + mod -\n (a[n - 1] + b[n - 1]) % mod) % mod\n",
"updated_at_timestamp": 1730474486,
"user_code": "#User function Template for python3\nclass Solution:\n def numberOfConsecutiveOnes (ob,n):\n # code here \n "
} | eJydVEFuwyAQ7KH9h8U5imAXMOQlkUrVQ+tDL24U2VKiKFEekfy3gJ1GSCyOs/bBEswyszPm/Hrdv73EWm/9x/uB/bSbvmOrignXgmvZomLNbtN8dc3352/f3RdPfvG4qFIEkggkEIo+wxIQwUORuBqM1taEHVm4DUXzRA0SFarC4SRYo1BCa1kiToO5NRa4qHNoiG5MKB9cKeqH6NHECCKwOAiMxo16plgNPqbypkyC2/uQ5EwQ5zBUhtfhIZulVMg+4AVqiYbqM4q6J2G+rJHJLYguNnmaUOgh6LkYJbnVymQTmZmLG26Ap9gkwfQ7ePlneSCjgz5REgjSWqxl2fhcAFILnPh3xTOZY8jHZfkHw4qsbw== |
700,469 | Sort a stack | Given a stack, the task is to sortit such that the top of the stack has the greatestelement.
Examples:
Input:
Stack: 3 2 1
Output:
3 2 1
Input:
Stack: 11 2 32 3 41
Output:
41 32 11 3 2
Constraints:
1<=N<=100 | geeksforgeeks | Medium | {
"class_name": "GfG",
"created_at_timestamp": 1615292571,
"func_sign": [
"public Stack<Integer> sort(Stack<Integer> s)"
],
"initial_code": "import java.util.*;\nimport java.util.Scanner;\nimport java.util.Stack;\n\nclass SortedStack {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while (t-- > 0) {\n Stack<Integer> s = new Stack<>();\n int n = sc.nextInt();\n while (n-- > 0) s.push(sc.nextInt());\n GfG g = new GfG();\n Stack<Integer> a = g.sort(s);\n while (!a.empty()) {\n System.out.print(a.peek() + \" \");\n a.pop();\n }\n System.out.println();\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "SortedStack",
"solution": "/*package whatever //do not write package name here */\nclass GfG{\n\tpublic Stack<Integer> sort(Stack<Integer> s)\n\t{\n\t\t\tif (s.empty() == true) {\n\t\t\treturn s;\n\t\t}\n\n\t\t// Remove the top element\n\t\tint top = s.peek();\n\t\ts.pop();\n\t\t// Recursion for the remaining elements in the stack\n\t\tsort(s);\n\t\t// Insert the popped element back in the sorted stack\n\t\tsortedInsert(s, top);\n\t\treturn s;\n\t}\n\tpublic static void sortedInsert(Stack<Integer> stack, int current) {\n\t\tif (stack.empty() == true || current > stack.peek()) {\n\t\t\tstack.push(current);\n\t\t\treturn;\n\t\t}\n\n\t\t// Remove the top element\n\t\tint top = stack.peek();\n\t\tstack.pop();\n\t\t// Recursion for the remaining elements in the stack\n\t\tsortedInsert(stack, current);\n\t\t// Insert the popped element back in the stack\n\t\tstack.push(top);\n\t}\n}",
"updated_at_timestamp": 1730273345,
"user_code": "/*Complete the function below*/\nclass GfG {\n public Stack<Integer> sort(Stack<Integer> s) {\n // add code here.\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"Sorted(self, s)"
],
"initial_code": "if __name__ == '__main__':\n t = int(input())\n for i in range(t):\n n = int(input())\n arr = list(map(int, input().strip().split()))\n ob = Solution()\n ob.Sorted(arr)\n for e in range(len(arr)):\n print(arr.pop(), end=\" \")\n print()\n print(\"~\")\n",
"solution": "class Solution:\n def Sorted(self, s):\n # Sorts the given list of elements in ascending order\n return sorted(s)\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n # your task is to complete this function\n # function sort the stack such that top element is max\n # funciton should return nothing\n # s is a stack\n def Sorted(self, s):\n # Code here\n"
} | eJy1VMtKxEAQ9CD4G0XOi0z3vBK/RDDiQffgJXrYBUEUP0L/yps/ZE9vCLtmOxtfyQTCzFRVd3XPvBy/fZwc6XP+Lj8Xj9Vtd79eVWeofNtFGQjwYFDbhbYjB3bwDsG1XZKpCPYghg9oEKoFquXD/fJ6tby5uluveiYSvBeeiLZ7FpAyCI+wbSYEKwRCI2Sh31U9LbAVDbdd3XYsVLqLA1i0EziD6xJY+Rwah9ohOySHWMIcpIzYuFaKpHRBqUWANjFspVvYkjLXqlLE9sUpPlEsH0gyUm+ISqYNamQkDIYeNCvJ/lpwAi4UrHRCahqURTeDEnbVN3UkBIKnkhuZ2rsyhSn3TijQK0mkvQEE7YiR71q3qEnEMiM+y5KP2kKNjK++aB7fqOC4SEOXqRSrLGkIvXVjj+1yW0WWYVbQwLAqW42IKdx0v0zE6GzbzNykXRz610AP65OHILt/PAaF3E7g1/eFeWHMP/bZ/UHGheTA0R/ELeZp2HaVvMkhSzOcF9snEtwHclthWMAJQfrJQbRvaIo8t066df79bMimsS7bNYgj7WSJX76efgJrwwOR |
703,392 | Merge two binary Max heaps | Given two binary max heaps as arrays, merge the given heaps to form a new max heap.
Examples:
Input:
n = 4 m = 3
a[] = {10, 5, 6, 2},
b[] = {12, 7, 9}
Output:
{12, 10, 9, 2, 5, 7, 6}
Explanation:
| geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int[] mergeHeaps(int[] a, int[] b, int n, int m)"
],
"initial_code": "//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nclass GFG {\n \n public static boolean isMerged(int[] a, int[] b, int[] merged){\n if(a.length + b.length != merged.length)\n return false;\n \n int[] m = new int[merged.length];\n int i = 0;\n for(int e : a)\n m[i++] = e;\n for(int e : b)\n m[i++] = e;\n Arrays.sort(m);\n int[] mergedCopy = Arrays.copyOf(merged, merged.length);\n Arrays.sort(mergedCopy);\n if(!Arrays.equals(m, mergedCopy))\n return false;\n \n for(i = 1; i < merged.length; i++){\n if(merged[i] > merged[(i-1)/2])\n return false;\n }\n \n return true;\n }\n \n\tpublic static void main(String[] args) throws IOException\n\t{\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine().trim());\n while(t-->0)\n {\n StringTokenizer stt = new StringTokenizer(br.readLine());\n \n int n = Integer.parseInt(stt.nextToken());\n int m = Integer.parseInt(stt.nextToken());\n int a[] = new int[n];\n int b[] = new int[m];\n int merged[];\n \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 String inputLine1[] = br.readLine().trim().split(\" \");\n for (int i = 0; i < m; i++) {\n b[i] = Integer.parseInt(inputLine1[i]);\n }\n \n \n Solution obj = new Solution();\n int[] copyA = Arrays.copyOf(a, a.length), copyB = Arrays.copyOf(b, b.length);\n merged = obj.mergeHeaps(a, b, n, m);\n \n boolean flag = isMerged(copyA, copyB, merged);\n System.out.println(flag ? 1 : 0);\n \nSystem.out.println(\"~\");\n}\n\t}\n}\n\n",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\n\nclass Solution{\n \n public void maxHeapify(int[] arr, int n, int idx) {\n // if index is out of bounds, return\n if (idx >= n) return;\n \n // calculate left and right child indices\n int l = 2 * idx + 1;\n int r = 2 * idx + 2;\n \n int max;\n \n // find the maximum element between current element and its left child\n if (l < n && arr[l] > arr[idx])\n max = l;\n else\n max = idx;\n \n // find the maximum element between previous maximum and right child\n if (r < n && arr[r] > arr[max]) max = r;\n \n // if maximum element is not the current element, swap and recursively call maxHeapify\n if (max != idx) {\n int temp = arr[max];\n arr[max] = arr[idx];\n arr[idx] = temp;\n maxHeapify(arr, n, max);\n }\n }\n \n public void buildMaxHeap(int[] arr, int n) {\n // iterate from last non-leaf node to the root and call maxHeapify\n for(int i = n/2-1; i >= 0; i--)\n maxHeapify(arr, n, i);\n }\n \n public int[] mergeHeaps(int[] a, int[] b, int n, int m) {\n // create a merged array\n int[] merged = new int[n+m];\n \n // copy elements from array a to merged array\n for (int i = 0; i < n; i++) merged[i] = a[i];\n \n // copy elements from array b to merged array\n for (int i = 0; i < m; i++) merged[n + i] = b[i];\n \n // build max heap of merged array\n buildMaxHeap(merged, n + m);\n \n // return the merged array\n return merged;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution{\n public int[] mergeHeaps(int[] a, int[] b, int n, int m) {\n // your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1624248285,
"func_sign": [
"mergeHeaps(self, a, b, n, m)"
],
"initial_code": "# Initial Template for Python 3\n\ndef isMerged(arr1, arr2, merged):\n if len(arr1) + len(arr2) != len(merged):\n return False\n arr1 += arr2\n arr1.sort()\n mergedCopy = sorted(merged)\n if arr1 != mergedCopy:\n return False\n for i in range(1, len(merged)):\n if merged[i] > merged[(i-1)//2]:\n return False\n\n return True\n\n\nif __name__ == \"__main__\":\n for _ in range(int(input())):\n n, m = map(int, input().split())\n a = [int(i) for i in input().split()]\n b = [int(i) for i in input().split()]\n copyA = a[:]\n copyB = b[:]\n obj = Solution()\n merged = obj.mergeHeaps(a, b, n, m)\n flag = isMerged(copyA, copyB, merged)\n print(0 if flag == False else 1)\n\n print(\"~\")\n",
"solution": "class Solution():\n def heapify(self, a, n, i):\n parent = i # variable to store the parent index\n lchild = (2*i) + 1 # variable to store the left child index\n rchild = (2*i) + 2 # variable to store the right child index\n\n # check if the left child is within the range and greater than the parent element\n if lchild <= n-1 and a[lchild] > a[parent]:\n parent = lchild\n\n # check if the right child is within the range and greater than the parent element\n if rchild <= n-1 and a[rchild] > a[parent]:\n parent = rchild\n\n # if the parent element is not the largest, swap with the largest child and heapify the affected part\n if i != parent:\n a[parent], a[i] = a[i], a[parent]\n self.heapify(a, n, parent)\n\n def mergeHeaps(self, a, b, n, m):\n a += b # concatenate the two lists\n # heapify the combined list from the last non-leaf node to the first element\n for i in range(int(len(a)/2-1), -1, -1):\n self.heapify(a, len(a), i)\n return a # return the merged and heapified list\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution():\n def mergeHeaps(self, a, b, n, m):\n #your code here"
} | eJztmM+OHDUQxjnwFlxKe46QXXZ12zwJEoM4QA5cBg6JhIRAPAA34H35fdUmgUhLZoZdkSi72naPqtvlqu+rfzO/fPzHb598lH+f/8qHL368+/b8/csXd5/ZnZ/OYXE6t2JerBYLQ+Rhlf9mtdo4nTfbTudais1io9hebOPFcjrPsBG2h20oCesountmd89/+P751y+ef/PVdy9frHPq6fwzOnK9++mZ/dOEqqPXEdPmsLnb3Az1s9tsNt0me3X8tDFs7DY2HT26jWbDbfC4utVUVmQdDgVqcQVjcQ+HdmvGOybLed557nKVjbGZD6vdttfvXO+KjBB0unFi59LJQjZdfBNB62maL/f75H0u56pcZQoOXN6nbdNiGm/wgp7z6C0WvmFbg1YdpRvngW3FmAqIFYsqJFbMqjBZN6ElP+RDLD9i+RLLn1g+ydnS+eCHgyOZ68lZSbK2pMnT8WH7Znu33ROEYduW4eahG/ZxlgsS2Vplb1l2lmVfsVuwdZBzQQd2DnhehCEX6FbgreBbAfh6DpqO0Y2zANWxwgHVMcUB1bHHAdU3BWTY4WQsR2M5G8vhWE6HXUiSIg3wwxcqiuGNC1n3hRKyhqwha75QQ+bIHJn7QhFZRUYSKCMOVJEVZG8SfFFy3JcicRQPpWjHw46HHQ87HnY87HjY8bBvStHINO0g1nGmg1jHgQ5iHaM7iPUqrrmjr6Gvoa+hr6Gvoa+hr6GvqQ6gr6Gvoa8pQNDXxCD6Gvoa+loVo9wvY1Rx2/ngi9rBRTGBAYeBg2ZkMOAw4DBwUI4MBhwGHAYO+pHBgMOAw8ARCshgwGHAYeAIC1ghySpZVkmzI0SQkWmVVKvk2hEuyEi3Sr5VEu4IHWQbsg3Z5iuMkMXbOP23qq3cU/Ip+5R+R/1NQsrK4aKie29tZ//pPNRrUkksRbGUxVKosOnkX+/7ConGVQkJZG1XeNxYttFz1G4lSVZKJb/wu7rK/tUBEpZY0MSC537PDrgiIcOAqRID96DlwHUEIjEAYg5kDmZHYPIe3Dst0YeaWLyq81GODNNSMse0lMwyLSXzTEtaEGlG5pqWktmmpWS+aSmZcVqS3qSjiI9C2LPsWjYtSkdSgKVpcS1Vi/aJrdK0Q5yVph1K7NK0o2lH046mHa28irSpAFIEKYQUQwoiRZHCSHGkQFIkzaFI40VQmaAySd9JZkyGhUl2zMGL47IWf1/0r7q/5bQhkEMgh0AOgRwCOQRyCOQ46I7knEUgh0AOgRwCOQRyCOQQyFEzj44IuY5IaAnREqIlREuIlhAtIVpCtIRoCdESoiVES4iWEC0hWkK0hGgJ0RKiJURLqAiHa4drh2uHa4cqc7h2uHa4drh2eEYLjOYEkt0te3v2t+zw2eGyz2ePy26fXS57fg4j2flzHMn+nwNJTgE5kuQskENJVpyb8+8o5WWNGuXoVwIUV3FUbppgxEHcqzlqMBUMeg1txtRUOn2FlkI3ySlEWUrnMJV8NX+agKnsV/tbqTG131WDLFtwhv1NBe31TJXzRk5WOXHkfJUzR05ZOXXkrJVzR7r9QNxoIp85SmnaIGerKllVKauqZVXFrKqaVZWzqnpWVdCqKlpVSauqaVXdl0U7hnaov/nQDnU51/jm6nW+a4c6Hn36urr9gJP7q5nx1kn9Ub4QzSMQymN+/bnxy2R9yG+TT/PlQ82X/v8OmFcTmUPgo3PZxMI7Ref78X3hugJ76W8jD/XjyMXWacj9rz/e3NgTngbO92Pg3D/EifMpPp/i88b41AB/cXg+Rnz6BxKgM416itF3KEa//P3TPwGoqceU |
703,908 | Celsius to Fahrenheit Conversion | Given a temperature in celsius C. You have to convert it in Fahrenheit.
Examples:
Input:
C = 32
Output:
89.60
Explanation:
For 32 degree C temperature
in farenheit = 89.60
Input:
C = 25
Output:
77.00
Explanation:
For 25 degree C temperature
in farenheit = 77.
Constraints:
1 <= C <= 100000 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static double celciusToFahrenheit(int C)"
],
"initial_code": "import 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 int N = Integer.parseInt(read.readLine());\n Solution ob = new Solution();\n System.out.println(String.format(\"%.2f\", ob.celciusToFahrenheit(N)));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution{\n static double celciusToFahrenheit(int C) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"celciusToFahrenheit(self, C)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n\n ob = Solution()\n print('%.2f' % ob.celciusToFahrenheit(N))\n print(\"~\")\n",
"solution": "class Solution:\n # Function to convert Celsius to Fahrenheit\n def celciusToFahrenheit(self, C):\n f = ((C * 9.0) / 5.0) + 32 # conversion formula\n return f\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def celciusToFahrenheit (self, C):\n # code here"
} | eJytU8tOwzAQ5IDEF3DjUOVcRfvwxjZfgoQRB+iBi+mhlSohEB8B/4vj1Elbxa4rkUs3bXdmZ3b2+/r37uYqPg+3oXj8aN78ertp7heNOM/kPIVPBHDeWuu8QHia5aJZ7darl83q9fl9u9k3GNt24X9fzmvdwlARUirRMLQ01BaAxx+az+XigJedD99jT68zTFOv2FRZk9hP8FSYQvMwesCNavIihLhVaciJh7k1SUZh9uAXUuBS0mmTYSAZGQyRUHo5geqieYG5V6UEe62hYogytOQlKORkRWcgTWrUJAGsGg1UB2qQJa+tdy63jxF6pqfk9jkzrY2pO48xJquIyHH/MlhYBJ0UHUW1iI77eavmnOnFQm8nXbb3KHSFLR0Hj1hnljYdYOUG5s6R5fw5Zi7z4iu1yZjM8RZzlVdbn7hg5fwRx7UW96owv9gUitoF9ykB1FXG44Hzzs14f5nzxFXW4wBfeXqXJkcB+P/PztNP+wc88xW3 |
702,962 | Common Subsequence | Given two strings a and b. Checkwhether they contain any common subsequence (non empty)or not.
Examples:
Input:
a = "ABEF" b = "CADE"
Output:
1
Explanation:
Subsequence "AE" occurs
in both the strings.
Input:
a = "ABCD", b = "EFGH"
Output:
0
Explanation:
There's no common subsequence
in both the strings.
| geeksforgeeks | Easy | {
"class_name": "Sol",
"created_at_timestamp": 1615292571,
"func_sign": [
"Boolean commonSubseq(String a, String b)"
],
"initial_code": "\nimport java.io.*;\nimport java.util.*;\nclass GfG\n{\n public static void main (String[] args)\n {\n \n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n String a = sc.next ();\n String b = sc.next ();\n \n if (new Sol().commonSubseq(a, b))\n System.out.println (1);\n \n else\n System.out.println (0);\n \t\t \n \nSystem.out.println(\"~\");\n}\n \n }\n}\n\n// Contributed By: Pranay Bansal\n\n",
"script_name": "GfG",
"solution": "class Sol {\n // Function to check if there is a common subsequence between two strings.\n Boolean commonSubseq(String a, String b) {\n // Boolean array to store the presence of each character in string a.\n Boolean[] f1 = new Boolean[26];\n for (int i = 0; i < 26; i++) f1[i] = false;\n // Marking the presence of each character in string a.\n for (int i = 0; i < a.length(); ++i) f1[(int) (a.charAt(i) - 'A')] = true;\n // Checking if any character in string b is present in string a.\n for (int i = 0; i < b.length(); ++i) if (f1[(int) (b.charAt(i) - 'A')]) return true;\n // Returning false if no common subsequence is found.\n return false;\n }\n}\n// Contributed By: Pranay Bansal\n",
"updated_at_timestamp": 1730469538,
"user_code": "\nclass Sol\n{\n Boolean commonSubseq (String a, String b)\n {\n // your code here \n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"commonSubseq(self, a, b)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n for tc in range(t):\n a, b = input().split()\n ob = Solution()\n if ob.commonSubseq(a, b):\n print(1)\n else:\n print(0)\n\n# Contributed By: Pranay Bansal\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def commonSubseq(self, a, b):\n f1 = [0 for i in range(26)]\n for i in a:\n f1[ord(i) - ord('A')] = 1\n\n for i in b:\n if f1[ord(i) - ord('A')] == 1:\n return True\n\n return False\n\n # Contributed By: Pranay Bansal\n",
"updated_at_timestamp": 1730469538,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef commonSubseq(self, a, b):\n\t\t# your code here"
} | eJzFVctOhDAUdWHibzRdT4xu3VFa3u83qHGhLNzgLJjExJj4Efo57vwwr0KGKTMwlEg8G5pCzz09Pbe8nX58nZ38IvuEwfULfqzWmxpfIXx5U0lEpkxRNd0wLdtxPT8IozhJs7xAw6/wCuHyeV3e1+XD3dOm7ujw6wr1CiBRmouDNMM6izxLkzgKA99zHdsyDV1TFUZlIgnp5IEIjzlaeamgdF98ty0RrdxCjhLBpNCud2nQ7NOxHZLIWQHeg/UUea4e51HAUl8KaWNEkckJcWwRbX7KgiiPdddreUOpZUHtczvffSp65D9nKwMogAEUAFIBGkAHGAATYAFswPwgDEd4gYg0q/6pdusrRzXBZHrU5SOdS7atC/VBOAyqpn2loQYe7QoR74o/PbgDHTnjulQ0VVswXdMMGr4MFowdG8+duRe8WckjvZJ0Ws3dgr3fzHj92/fzb3MXWpU= |
702,779 | Count pair sum | Given two sorted arrays arr1 and arr2 of distinct elements. Given a value x. The problem is to count all pairs from both arrays whose sum equals x.Note: The pair has an element from each array.
Examples:
Input:
x = 10, arr1[] = [1, 3, 5, 7], arr2[] = [2, 3, 5, 8]
Output:
2
Explanation:
The pairs are: (5, 5) and (7, 3).
Input:
x = 5, arr1[] = [1, 2, 3, 4], arr2[] = [5, 6, 7, 8]
Output:
0
Explanation:
There are no valid pairs.
Constraints:
1 ≤ x ≤ 10**9
1 ≤ arr1.size(), arr2.size() ≤ 10**6
1 ≤ arr1[i], arr2[i] ≤ 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int countPairs(int arr1[], int arr2[], int x)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass Main {\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 int sum = Integer.parseInt(read.readLine());\n ArrayList<Integer> array1 = new ArrayList<Integer>();\n ArrayList<Integer> array2 = new ArrayList<Integer>();\n\n String line = read.readLine();\n String[] tokens = line.split(\" \");\n for (String token : tokens) {\n array1.add(Integer.parseInt(token));\n }\n line = read.readLine();\n tokens = line.split(\" \");\n for (String token : tokens) {\n array2.add(Integer.parseInt(token));\n }\n\n int[] arr1 = new int[array1.size()];\n int idx = 0;\n for (int i : array1) arr1[idx++] = i;\n\n int[] arr2 = new int[array2.size()];\n idx = 0;\n for (int i : array2) arr2[idx++] = i;\n\n int res = new Solution().countPairs(arr1, arr2, sum);\n\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "Main",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n // function to count all pairs\n // from both the sorted arrays\n // whose sum is equal to a given\n // value\n static int countPairs(int arr1[], int arr2[], int x) {\n int m = arr1.length;\n int n = arr2.length;\n int count = 0;\n int l = 0, r = n - 1;\n // traverse 'arr1[]' from\n // left to right\n // traverse 'arr2[]' from\n // right to left\n while (l < m && r >= 0) {\n // if this sum is equal\n // to 'x', then increment 'l',\n // decrement 'r' and\n // increment 'count'\n if ((arr1[l] + arr2[r]) == x) {\n l++;\n r--;\n count++;\n }\n // if this sum is less\n // than x, then increment l\n else if ((arr1[l] + arr2[r]) < x) l++;\n // else decrement 'r'\n else r--;\n }\n // required count of pairs\n return count;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n\n // function to count all pairs\n // from both the sorted arrays\n // whose sum is equal to a given\n // value\n static int countPairs(int arr1[], int arr2[], int x) {\n // code here.\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"countPairs(self,arr1, arr2, x)"
],
"initial_code": "# Initial Template for Python 3\nimport io\nimport sys\n\n# Contributed by : Nagendra Jha\n\nif __name__ == '__main__':\n test_cases = int(input())\n for cases in range(test_cases):\n x = int(input())\n arr1 = list(map(int, input().strip().split()))\n arr2 = list(map(int, input().strip().split()))\n ob = Solution()\n l = ob.countPairs(arr1, arr2, x)\n print(l)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n\n def countPairs(self, arr1, arr2, x):\n m = len(arr1)\n n = len(arr2)\n count, l, r = 0, 0, n - 1\n\n # traverse 'arr1[]' from left to right\n # traverse 'arr2[]' from right to left\n while (l < m and r >= 0):\n # if this sum is equal to 'x', then increment 'l',\n # decrement 'r' and increment 'count'\n if ((arr1[l] + arr2[r]) == x):\n l += 1\n r -= 1\n count += 1\n # if this sum is less than x, then increment l\n elif ((arr1[l] + arr2[r]) < x):\n l += 1\n # else decrement 'r'\n else:\n r -= 1\n\n # required count of pairs\n return count\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def countPairs(self,arr1, arr2, x):\n #code here.\n"
} | eJztVkuOEzEQZcGSQzxlPUIul+tjToJEEAvIgk2YRUZCQiAOAVdix52obrt7EkIDCRnNgnErfpV2ubp+ft2fH3/9/uTROJ5/C+HFh9Xb7fXNbvUMK1pvKY1jvZV9jIXVFVab99eb17vNm1fvbnZ9S2h8isWPV/jZTvxwdK23FUfXonFatj65WduIW8tWfm9k3DpZOdsEGAKLaCiiZJCADFSRCZmRBdmQKzgUGSxgA1cUQmEUQTGUCiFI2BGIQSqUoAwVqEErjGAMi8cYrMIJznCBGzyySKiMKqjhRUSSUaBwUAJlUAEpyJETckYuyIrs4ATO4AJWsKMklNhYUBTFIQmSIQWiEIcmaIaGXYU6LMEyrMAU5vAEz/ACj8c6akLNqAVVUQc30sk9NJcW4WKEE4mIFPuQ5F75Ie4BvIE10AbSoDTgBrkBNTjdp3xb8V85Rc1nNPSO1lE7SsfSkTvmjtRx2b3FhsxcRG0S0P5inKO8wxxtNsyDs20MqYiQoo/MY9V01FVphk7NzwFvRMM0sAbeoHadnsyItmNfp65O2hXPO5atTl1CngSehDIJskcn073qs2SzpLN0u+VSFbKzSzQ7eDJHP7DXxF53QF+Lr8DWQWjcNXLRH9+E9u8UWfY58pgkjU8PcOhdPuplOW7mO2ve4pf4VDmgrFs7pA8HavFAte45OFaXPj5LybyH1/C59Qu//uMKzvzQqMH+nhvSaeTw8svTHzoK/jI= |
703,472 | Construct binary palindrome by repeated appending and trimming | You are given two integers n and k. Your task is to create a palindrome of length n using binary numbers (0s and 1s) of length k that starts with 1. You can repeat the binary number as many times as you need, and you are allowed to remove any zeros from the end of the final palindrome.
Examples:
Input:
n = 5, k = 3
Output:
11011
Explanation:
Since only length of 3 binary digits are allowed, so the possible binary representations are 100, 110, 111, 101. Out of these, If we take the binary representation of 6(110), combine it twice & trim a zero the final output will be 11011, which satisfy all the conditions
Input:
n = 6, k = 1
Output:
111111
Explanation:
The binary representation of 1 is 1 of length 1, it is combined six times to produce 111111.
Constraints:
1 ≤ n, k ≤ 10**6 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1713950908,
"func_sign": [
"public static String binaryPalindrome(int n, int k)"
],
"initial_code": "import 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;\n t = Integer.parseInt(br.readLine());\n while (t-- > 0) {\n\n int n;\n n = Integer.parseInt(br.readLine());\n\n int k;\n k = Integer.parseInt(br.readLine());\n\n Solution obj = new Solution();\n String res = obj.binaryPalindrome(n, k);\n\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n private static void dfs(int parent, int[] ans, List<Integer>[] connectChars) {\n ans[parent] = 1;\n for (int i = 0; i < connectChars[parent].size(); i++) {\n if (ans[connectChars[parent].get(i)] == 0)\n dfs(connectChars[parent].get(i), ans, connectChars);\n }\n }\n\n public static String binaryPalindrome(int n, int k) {\n int[] arr = new int[n];\n int[] ans = new int[n];\n List<Integer>[] connectChars = new List[k];\n // Initialize connectChars lists\n for (int i = 0; i < k; i++) {\n connectChars[i] = new ArrayList<>();\n }\n // Assign characters in the array according to the pattern\n for (int i = 0; i < n; i++) arr[i] = i % k;\n // Connect characters in the connectChars array\n for (int i = 0; i < n; i++) {\n connectChars[arr[i]].add(arr[n - i - 1]);\n connectChars[arr[n - i - 1]].add(arr[i]);\n }\n // Run dfs on the connected characters to mark them with 1 in the ans array\n dfs(0, ans, connectChars);\n // Create the binary palindrome string using the ans array\n StringBuilder sb = new StringBuilder();\n for (int i = 0; i < n; i++) {\n sb.append(ans[arr[i]] == 1 ? '1' : '0');\n }\n // Return the binary palindrome string\n return sb.toString();\n }\n}\n",
"updated_at_timestamp": 1730471064,
"user_code": "\nclass Solution {\n public static String binaryPalindrome(int n, int k) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1713950908,
"func_sign": [
"binaryPalindrome(self, n : int, k : int) -> str"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n n = int(input())\n k = int(input())\n obj = Solution()\n res = obj.binaryPalindrome(n, k)\n print(res)\n print(\"~\")\n",
"solution": "class Solution:\n def dfs(self, parent, ans, connectChars):\n ans[parent] = 1\n for i in connectChars[parent]:\n if not ans[i]:\n self.dfs(i, ans, connectChars)\n\n def binaryPalindrome(self, n, k):\n arr = [i % k for i in range(n)]\n ans = [0] * n\n connectChars = [[] for _ in range(k)]\n\n # Connect characters in the connectChars array\n for i in range(n):\n connectChars[arr[i]].append(arr[n - i - 1])\n connectChars[arr[n - i - 1]].append(arr[i])\n\n # Run dfs on the connected characters to mark them with 1 in the ans array\n self.dfs(0, ans, connectChars)\n\n # Create the binary palindrome string using the ans array\n s = \"\".join([\"1\" if ans[arr[i]] == 1 else \"0\" for i in range(n)])\n\n # Return the binary palindrome string\n return s\n",
"updated_at_timestamp": 1730471064,
"user_code": "\nclass Solution:\n def binaryPalindrome(self, n : int, k : int) -> str:\n # code here\n \n"
} | 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 |
702,910 | Sort The Array | Given a random arrayarrof numbers, please return them in ascending sorted order.
Examples:
Input:
arr[] = [1, 5, 3, 2]
Output:
[1, 2, 3, 5]
Explanation:
After sorting array will be like [1, 2, 3, 5].
Input:
arr[] = [3, 1]
Output:
[1, 3]
Explanation:
After sorting array will be like [1, 3].
Constraints:
1 ≤ arr.size, arr[i] ≤ 10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1728621107,
"func_sign": [
"void sortArr(int[] arr)"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n int t = Integer.parseInt(scanner.nextLine().trim());\n\n while (t-- > 0) {\n String line = scanner.nextLine().trim();\n String[] numsStr = line.split(\" \");\n int[] nums = new int[numsStr.length];\n for (int i = 0; i < numsStr.length; i++) {\n nums[i] = Integer.parseInt(numsStr[i]);\n }\n\n Solution obj = new Solution();\n obj.sortArr(nums);\n for (int x : nums) {\n System.out.print(x + \" \");\n }\n System.out.println();\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1730272810,
"user_code": "// User function Template for Java\nclass Solution {\n void sortArr(int[] arr) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1728621107,
"func_sign": [
"sortArr(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n arr = list(map(int, input().strip().split()))\n obj = Solution()\n obj.sortArr(arr)\n for i in arr:\n print(i, end=\" \")\n print()\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\ndef main():\n pass\n\n# defining the Solution class\n\n\nclass Solution:\n # sorting the array\n def sortArr(self, arr):\n arr.sort() # using the list's sort method to sort the array\n\n\nif __name__ == \"__main__\":\n main()\n",
"updated_at_timestamp": 1730272810,
"user_code": "#User function Template for python3\nclass Solution:\n def sortArr(self, arr): \n #code here"
} | eJy9VbFu3DAM7dAlWz7hwXMQ2JJs2fmSAr0iQ3tDl2uGCxAgSJCPSP43Ip+M46Wlrr2hHGjJIt8jJZF6+fx2efFJ5ctFGXx97H7u7u733Q26YbNbRDCLIItgEsEogiSCKIIggkEEfXeFbvtwt/2+3/64/XW/r4B9Xact/YhBPGKTh5zk3+yeN7vu6QrHwY2ImDEhYEHGgNQiLlaFDIWk2BZgD3QIMY0YUwwDpjwvPZY5T4UqjVNGGaWSq0wgw4Bq7RDXVRCVfkSqDIpBHmKTzQuuFynJjPrl7shPZPmDINoJZaChmlR/Oh1QysQjPuvc7F4yL2Zq9tILVvnqrhlWelZuxbUR2H08ika5m3eppk8bUcwhq55UEyGpjqqD6sHJQdeMXTT+o8HNhu/UOfDckuqoOvBGqF6/wazTVv384jAY4TcEi2PQqj6xn6pn3jbVk/F18vDuRCu3ipsN33JA9MPE0cETiiXC4hhkgigTTDqeZezXmNoQgV41PP1PTEX4u7Jzefzu1Whf8WP/0qvocNDIItkGVYkq7ArVbKpeLlrkjqP//jR6/b+/JNpumq2oVY9+buvyH929BBptv//vfV+PefGPTlbPfko1mvUhTe2XVK6emhDVe0TJcMD2zs1jWR2+vV6/A6s6M/A= |
701,989 | Rotate by 90 degree | Given a squarematrix[][]. The task is to rotate it by 90 degrees in an clockwise direction without using any extra space.
Examples:
Input:
mat[][] = [[1 2 3], [4 5 6], [7 8 9]]
Output:
7 4 1
8 5 2
9 6 3
Input:
mat[][] = [1 2], [3 4]
Output:
3 1
4 2
Input:
mat[][] = [[1]]
Output:
1
Constraints:
1 ≤ mat.size() ≤ 1000
1<= mat[][] <= 100 | geeksforgeeks | Medium | {
"class_name": "GFG",
"created_at_timestamp": 1729172254,
"func_sign": [
"static void rotate(int mat[][])"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass DriverClass {\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[][] arr = new int[n][n];\n\n for (int i = 0; i < n; i++)\n for (int j = 0; j < n; j++) arr[i][j] = sc.nextInt();\n\n GFG g = new GFG();\n g.rotate(arr);\n printMatrix(arr);\n\n System.out.println(\"~\");\n }\n }\n\n static void printMatrix(int arr[][]) {\n for (int i = 0; i < arr.length; i++) {\n for (int j = 0; j < arr[0].length; j++) System.out.print(arr[i][j] + \" \");\n System.out.println(\"\");\n }\n }\n}",
"script_name": "DriverClass",
"solution": "class GFG {\n static void rotate(int mat[][]) {\n // Code Here\n int n = mat.length;\n\n // Reverse Columns\n for (int i = 0; i < n/2; i++) {\n for (int j = 0; j < n; j++) {\n int temp = mat[i][j];\n mat[i][j] = mat[n - i - 1][j];\n mat[n - i - 1][j] = temp;\n }\n }\n\n // Perform Transpose\n for (int i = 0; i < n; i++) {\n for (int j = i+1; j < n; j++) {\n int temp = mat[i][j];\n mat[i][j] = mat[j][i];\n mat[j][i] = temp;\n }\n }\n \n }\n}",
"updated_at_timestamp": 1730828185,
"user_code": "// User function Template for Java\n\nclass GFG {\n static void rotate(int mat[][]) {\n // Code Here\n }\n}"
} | {
"class_name": null,
"created_at_timestamp": 1729172254,
"func_sign": [
"rotate(mat)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n matrix = []\n for i in range(N):\n arr = [int(x) for x in input().strip().split()]\n matrix.append(arr)\n\n rotate(matrix)\n for i in range(N):\n for j in range(N):\n print(matrix[i][j], end=' ')\n print()\n print(\"~\")\n",
"solution": "def rotate(matrix):\n n = len(matrix)\n\n # Step 1: Transpose the matrix\n for i in range(n):\n for j in range(i + 1, n): # Start from i + 1 to avoid self-swap\n matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]\n\n # Step 2: Reverse each row\n for i in range(n):\n matrix[i].reverse()\n",
"updated_at_timestamp": 1730828185,
"user_code": "#User function Template for python3\n\ndef rotate(mat): \n #code here"
} | eJztmM1uHUUUhFkgdmxZl+46QtP/3TwJEkEswAs2JgtHQoqCeAh4X+rrGcLYvnPjmCTCQCZj9XVXd59TdX5u+9dPf//8i0/mv68/8+CbV6cfr1+8vDl9pVN4fh0Wv4pKyiqqauoamr8NClEhKWSFolAVmkJXGIqejl4VFZNiViyKVbEpdsWh5OkUlLxrUspKRakqNaWuNJQ9nYNyVPapWbkoV+Wm3JWHiqdLUIkqScVWFZWq0lS6ylD1dA2qUTWpZlVbXVWbalcdap5uQS2qJbWsVtTsVVPrakPd0z2oR/WkntWLelW31119aHh6BI2okTSyRtGoGk3DrEDLcnqm09XPL66+v7n64bufXt5sTHqRt/XBNs3G2z0TYIogUd4zcqSNstl2zK6bHNNngiPTCXNssF2y06bFxJlak5+YzphqZ+yuCTFlJtW0W5jMdMENO2oqTJbpNOGWxKIVpisumgTTZCJNtcWwXBa0Mt1w3wSZQpNsGSyUpbTYjekONSbP9FoAS2QRLbMDoTM9oM3EmnqLY/kssEPAQTJEdC3m1KxbFytnba2+48MRZDIN+OX59en1M92OyUJIbs+7DA+0eTOvHfaB47P2pZ1jjrbNMwf15tqBHXmywEpvMRcNhnHS0g/ZyJwGYWmZqVPm0rYePtYNgxGBrAwGBR8UjAr1yBJQYx47RZgLlrltnJ/LumObZ/pznbtjYz40k/+HAhysiSuRcaFgLOx+ZDGzK3N5XXAxdrZy5kJxWM/w6lJBO7CDlK5kdZ3hQQo3tm0zj0nZzhF95i0pOjhuzDylSi6zlC4zMc/TeFyPrZk/OFE94RJgUHhq2KMAWUi3Mz8c4F5293UJ18rx/nUm+pi7LzFQdPd1nNz7HcXw/npq4P2zKH337Rpr8TjvzCW9/0pv7bJba3ITuWv+3Uluh55f48LYciiyk4GRMmRgNDCS1QZGA+PgmNmdPeBMAxNly8BkYCLlDUxjJiN92gMDM9YZmKngBmYDM/VglpHZsT2glBlY8MPAQl00sBhYBo7N3u2BgZUSaGDFYwMrddTAOnB/dnEPDGwGNmqngQ1uDGx0lFl/Zz/3gPJkYDewU04N7LBoYB9QOTu7BwYOyp+Bw8BBGTZwwPdK+HGP914YhQe4CzcQCethK8LL7ParQViPq/ACiTCOPGg5Cy2GYDUuwgfkwTSyoCGCzwqMtbgGD5AGw8iBdghNVMzSjEv4D1kwiwxohsBEA6FTJrCuJMEo9KMVwhIFhAzxVSewrUxCOxohKOoTKsQVQdgmsK90ow1CojohQjwRfETq7HLQjCYIiNqEBnFE0BGhYWydES1QDpmJCQKIaCM0iePZB8JxL2j7Xj6/KvB1681DYu8esn/3UCJ2D3Vk91Bsds9BxNyqfbNAfdjPH5+FFB/CA6gnysRbqHiyXKzfKm9/rVz+kd8rP2aD9AYP7ZH/4i4Zl61RLo/ulHOL/5vlY5rlu7TLLV7fW8c8cyGzCw+5k+HphWvZ/Stzw8T0iGvzXPjnzTldvDpfuKgvH+CmvmdP7+k++9Tug0T/f/tKCAN/91aYZvN89J+Y8tsi99vfvvwD9i6+0g== |
712,536 | Insert Interval | Geek has an array ofnon-overlapping intervalsintervalswhereintervals[i] = [starti, endi]represent the start and the end of thei**thevent andintervalsis sorted in ascending order bystarti. He wants to add a new interval newEvent =[newStart, newEnd]where newStart and newEnd represent the start and end of this interval.
Examples:
Input:
intervals = [[1,3], [10,15], [20,30]], newEvent = [5,6]
Output:
[[1,3], [5,6], [10,15], [20,30]]
Explanation:
The newEvent (5, 6) does not overlap with any of the existing ranges, hence it is added
to the intervals list maintaining the sorted order of start times.
Input:
intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newEvent = [5,10]
Output:
[[1,2], [3,10], [12,16]]
Explanation:
Because the new interval [5,10] overlaps with [3,5],[6,7],[8,10].
Constraints:
1 ≤ intervals.size() ≤ 10**4
0 ≤ start[i], end[i]≤ 10**9 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1666857631,
"func_sign": [
"static ArrayList<int[]> insertInterval(int[][] intervals, int[] newInterval)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.math.*;\nimport java.util.*;\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 a[][] = new int[n][2];\n for (int i = 0; i < n; i++) {\n a[i][0] = sc.nextInt();\n a[i][1] = sc.nextInt();\n }\n int h[] = new int[2];\n h[0] = sc.nextInt();\n h[1] = sc.nextInt();\n sc.nextLine();\n Solution obj = new Solution();\n ArrayList<int[]> ans = obj.insertInterval(a, h);\n System.out.print(\"[\");\n for (int i = 0; i < ans.size(); i++) {\n System.out.print(\"[\");\n System.out.print(ans.get(i)[0] + \",\" + ans.get(i)[1]);\n System.out.print(\"]\");\n if (i != ans.size() - 1) System.out.print(\",\");\n }\n System.out.println(\"]\");\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1731143633,
"user_code": "// User function Template for Java\n\nclass Solution {\n static ArrayList<int[]> insertInterval(int[][] intervals, int[] newInterval) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1666733333,
"func_sign": [
"insertInterval(self, intervals, newInterval)"
],
"initial_code": "# Initial Template for Python 3\n\n# Position this line where user code will be pasted.\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n intervals = [list(map(int, input().split())) for i in range(N)]\n newEvent = list(map(int, input().split()))\n ob = Solution()\n res = ob.insertInterval(intervals, newEvent)\n print('[', end='')\n for i in range(len(res)):\n print('[', end='')\n print(str(res[i][0])+','+str(res[i][1]), end='')\n print(']', end='')\n if i < len(res)-1:\n print(',', end='')\n print(']')\n print(\"~\")\n",
"solution": "class Solution:\n\n # Function to insert and merge intervals\n def insertInterval(self, intervals, newInterval):\n res = []\n i = 0\n n = len(intervals)\n \n # Add all intervals that come before the new interval\n while i < n and intervals[i][1] < newInterval[0]:\n res.append(intervals[i])\n i += 1\n \n # Merge all overlapping intervals with the new interval\n while i < n and intervals[i][0] <= newInterval[1]:\n newInterval[0] = min(newInterval[0], intervals[i][0])\n newInterval[1] = max(newInterval[1], intervals[i][1])\n i += 1\n \n res.append(newInterval)\n \n # Add all the remaining intervals\n while i < n:\n res.append(intervals[i])\n i += 1\n \n return res\n",
"updated_at_timestamp": 1731146858,
"user_code": "#User function Template for python3\n\nclass Solution:\n def insertInterval(self, intervals, newInterval):\n # Code here"
} | eJytlM1OhDAQxz0Yn2Pk5GHWdKa0gE9i0hIPysFL3QObmBiND6HvawfWGBM7wEYukAC//j/aeT//vLo4m67by/wQXqrHtD+M1Q1UFJOJyUFTIVTD8364H4eHu6fDeHwfgsOm72N6i6l6Rfj9q4uJgGNisDFZqGOqwQnOZyz4ItOgLzKtMDPEA2VlxEBOYGwUGpttODJAXOQRuh6DR3JFan00bmd0E1M78VkxTTlIDC1SWaxEOutUBTokLjJYpFlR1Yket2izW+eyFR4RUGZ3QLXC5cy1Ez27rTW3Bma5SrdWq9aAhAViW0g7DbUjhVUuVNhaqT9m/ULBpR28Rg2dKocUPRm7WtJ32LwlbQxMSHLD8oZVo59W/Kf8/54Gy9Mlf7N5vHiSjb08Y7xykmc2nwIvYs107KTMcvX9x/UX67jSnQ== |
701,313 | Minimum indexed character | Given a stringstrand another stringpatt. Find the minimum index of the character in strthat is also present inpatt.
Examples:
Input:
str = geeksforgeeks
patt = set
Output:
1
Explanation:
e is the character which is
present in given str "geeksforgeeks"
and is also present in patt "set". Minimum
index of e is 1.
Input:
str = adcffaet
patt = onkl
Output:
-1
Explanation:
There are none of the
characters which is common in patt
and str.
Constraints:
1 ≤ |str|,|patt|≤ 10**5
'a' <= str
i
, patt
i
<= 'z' | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1619239298,
"func_sign": [
"public static int minIndexChar(String str, String patt)"
],
"initial_code": "import java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\n//Position this line where user code will be pasted.\n\nclass GFG {\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 t--;\n\t\t \n\t\t String s1=sc.next();\n\t\t String s2=sc.next();\n\t\t \n\t\t int res = new Solution().minIndexChar(s1, s2);\n\t\t System.out.println(res);\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n}\n",
"script_name": "GFG",
"solution": "// Backend complete function template for JAVA\n\nclass Solution {\n // Function to find the minimum indexed character.\n public static int minIndexChar(String s1, String s2) {\n // using a map as hash table to store first index of all characters.\n HashMap<Character, Integer> hm = new HashMap<>();\n int minIndex = Integer.MAX_VALUE;\n\n int m = s1.length();\n int n = s2.length();\n\n // storing first index of each character of string \"s1\" in hash table.\n for (int i = 0; i < m; i++)\n if (!hm.containsKey(s1.charAt(i))) hm.put(s1.charAt(i), i);\n\n // iterating over the second string \"s2\".\n for (int i = 0; i < n; i++) {\n // if current character of string \"s2\" is found in hash table,\n // we check if it has the minimum index or not.\n if (hm.containsKey(s2.charAt(i)) && hm.get(s2.charAt(i)) < minIndex) {\n // updating minimum index.\n minIndex = hm.get(s2.charAt(i));\n }\n }\n\n // returning the minimum indexed character or -1 if no\n // character of \"s2\" is present in \"s1\".\n if (minIndex != Integer.MAX_VALUE)\n return minIndex;\n else\n return -1;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function template for JAVA\n\nclass Solution\n{\n //Function to find the minimum indexed character.\n public static int minIndexChar(String str, String patt)\n {\n // Your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619239298,
"func_sign": [
"minIndexChar(self,Str, pat)"
],
"initial_code": "import atexit\nimport io\nimport sys\n\n_INPUT_LINES = sys.stdin.read().splitlines()\ninput = iter(_INPUT_LINES).__next__\n_OUTPUT_BUFFER = io.StringIO()\nsys.stdout = _OUTPUT_BUFFER\n\n\n@atexit.register\ndef write():\n sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())\n\n\nif __name__ == '__main__':\n t = int(input())\n for i in range(t):\n s = str(input())\n p = str(input())\n obj = Solution()\n ans = obj.minIndexChar(s, p)\n print(ans)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n\n # Function to find the minimum indexed character.\n def minIndexChar(self, st, patt):\n\n # using a map as hash table to store first index of all characters.\n um = {}\n minIndex = sys.maxsize\n\n m = len(st)\n n = len(patt)\n\n # storing first index of each character of string \"st\" in hash table.\n for i in range(m):\n if (st[i] not in um):\n um[st[i]] = i\n\n # iterating over the second string \"patt\".\n for i in range(n):\n # if current character of string \"patt\" is found in hash table,\n # we check if it has the minimum index or not.\n if (patt[i] in um and um[patt[i]] < minIndex):\n # updating minimum index.\n minIndex = um[patt[i]]\n\n # returning the minimum indexed character or -1 if no\n # character of \"patt\" is present in \"st\".\n if (minIndex != sys.maxsize):\n return minIndex\n else:\n return -1\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to find the minimum indexed character.\n def minIndexChar(self,Str, pat): \n #code here"
} | eJztV9tOg0AQ9cEP8BManiuh4P1LTFxjuBbaMqClFmo0foTGN7/V2aW21DJLKTaVxAnpbsMyZ+bM2cnu6+H759GBsOsPnNw8KQHEk0S56igGA5OyGb5jYMkMl/BHZuhE6XYUN41dO3Gdu2iSzLE1Bi8M9EsxHPfEoDx3O4XwdAZpNqMeAR5CFN8/jMMEfxmMk8kjAacLgLMymBMM0rId1+v7wWA4mrtEV1NEod8gfpZK02dgW+Yixvwz4Y8B91hCfgWXMyo5o8jifOidE5xKkkXLY8NXIrU0tyzDf2lGwJ8KII2CMy3Lth3HdT2v3/f9IBgMhsPRKAwBoihmP0lFnCwVEyrbCxrPkKVXIs4K+easEz650ykPmdKcVohT18vC7Uk2oNRoLZBbqSpRSaacPQaONE2jUm27m620gmYD+pETS8ucm6qqiwLx7rBsltjL8DOpa7J0JmxCZP1M68SoVYQoT/9X9NeMwxXSGrVBt1FXa+8OkElgD40XmnTeuoowGBMrWnRY2JhI5LG+4PctQ7IPYzBmnbJ6/3VtQ10pQhp18uLqdjQ9rOn2TW9537PWj5Qcu/LGZ61f+ZqcYUs42v66uNtqtIE7UjF/9lr0vdtv39QvCISjaQ== |
705,546 | Satisfy the equation | Given an array A[ ] of N of integers, find the distinct index of values that satisfy A + B = C + D where A,B,C & D are integers values in the array.Note: As there may be multiple pairs satisfying the equation return lexicographically smallest order ofA, B, C and D and returnall as -1 if there are no pairs satisfying the equation.
Examples:
Input:
N =
7
A[] =
{3, 4, 7, 1, 2, 9, 8}
Output:
0 2 3 5
Explanation:
A[0] + A[2] = 3+7 = 10
A[3] + A[5] = 1+9 = 10
Input:
N =
4
A[] =
{424, 12, 31, 7}
Output:
-1 -1 -1 -1
Explanation:
There are no pairs satisfying the equation.
Constraints:
1 <= N <= 500
1 <= A[i] <= 10**5 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int[] satisfyEqn(int[] A, int N)"
],
"initial_code": "//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 S[] = read.readLine().split(\" \");\n int[] A = new int[N];\n \n for(int i=0; i<N; i++)\n A[i] = Integer.parseInt(S[i]);\n\n Solution ob = new Solution();\n int[] ptr = ob.satisfyEqn(A,N);\n \n System.out.println(ptr[0] + \" \" + ptr[1] + \" \" + ptr[2] + \" \" + ptr[3]);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730987010,
"user_code": "//User function Template for Java\n\nclass Solution {\n static int[] satisfyEqn(int[] A, int N) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"satisfyEqn(self, A, N)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n A = list(map(int, input().split()))\n ob = Solution()\n ptr = ob.satisfyEqn(A, N)\n print(*ptr)\n print(\"~\")\n",
"solution": "class Solution:\n def satisfyEqn(self, A, N):\n Hash = {} # create an empty dictionary to store sums\n Ans = [] # create an empty list to store the final answer\n flag = 0 # initialize a flag variable to 0\n for i in range(N): # loop through the elements in A\n for j in range(i + 1, N): # loop through the elements after index i in A\n # calculate the sum of the current pair of elements\n sum = A[i] + A[j]\n if sum not in Hash: # if the sum is not present in the dictionary\n # add the sum as a key and the pair of indices as its value\n Hash[sum] = (i, j)\n else: # if the sum is already present in the dictionary\n pp = Hash[sum] # get the pair of indices for the sum\n # if the pair of indices is not the same as the current pair\n if pp[0] != i and pp[0] != j and pp[1] != i and pp[1] != j:\n ans = [] # create an empty list to store the indices\n # add the first index from the dictionary pair\n ans.append(pp[0])\n # add the second index from the dictionary pair\n ans.append(pp[1])\n # add the first index from the current pair\n ans.append(i)\n # add the second index from the current pair\n ans.append(j)\n if not Ans: # if the final answer list is empty\n # copy the current list of indices as the final answer\n Ans = ans[:]\n else: # if the final answer list is not empty\n # initialize a variable to determine if the current list of indices should replace the final answer\n shouldReplace = False\n # loop through the elements in the final answer list\n for i1 in range(len(Ans)):\n # if the corresponding element in the final answer list is smaller than the corresponding element in the current list\n if Ans[i1] < ans[i1]:\n break # break the loop\n # if the corresponding element in the final answer list is larger than the corresponding element in the current list\n if Ans[i1] > ans[i1]:\n # set the variable to indicate that the current list should replace the final answer\n shouldReplace = True\n break # break the loop\n if shouldReplace: # if the current list should replace the final answer\n # replace the final answer with the current list\n Ans = ans[:]\n if not Ans: # if no valid indices were found\n return [-1, -1, -1, -1] # return a list of -1\n return Ans # return the list of valid indices if any were found\n",
"updated_at_timestamp": 1730987010,
"user_code": "#User function Template for python3\n\nclass Solution:\n def satisfyEqn(self, A, N):\n # code here "
} | eJytVMFOhDAQ9WD8jpeeV0NbWsAvMRHjQTl4wT2wiYnR+A/qxa91psXVXZlu6FIYSmnn9c3wpm+nn19nJ6FdvdPL9bN66NebQV1C6bbnW62guqd1dzd097ePm2GcPdf4udv+te3Vywq7zoacC26IXTaQJSAY2GyAco8JCC4bzP2CoeEGF0YuEWOgj1JA9Bzf9hIgAmlYAUIXgRUMmSUrIyF4soqsJmvG+MUNLG8hbcBh0wqDEpN9kraXJEK0Yw51/DXjkz/V5Pcns2EmZrziXIaxCWMPB48KNQhHDk+Tk0toVUz9YU0UW60nUzxDXFPqyqe3vGb3inuHej7RJfXQHCUIIWPplM0UylFKiQXppioSB2uS10o1+T/yZUKnoyvizDvLbz4uvgEkk7/4 |
703,753 | C++ Nega Bit | Given two integer numbers, F and S.In binary form of the numbers, for every i**thset bit in F, negatethe i **thbit inS.
Examples:
Input:
F =
2 ,
S =
5
Output:
7
Explanation:
2 is represented as 10 in binary and
5 is represented as 101. Hence negating
the 2nd bit of 5 from right, thus the
new number becomes 7 i.e. 111.
Input:
F =
1 ,
S =
3
Output:
2
Explanation:
1-1 and 3-11 in binary, thus negating
1st bit of 3 from right we get 10 i.e. 2.
Constraints:
1 <= F,S <= 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int negaBit(int F , int S)"
],
"initial_code": "//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 St[] = read.readLine().split(\" \");\n int F = Integer.parseInt(St[0]);\n int S = Integer.parseInt(St[1]);\n\n Solution ob = new Solution();\n System.out.println(ob.negaBit(F,S));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730473104,
"user_code": "//User function Template for Java\n\nclass Solution {\n static int negaBit(int F , int S) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"negaBit(self, F , S)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n F, S = map(int, input().split())\n\n ob = Solution()\n print(ob.negaBit(F, S))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to perform negaBit operation.\n def negaBit(self, F, S):\n # performing XOR operation between S and F.\n ans = S ^ F\n\n # returning the result.\n return ans\n",
"updated_at_timestamp": 1730473104,
"user_code": "#User function Template for python3\n\nclass Solution:\n def negaBit(self, F , S):\n # code here "
} | eJytVMtKxEAQ9KD/0eS8yPRrpuOXCEY8aA5e1j1kQRDFj9Cf8OYfOpnMKot2sopzSWCmi6rq6n4+fn0/OSrn/C3/XDw0t+vNdmjOoMFujYEYFPNfs4Kmv9/010N/c3W3HeobRerWT/n6cQX7pUpCZtCW49ZL0jTC/wgRVTkCMoZELgK2MQZzEDCIaVKoXxckOPUTe7ByfAomxq1HgVg0QlRhmvGRg0X1WFjK5TAhuRBtagOKx2I0EYEiobAvpFrtNzTBjIbxQZx30q8u924fs3RedhGTZQnpQBDsOqqq/oT31ZYyIUu9URenhuwzpGPYptzsgucjGyoxsmd7nUJaGENamEOBog7ZpcFe676rm9c536h/tGa323692fbpySFBShIiueme9hwvLDoO5V3FuHw5/QDRnKf2 |
703,909 | Modular Exponentiation for large numbers | Implement pow(x, n) % M.In other words, for a given value of x, n, and M, find (x**n) % M.
Examples:
Input:
x = 3, n = 2, m = 4
Output:
1
Explanation:
3
**2 = 9. 9 % 4 = 1.
Input:
x = 2, n = 6, m = 10
Output:
4
Explanation:
2
**6 = 64. 64 % 10 = 4.
Constraints:
1 ≤ x, n, M ≤ 10**9 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public long PowMod(long x, long n, long m)"
],
"initial_code": "//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();\n String[] S = s.split(\" \");\n long x = Long.parseLong(S[0]);\n long n = Long.parseLong(S[1]);\n long m = Long.parseLong(S[2]);\n Solution ob = new Solution();\n long ans = ob.PowMod(x, n, m);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "//Backend complete function Template for Java\n\nclass Solution\n{\n // Function to calculate (x^n) % m using modular exponentiation\n public long PowMod(long x, long n, long m)\n {\n long result=1;\n \t\twhile(n>0)\n \t\t{\n \t\t // If n is odd, multiply result with x and take modulo m\n \t\t if(n % 2 == 1)\n \t\t result=((result % m) * (x % m))%m;\n \t\t // Square x and take modulo m\n \t\t x = (x*x) % m;\n \t\t // Divide n by 2\n \t\t n = n/2;\n \t\t}\n \t\t// Returning the result\n \t\treturn result;\n }\n}",
"updated_at_timestamp": 1730271469,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public long PowMod(long x, long n, long m)\n {\n // Code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"PowMod(self, x, n, m)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n x, n, m = input().split()\n x = int(x)\n n = int(n)\n m = int(m)\n\n ob = Solution()\n ans = ob.PowMod(x, n, m)\n print(ans)\n print(\"~\")\n",
"solution": "# Backend complete function Template for python3\n\nclass Solution:\n # Function to calculate power of x raised to the power of n modulo m.\n def PowMod(self, x, n, m):\n res = 1\n while n > 0:\n if n % 2 == 1:\n res = (res * x) % m\n x = (x * x) % m\n n //= 2\n return res\n",
"updated_at_timestamp": 1731579300,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef PowMod(self, x, n, m):\n\t\t# Code here"
} | eJxrYJmqyMYABhFSQEZ0tVJmXkFpiZKVgpJhTJ6hgoECkFLSUVBKrShITS5JTYnPLy1BKKgDStbqKKDqAurBo8sAhy5D8nQZwABQuxE5liIZAGeS7GVLCDA2V0CwiDHOxMDMwMjC0ByHsUYkOs/cwtzQAGi3Gb4wpoYvjRD+pCjKSPIdVgMNcChGV0akOrRAp2KwA2lc/iUvNpBMNcQ0llxTMX2Py9O4fEtZdgR7CWe2hHoXzRYQyxChGkuxgBIm5Ac1HnfFKBDnMiMqOw1hFPakCzM3Bn/KJhRTsVP0AA90sq8= |
713,193 | Geeks And The String | Our geek loves to play with strings, Currently, he is trying to reduce the size of a string by recursively removing all the consecutive duplicate pairs. In other words, He can apply the below operations any number of times.
Examples:
Input:
aaabbaaccd
Output:
ad
Explanation:
Remove (aa)abbaaccd =>abbaaccd
Remove a(bb)aaccd => aaaccd
Remove (aa)accd => accd
Remove a(cc)d => ad
Input:
aaaa
Output:
Empty String
Explanation:
Remove (aa)aa => aa
Again removing pair of duplicates then (aa)
will be removed and we will get 'Empty String'.
Expected Time Complexity:
O(N)
Expected Auxiliary Space:
O(N)
Constraints:
1 <= |str| <= 10**4 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1671618299,
"func_sign": [
"public static String removePair(String s)"
],
"initial_code": "import 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;\n t = Integer.parseInt(br.readLine());\n while(t-- > 0){\n \n String s; \n s = br.readLine();\n \n Solution obj = new Solution();\n String res = obj.removePair(s);\n \n System.out.println(res);\n \n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution{\n public static String removePair(String s) {\n // using a stack to store the characters\n Stack<Character> stack = new Stack<>(); \n \n // adding the first character to the stack\n stack.add(s.charAt(0)); \n \n // iterating over the remaining characters in the string\n int curr_index = 1;\n while (curr_index < s.length()){\n \n // if stack is empty, add the character to the stack\n if (stack.size() == 0)\n stack.add(s.charAt(curr_index));\n \n // if the current character is equal to the top of stack,\n // remove the top element from stack\n else if (s.charAt(curr_index) == stack.peek()) \n stack.pop();\n \n // otherwise, add the character to the stack\n else\n stack.add(s.charAt(curr_index)); \n \n curr_index += 1;\n }\n \n // creating a string using the remaining characters in the stack\n String ans = \"\" ;\n for (char k: stack)\n ans+=Character.toString(k);\n \n // if there are no remaining characters, return -1\n if (ans.length() ==0)\n ans=\"-1\";\n \n // returning the result string\n return ans;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public static String removePair(String s) {\n // code here\n }\n}\n \n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1671618299,
"func_sign": [
"removePair(self,s)"
],
"initial_code": "# Initial Template for Python 3\n\nimport atexit\nimport io\nimport sys\n\n# Contributed by : Nagendra Jha\n_INPUT_LINES = sys.stdin.read().splitlines()\ninput = iter(_INPUT_LINES).__next__\n_OUTPUT_BUFFER = io.StringIO()\nsys.stdout = _OUTPUT_BUFFER\n\n\n@atexit.register\ndef write():\n sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())\n\n\nif __name__ == '__main__':\n test_cases = int(input())\n for cases in range(test_cases):\n obj = Solution()\n print(obj.removePair(str(input())))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n\n # Function to remove pair of duplicates from given string using Stack.\n def removePair(self, s):\n\n stack = []\n\n # pushing the first character of the string into the stack.\n stack.append(s[0])\n\n curr_index = 1\n\n # iterating over the string.\n while curr_index < len(s):\n if len(stack) == 0:\n stack.append(s[curr_index])\n # if current character of string is equal to the character at top\n # of stack, we pop it from stack and continue iterating.\n elif s[curr_index] == stack[-1]:\n stack.pop()\n # else we push the current character into the stack.\n else:\n stack.append(s[curr_index])\n curr_index += 1\n\n ans = \"\"\n\n # adding all characters in the stack to the answer and returning it.\n for char in stack:\n ans += char\n\n if len(ans) == 0:\n ans = \"-1\"\n\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to remove pair of duplicates from given string using Stack.\n def removePair(self,s):\n # code here"
} | eJxrYJm6lIUBDCLmARnR1UqZeQWlJUpWCkqGMXmJSjoKSqkVBanJJakp8fmlJVCpxJi8upg8pVodBTT1Sbg0JOHSgcsKXUOcdiTjtCQZp54k0u0BakrGZRUBXSCSPJ0pKampaWmk6yUnHCEQZ2BCIE4bUTxLwNO43AAxgwxNpOoBuxHoRBzaknAmaCzehDmBdO9CDMIfXwR8gMsDuBMGOR5IxB9h8HQKYkOzF2634fQR3DACKRFmQOwUPQBUao0V |
703,341 | LCS of three strings | Given 3 strings A, Band C, the task is to find the length of the longest sub-sequence that is common in all the three given strings.
Examples:
Input:
A = "geeks"
B = "geeksfor",
C = "geeksforgeeks"
Output:
5
Explanation:
"geeks"is the longest common
subsequence with length 5.
Input:
A = "abcd"
B = "efgh"
C = "ijkl"
Output:
0
Explanation:
There's no subsequence common
in all the three strings.
Constraints:
1 <= n1, n2, n3 <= 20
Elements of the strings consitutes only of the lower case english alphabets. | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1731665657,
"func_sign": [
"int LCSof3(String s1, String s2, String s3)"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\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 // String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n // int n1 = Integer.parseInt(input_line[0]);\n // int n2 = Integer.parseInt(input_line[1]);\n // int n3 = Integer.parseInt(input_line[2]);\n String[] input_line = read.readLine().trim().split(\"\\\\s+\");\n String s1 = input_line[0];\n String s2 = input_line[1];\n String s3 = input_line[2];\n Solution obj = new Solution();\n System.out.println(obj.LCSof3(s1, s2, s3));\n\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "GFG",
"solution": "class Solution \n{ \n int LCSof3(String A, String B, String C, int n1, int n2, int n3) \n { \n int[][][] dp = new int[n1 + 1][n2 + 1][n3 + 1];\n\n\t\tfor (int i = 0; i <= n1; i++) {\n\t\t\tfor (int j = 0; j <= n2; j++) {\n\t\t\t\tfor (int t = 0; t <= n3; t++) {\n\n\t\t\t\t\tif (i == 0 || j == 0 || t == 0) {\n\t\t\t\t\t\tdp[i][j][t] = 0;\n\t\t\t\t\t}\n\n\t\t\t\t\telse if (A.charAt(i - 1) == B.charAt(j - 1) && A.charAt(i - 1) == C.charAt(t - 1)) {\n\t\t\t\t\t\tdp[i][j][t] = 1 + dp[i - 1][j - 1][t - 1];\n\t\t\t\t\t}\n\n\t\t\t\t\telse {\n\t\t\t\t\t\tdp[i][j][t] = Math.max(Math.max(dp[i - 1][j][t], dp[i][j - 1][t]), dp[i][j][t - 1]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn dp[n1][n2][n3];\n }\n}",
"updated_at_timestamp": 1731665657,
"user_code": "// User function Template for Java\nclass Solution {\n int LCSof3(String s1, String s2, String s3) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1731665657,
"func_sign": [
"LCSof3(self,s1, s2, s3)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n\n for _ in range(t):\n # n1,n2,n3 = map(int,input().split())\n s1, s2, s3 = input().split()\n\n solObj = Solution()\n ans = solObj.LCSof3(s1, s2, s3)\n\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n\n def LCSof3(self, s1, s2, s3):\n n1 = len(s1)\n n2 = len(s2)\n n3 = len(s3)\n memo = [[[-1] * (n3 + 1) for i in range(n2 + 1)]\n for i in range(n1 + 1)]\n\n return self.solve(s1, s2, s3, 0, 0, 0, n1, n2, n3, memo)\n\n def solve(self, s1, s2, s3, i, j, k, n1, n2, n3, memo):\n if (i == n1 or j == n2 or k == n3):\n return 0\n\n if (memo[i][j][k] != -1):\n return memo[i][j][k]\n\n # if all the characters are same, we can include them in the longest length\n # and check for the longest length in state (i + 1, j + 1, k + 1)\n if (s1[i] == s2[j] and s1[i] == s3[k]):\n memo[i][j][k] = 1 + self.solve(s1, s2, s3, i + 1, j + 1, k + 1, n1,\n n2, n3, memo)\n return memo[i][j][k]\n\n # if the characters do not match, we simply call for all the possible recursions\n # and store the maximum we get out of them\n memo[i][j][k] = max(\n self.solve(s1, s2, s3, i + 1, j, k, n1, n2, n3, memo),\n self.solve(s1, s2, s3, i, j + 1, k, n1, n2, n3, memo),\n self.solve(s1, s2, s3, i, j, k + 1, n1, n2, n3, memo))\n return memo[i][j][k]\n",
"updated_at_timestamp": 1731665657,
"user_code": "#User function Template for python3\n\nclass Solution:\n\n def LCSof3(self,s1, s2, s3):\n # code here"
} | eJzlV11OwzAM5oFX7mD1eUK0GyA4CRJFaGu7AWPZ2NqtLQJxCLgfb1yDNnHTNIvbMpj4c6fEjqPEX/yT7Gn35W1vh9PZa8ac31vXbBaF1ilYjsv6SDBAAg/JZT4SBEgwRLI6YAXxLPDCwL+cRiGud+CyR5eJ1nroQHWrVBIY2dIYlaRhKkkjVSKMsuutmt3NFyAbl03YNGfCaAkTVnCiy1XEJj2++pFpjy7HBWh1Jgw8PxiOrq5vYHxb7AbRchUnaa7LZyifp3yZDBVldSJvAVm/HFKkvG/hPMcmkMSJ+kGtqEAVQMUxQoE003v+cJQrQXJsqvLUcds9xdgTwlbhPuG6VYzeNEqqU0qfCJfARioZR+tTYAMNdQxd4S0Rd84hFX5yPSX2Wg+6rIINaiQ1x9fS2zxAIHOEaxGg3YzMmEqlCkojUcFtzealaRJzS5KY28aHcAxKrei13ASvkp5QSUgC2bFA5NAFw+a4tB/UyVR4OPTy7Y6tUVXvvk8DM8UjBdYYI9oNp6295QvPfLUQZixCMvu/8irSK3a2M/JNF0urGj/Wi3zSXOXDf13mtXq4jaq/nsl0Qv/aqikz3aces6RDiqSn/fyhckC9nX56oM6/4UFSG5r9vxSbhptsG389Lp733wFTS1eC |
704,006 | High Effort vs Low Effort | You are given n days and for each day (di) you canselect one of the following options:
Examples:
Input:
n = 3
hi[] = {2,8,1}
li[] = {1,2,1}
Output:
9
Explanation:
Options on 1st day: hi[0]=2, li[0]=1 or no-task
Select no-task.
Options on 2nd day: hi[1]=8, li[2]=1 or no-task
Select high-effort task as no-task was selected
the previous day.
Options on 3rd day: hi[2]=1, li[2]=1 or no-task
Select low-effort task as selecting high-effort
task is only possible if you chose no-task on
previous day.
Input:
n = 5
hi[] = {3,6,8,7,6}
li[] = {1,5,4,5,3}
Output:
20
Explanation:
Perform high-effort task on first
day and low-effort task on all remaining days.
Constraints:
1 <= n<= 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int maxAmt(int n , int hi[] , int li[])"
],
"initial_code": "//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\nclass GfG\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 \n int n = sc.nextInt();\n int hi[] = new int[n];\n int li[] = new int[n];\n for(int i = 0;i<n;i++)\n hi[i] = sc.nextInt();\n for(int i = 0;i<n;i++)\n li[i] = sc.nextInt(); \n Solution ob = new Solution();\n System.out.println(ob.maxAmt(n,hi,li));\n \nSystem.out.println(\"~\");\n}\n }\n} ",
"script_name": "GfG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n public int maxAmt(int n, int hi[], int li[]) {\n int dp[] = new int[n];\n // on first day, we can take value from high-effort also.\n dp[0] = Math.max(hi[0], li[0]);\n if (n > 1) dp[1] = Math.max(hi[1], li[1] + dp[0]);\n for (int i = 2; i < n; i++) {\n // taking maximum value of current low-effort plus previous day value and\n // current high effort plus previous to previous day's value\n dp[i] = Math.max(li[i] + dp[i - 1], hi[i] + dp[i - 2]);\n }\n return dp[n - 1];\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public int maxAmt(int n , int hi[] , int li[]) \n { \n //code here.\n } \n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"maxAmt(self, n, hi, li)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n n = int(input())\n hi = list(map(int, input().strip().split()))\n li = list(map(int, input().strip().split()))\n ob = Solution()\n print(ob.maxAmt(n, hi, li))\n print(\"~\")\n",
"solution": "class Solution:\n def maxAmt(self, n, hi, li):\n # base case if n is 1\n if n == 1:\n return max(hi[0], li[0])\n dp = [0 for i in range(n)]\n\n # initializing the dp array with the maximum amount for the first two elements\n dp[0] = max(hi[0], li[0])\n dp[1] = max(li[0]+li[1], hi[0]+li[1], hi[1])\n\n for i in range(2, n):\n # calculating the maximum amount for the current element\n dp[i] = max(dp[i-2]+hi[i], dp[i-1]+li[i])\n return dp[-1]\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def maxAmt(self, n, hi, li): \n # code here \n"
} | eJy9lc1OwzAMgDlw4DGsnCdkJ02a7kmQKOIAPXAJO3QSEgLtIcb74iRUAjXONtStqfuzxfZnJ3Z311/rm6t03Bl+uH9XL2GzHdUaFPWBMAoQFC59sDAbagVqeNsMT+Pw/Pi6HX9MWduHzz6ojxUUHJSsQ/yn47tnaVkciwWSHKDkwEYznk04Vm/AgGZDmu8Nvztoo/9frzz1z3TBn/eCP41RgBidyRmcuRm7ATJA7DpFNwNKSThmCDhEVOGZBxgzTInHJDabONvE3MH/YhDQdGOkpcmnFFJFCxHzVdJNE8r5SKnO2nI6EcV8Tqp534oIWkaIOxthNoo/CtZF0xMgeZw2f17NSqReDLZcPK5UPaeVD7Xipjiq49DhluOklrN0RSxZEot1D3ta/9C21j/OSiStn64u4JmQDmWpKyGJPWCODhf9HMElPD7sb78BnTAIFA== |
707,042 | IPL 2021 - Match Day 2 | Due to the rise of covid-19 cases in India, this year BCCI decided to organize knock-out matches in IPL rather than a league.
Examples:
Input:
N = 9, K = 3
arr[] = 1 2 3 1 4 5 2 3 6
Output:
3 3 4 5 5 5 6
Explanation:
1st contiguous subarray = {1 2 3} Max = 3
2nd contiguous subarray = {2 3 1} Max = 3
3rd contiguous subarray = {3 1 4} Max = 4
4th contiguous subarray = {1 4 5} Max = 5
5th contiguous subarray = {4 5 2} Max = 5
6th contiguous subarray = {5 2 3} Max = 5
7th contiguous subarray = {2 3 6} Max = 6
Input:
N = 10, K = 4
arr[] = 8 5 10 7 9 4 15 12 90 13
Output:
10 10 10 15 15 90 90
Explanation:
1st contiguous subarray = {8 5 10 7}, Max = 10
2nd contiguous subarray = {5 10 7 9}, Max = 10
3rd contiguous subarray = {10 7 9 4}, Max = 10
4th contiguous subarray = {7 9 4 15}, Max = 15
5th contiguous subarray = {9 4 15 12}, Max = 15
6th contiguous subarray = {4 15 12 90}, Max = 90
7th contiguous subarray = {15 12 90 13}, Max = 90
Constraints:
1 ≤ N ≤ 10**6
1 ≤ K ≤ N
0 ≤ arr[i]≤ 10**6 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1618213696,
"func_sign": [
"static ArrayList<Integer> max_of_subarrays(int arr[], int n, int k)"
],
"initial_code": "import java.util.*;\nimport java.io.*;\nimport java.lang.*;\n\nclass Main {\n public static void main(String args[]) {\n // taking input using class Scanner\n Scanner sc = new Scanner(System.in);\n\n // taking total count of testcases\n int t = sc.nextInt();\n\n while (t-- > 0) {\n // taking total number of elements\n int n = sc.nextInt();\n\n // taking size of subArrays\n int k = sc.nextInt();\n\n // Declaring and Intializing an array of size n\n int arr[] = new int[n];\n\n // adding all the elements to the array\n for (int i = 0; i < n; i++) {\n arr[i] = sc.nextInt();\n }\n\n // Calling the method max_of_subarrays of class solve\n // and storing the result in an ArrayList\n ArrayList<Integer> res = new Solution().max_of_subarrays(arr, n, k);\n\n // printing the elements of the ArrayList\n for (int i = 0; i < res.size(); i++)\n System.out.print(res.get(i) + \" \");\n System.out.println();\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1730480509,
"user_code": "class Solution {\n static ArrayList<Integer> max_of_subarrays(int arr[], int n, int k) {\n // Your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1618213696,
"func_sign": [
"max_of_subarrays(self,arr,n,k)"
],
"initial_code": "# Initial Template for Python 3\n\nimport atexit\nimport io\nimport sys\nfrom collections import deque\n\n# Contributed by : Nagendra Jha\n\n_INPUT_LINES = sys.stdin.read().splitlines()\ninput = iter(_INPUT_LINES).__next__\n\n_OUTPUT_BUFFER = io.StringIO()\nsys.stdout = _OUTPUT_BUFFER\n\n\n@atexit.register\ndef write():\n sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())\n\n\nif __name__ == '__main__':\n test_cases = int(input())\n for cases in range(test_cases):\n n, k = map(int, input().strip().split())\n arr = list(map(int, input().strip().split()))\n ob = Solution()\n res = ob.max_of_subarrays(arr, n, k)\n for i in range(len(res)):\n print(res[i], end=\" \")\n print()\n print(\"~\")\n",
"solution": "class 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 res = []\n d = deque()\n\n for i in range(k):\n # -1 repesents right end of deque\n while len(d) and arr[i] >= arr[d[-1]]:\n d.pop()\n d.append(i)\n\n for i in range(k, n):\n # print(arr[d[0]],end=\" \") # print element at front of deque\n res.append(arr[d[0]])\n while len(d) and d[0] <= i-k:\n d.popleft()\n while len(d) and arr[i] >= arr[d[-1]]:\n d.pop()\n d.append(i)\n\n res.append(arr[d[0]])\n return res\n",
"updated_at_timestamp": 1730480509,
"user_code": "#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"
} | eJzdVTtPxDAMZmDhX1idTygv98EvQaKIAW5gKTfcSUgIxMbGBP+XL8616KDu40AIXdLElePYzmfHeT5+fz05knb+gp+Lh+y2WW3W2Rlltm4sE9eNp7Zz1/O2ZwvKlver5fV6eXN1t1lvN/fKUt081U32uKBdM86QNbBmqKKSCggyBZhzZNEd/oKoKbBaQVSxubP/U1qzyoYci1XY94aCIbByQ4WhEqqiU0JKYeWyHERUHCag45g8fMUpYZGpYCqZKpkL4bCsepGMaEYaZAUi1mDEBXAsWBY8B54Dz4HnclaPmrwbGxX3fBPMapghHhExabprsakaTFLxPdRTotpmhRbSmK5dxigK9cN1aah/upOK0px865LM6n1JXbsh5OrGkGZ+EG3TRYwqaYmUiRSJ5IlwIiERn4hLRA/QcMCVGuLnFBG/+/VXEjUlB/N48FSj98CiD6mQ9VFoyj2wKeO2OehMB2es6uNEM+p+lNYxmFqFzdc6/D8KsTg2fwo942eV+RdwPBQg0+O3P5LyiAC/7TPyV2U0dHfk8u30AxrxQ54= |
703,144 | K-Pangrams | Given a string str and an integer k, return true if the string can be changed into a pangram after at most k operations, else return false.
Examples:
Input:
str = "the quick brown fox jumps over the lazy dog", k = 0
Output:
true
Explanation:
the sentence contains all 26 characters and is already a pangram.
Input:
str = "aaaaaaaaaaaaaaaaaaaaaaaaaa", k = 25
Output:
true
Explanation:
The word contains 26 instances of 'a'. Since only 25 operations are allowed. We can keep 1 instance and change all others to make str a pangram.
Input:
str = "a b c d e f g h i j k l m", k = 20
Output:
false
Explanation:
Since there are only 13
alphabetic
characters in this case, no amount of swapping can produce a panagram here.
Constraints:
1<= str.size() <= 10**5
0<= k <= 50
str may contain duplicate characters
str contains only lowercase alphabets or spaces. | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"boolean kPangram(String str, int k)"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String args[]) throws IOException {\n Scanner sc = new Scanner(System.in);\n int t = Integer.parseInt(sc.nextLine().trim());\n while (t-- > 0) {\n String str = sc.nextLine();\n int k = Integer.parseInt(sc.nextLine().trim());\n Solution obj = new Solution();\n if (obj.kPangram(str, k))\n System.out.println(\"true\");\n else\n System.out.println(\"false\");\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n boolean kPangram(String str, int k) {\n // create an array to store the frequency of each letter in the alphabet\n int map[] = new int[26];\n // initialize all elements of the array to 0\n Arrays.fill(map, 0);\n // initialize a variable to keep track of the total number of letters in the\n // string\n int total = 0;\n // iterate through the string character by character\n for (int i = 0; i < str.length(); i++) {\n // if the character is a space, skip to the next iteration\n if (str.charAt(i) == ' ') continue;\n // increment the frequency count of the corresponding letter in the map\n // array\n map[(int)str.charAt(i) - (int)'a']++;\n // increment the total count of letters in the string\n total++;\n }\n // if the total count of letters in the string is less than 26, return false\n if (total < 26) return false;\n // initialize a variable to keep track of the count of different letters in the\n // string\n int count = 0;\n // iterate through the map array to count the number of non-zero elements\n for (int i = 0; i < 26; i++) {\n // if the frequency count of a letter is not zero, increment the count\n // variable\n if (map[i] != 0) count++;\n }\n // if the count of different letters in the string plus k is greater than or\n // equal to 26, return true\n if (count + k >= 26) return true;\n // otherwise, return false\n return false;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\nclass Solution {\n boolean kPangram(String str, int k) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"kPangram(self,string, k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n\n for tcs in range(T):\n string = input()\n K = int(input())\n ob = Solution()\n a = ob.kPangram(string, K)\n if a:\n print(\"true\")\n else:\n print(\"false\")\n print(\"~\")\n",
"solution": "class Solution:\n\n def kPangram(self, string, k):\n noOfAlpha = len(string) - string.count(' ')\n\n # If the number of alphabets in the string is less than 26, it can't be a pangram.\n if noOfAlpha < 26:\n return False\n\n # If k is greater than 25, it means any k distinct alphabets can form a pangram.\n if k > 25:\n return True\n\n # Creating a map to keep track of alphabets present in the string.\n alphabet_map = [0] * 26\n\n # Iterating over the string to update the map.\n for char in string:\n if char != ' ':\n alphabet_map[ord(char.lower()) - ord('a')] = 1\n\n # Counting the number of distinct alphabets present in the string.\n noOfDistAlpha = alphabet_map.count(1)\n\n # If the number of distinct alphabets plus k is greater than or equal to 26,\n # it means k distinct alphabets can be added to the string to form a pangram.\n if noOfDistAlpha + k >= 26:\n return True\n else:\n return False\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def kPangram(self,string, k):\n # code here"
} | eJy9k81Og0AUhV0Yn+OEdWOsSTc+iYljDDADTKHD3wwFjMY3cKM+r3caf2pbME6J34oNJ3e+e+7T6evb2cmG62f6uLn3pCqM9q7gzZkKQi6iOJHLNFupvCirWptm3XY9U5cLbwZPtIUIteB3udEfv0V+VgumHpnyHmb4mdd37boxuq7KIlerLF3KJI4EDwOfqYuBPF2ZoTgfAUJwCESIkUBiiRQZVkzNh+LGxitHYGrhMGG5FpXujMwLv+ZkkkT2bdgEikYcEjj24K+F4Hsj+FzJ3CGQQEAgJMAJCAIRgZhAQkBKcku4WdgqDuwTsF0qp80Xls1eKktt0RZjGuqmS5eGGSm7g9oRhX/opt3KBP3cP0jiuJvcwRo4TuSBY7RGj73MX3xOE7s3rVvqRB3y+b+c++77N25TB7m3L+fvOGtZcQ== |
703,293 | Maximum number of zeroes | Given an array arr[] of integers, the task is to find the number that has the maximum number of zeroes. If there are no zeroes then print -1.
Examples:
Input:
arr[] = [10, 20, 3000, 9999, 200]
Output:
3000
Explanation:
3000 contains 3 zero's in it.
Input:
arr[] = [1, 2, 3, 4]
Output:
-1
Explanation:
No zero is present.
Constraints:
1 ≤ arr.size() ≤ 10**5
1 < arr[i] < 10**100 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public String maxZero(ArrayList<String> arr)"
],
"initial_code": "import java.util.ArrayList;\nimport java.util.Scanner;\n\n//Position this line where user code will be pasted.\npublic class Main {\n public static void main(String[] args) {\n Scanner sc = new Scanner(System.in);\n int testCases = sc.nextInt();\n sc.nextLine();\n while (testCases-- > 0) {\n String inputLine = sc.nextLine();\n String[] arr = inputLine.split(\" \");\n\n ArrayList<String> arrList = new ArrayList<>();\n for (String numStr : arr) {\n arrList.add(numStr);\n }\n\n Solution solution = new Solution();\n System.out.println(solution.maxZero(arrList));\n \nSystem.out.println(\"~\");\n}\n sc.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n private int countZeros(String numStr) {\n int zeroCount = 0;\n for (char ch : numStr.toCharArray()) {\n if (ch == '0') {\n zeroCount++;\n }\n }\n return zeroCount;\n }\n\n private boolean compareStrings(String str1, String str2) {\n if (str1.length() != str2.length()) {\n return str1.length() > str2.length();\n }\n return str1.compareTo(str2) > 0;\n }\n\n public String maxZero(ArrayList<String> arr) {\n String result = \"\";\n int maxZeroCount = -1;\n for (String numStr : arr) {\n int zeroCount = countZeros(numStr);\n if (zeroCount > maxZeroCount && zeroCount != 0) {\n maxZeroCount = zeroCount;\n result = numStr;\n } else if (zeroCount == maxZeroCount) {\n if (compareStrings(numStr, result)) {\n result = numStr;\n }\n }\n }\n return result.isEmpty() ? \"-1\" : result;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public String maxZero(ArrayList<String> arr) {\n // Code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"maxZero(self, arr)"
],
"initial_code": "import sys\n\ninput = sys.stdin.read\ndata = input().splitlines()\n\nt = int(data[0])\nsolution = Solution()\n\nfor i in range(1, t + 1):\n arr = data[i].split()\n print(solution.maxZero(arr))\n print(\"~\")\n",
"solution": "class Solution:\n\n def compareStrings(self, str1, str2):\n if len(str1) != len(str2):\n return len(str1) > len(str2)\n\n for ch1, ch2 in zip(str1, str2):\n if ch1 > ch2:\n return True\n elif ch1 < ch2:\n return False\n\n return False\n\n def maxZero(self, arr):\n result = \"\"\n maxZeroCount = -1\n\n for numStr in arr:\n zeroCount = numStr.count('0')\n if zeroCount > maxZeroCount and zeroCount != 0:\n maxZeroCount = zeroCount\n result = numStr\n elif zeroCount == maxZeroCount:\n if self.compareStrings(numStr, result):\n result = numStr\n\n return result if result else \"-1\"\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def maxZero(self, arr):\n #Code here\n"
} | eJytVMEKwjAM9SB+R+hZJV073fwSwYkH3UEP08MEQRQ/Qv/XWOusYymurJAQuiwv6Uty6z92g5458zUZi7PYFodjKWYgZFZIiECBzgoxBJGfDvm6zDer/bG0LiPyudLXyxBqPyJECArRVSkdukY23MuLCxgpHU+mSQppMp3EWkUSqjusTKxM9OC4Lo1o7QvmwdiKKFU08lZW468p+SIqbw6A2JOgJGg+CFtPHMI5vlg3ZIMmiX0UePL+VOUvvKNGMQ/1T7cknoSJL8rKZbFzMh2MOrfBmN94TAPVgEJmmm+XZqLcrRM23TyikdaT3dFcF55YX4/mkPZBMs9mtYNjyQhZ2AH9ZbDaNdnyPn4CFhfBiA== |
703,436 | Find the smallest and second smallest element | Given an array, arr of integers, your task is to return the smallest and second smallest element in the array. If the smallest and second smallest do not exist, return -1.
Examples:
Input:
arr[] = [2, 4, 3, 5, 6]
Output:
2 3
Explanation:
2 and 3 are respectively the smallest and second smallest elements in the array.
Input:
arr[] = [1, 1, 1]
Output:
-1
Explanation:
Only element is 1 which is smallest, so there is no second smallest element.
Constraints:
1 <= arr.size <= 10**5
1 <= arr[i] <= 10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1618922067,
"func_sign": [
"public int[] minAnd2ndMin(int arr[])"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\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 inputLine[] = br.readLine().trim().split(\" \");\n int n = inputLine.length;\n int arr[] = new int[(int)(n)];\n for (int i = 0; i < n; i++) {\n arr[i] = (int)(Long.parseLong(inputLine[i]));\n }\n\n Solution obj = new Solution();\n int[] product = obj.minAnd2ndMin(arr);\n if (product[0] == -1)\n System.out.println(product[0]);\n else\n System.out.println(product[0] + \" \" + product[1]);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int[] minAnd2ndMin(int arr[]) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1618922067,
"func_sign": [
"minAnd2ndMin(self, arr)"
],
"initial_code": "# Initial Template for Python 3\ndef main():\n T = int(input())\n while (T > 0):\n arr = [int(x) for x in input().strip().split()]\n obj = Solution()\n product = obj.minAnd2ndMin(arr)\n if product[0] == -1:\n print(product[0])\n else:\n print(product[0], end=\" \")\n print(product[1])\n T -= 1\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def minAnd2ndMin(self, arr):\n # Initialize the answer list\n ans = []\n\n # Edge case: if the array is empty, return [-1, -1]\n if len(arr) == 0:\n return [-1, -1]\n\n min1 = arr[0]\n min2 = float('inf')\n n = len(arr)\n\n # Traverse the array to find the minimum and second minimum elements.\n for i in range(1, n):\n # Update min1 and min2 if arr[i] is smaller than both.\n if arr[i] < min1:\n min2 = min1\n min1 = arr[i]\n # Update min2 if arr[i] is smaller than min2 but greater than min1.\n elif arr[i] < min2 and arr[i] != min1:\n min2 = arr[i]\n\n # If there is only one element in the array or second minimum is not found,\n # return [-1, -1].\n if n == 1 or min2 == float('inf'):\n ans.append(-1)\n ans.append(-1)\n else:\n # Otherwise, return the minimum and second minimum elements.\n ans.append(min1)\n ans.append(min2)\n\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def minAnd2ndMin(self, arr):\n #code here\n \n \n\n"
} | eJytVMFugzAM3WHSfsPKuZ0wJYX1Syot0w4bh17SHkCaNG3aR6z/W4MJawdOoGmQgkPCi/3s55/7Y/1w146tJeP5U+3soa7UBhQai0kzoHs9NQMuvqkFqPLjUL5V5fvrvq66X89PGvttrPpawCX0EAzbCwpepB7kgj3xAg9mAW+JAozzDAaGgIT+eMc4PIuXF7kn6pyPS/AOJnXGyhmZM7ToeSqipoSTgYY15EC8ExQg3UW3ED4hX4MpUxvJsYaR58rEBxLVzut21mEtaD4eYkRz8hBnpm8VSl8vC07j/Jx5OZkaQkbbWaDS8a8RCL4kDOrpSn24Ee1JjjgQQLc7QVBjiiIzQlEC+UVs+Tj198QaQ47+7wQxrM0rvWSoR2z8uaUmp3QBbgPJ3DtdZb/8Pp4AK/PojQ== |
713,994 | Frogs and Jumps | Nfrogs are positioned at one end of the pond. All frogs want to reach the other end of the pond as soon as possible. The pond has someleaves arranged in a straight line. Each frog has the strength to jump exactlyKleaves. For example, a frog having strength 2 will visit the leaves 2, 4, 6, ... etc. while crossing the pond.
Examples:
Input:
N = 3
leaves = 4
frogs[] = {3, 2, 4}
Output:
1
Explanation:
Leaf 1 will not be visited by any frog.
Input:
N = 3
leaves = 6
frogs[] = {1, 3, 5}
Output:
0
Explanation:
First frog will visit all the leaves so no
leaf is left unvisited.
Constraints:
1 ≤ N, leaves, frogs[i] ≤ 10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1676003114,
"func_sign": [
"public int unvisitedLeaves(int N, int leaves, int frogs[])"
],
"initial_code": "//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 = Integer.parseInt(br.readLine().trim()); // Inputting the testcases\n while(t-->0)\n {\n \n String inputLine1[] = br.readLine().trim().split(\" \"); \n int i=0;\n int N = Integer.parseInt(inputLine1[i++]);\n int leaves = Integer.parseInt(inputLine1[i++]);\n \n int frogs[] = new int[(int)(N)];\n \n String inputLine2[] = br.readLine().trim().split(\" \");\n for ( i = 0; i < N; i++) {\n frogs[i] = Integer.parseInt(inputLine2[i]);\n }\n \n Solution ob = new Solution();\n System.out.println(ob.unvisitedLeaves(N, leaves, frogs));\n \n \nSystem.out.println(\"~\");\n}\n\t}\n}\n",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution {\n public int unvisitedLeaves(int N, int leaves, int frogs[]) {\n \n int leaveStatus[] = new int[leaves+1]; \n\t\tfor (int i = 0; i < N; i++) {\n\t\t\tif (frogs[i] <= leaves && leaveStatus[frogs[i]] == 0) {\n\t\t\t\tfor (int j = frogs[i]; j <= leaves; j += frogs[i]) {\n\t\t\t\t\tleaveStatus[j] = 1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tint leafCount = leaves;\n\t\tfor (int i : leaveStatus) {\n\t\t\tif (i==1) {\n\t\t\t\tleafCount--;\n\t\t\t}\n\t\t}\n\t\treturn leafCount;\n }\n};",
"updated_at_timestamp": 1730482160,
"user_code": "//User function Template for Java\n\nclass Solution {\n public int unvisitedLeaves(int N, int leaves, int frogs[]) {\n // Code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1676003114,
"func_sign": [
"unvisitedLeaves(self, N, leaves, frogs)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n while T > 0:\n N, leaves = [int(i) for i in input().split()]\n frogs = [int(i) for i in input().split()]\n ob = Solution()\n print(ob.unvisitedLeaves(N, leaves, frogs))\n T -= 1\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to find minimum number of unvisited leaves.\n def unvisitedLeaves(self, N, leaves, frogs):\n\n # Initializing leaveStatus array with all zeros.\n leaveStatus = [0 for j in range(leaves+1)]\n\n # Iterating over frogs array.\n for i in range(N):\n # Checking if frog's jump is within leaves range and leaf is unvisited.\n if frogs[i] <= leaves and leaveStatus[frogs[i]] == 0:\n # Marking all the leaves that can be reached by the frog as visited.\n for j in range(frogs[i], leaves+1, frogs[i]):\n leaveStatus[j] = 1\n\n leafCount = leaves\n # Counting the unvisited leaves.\n for i in leaveStatus:\n if(i):\n leafCount -= 1\n\n return leafCount\n",
"updated_at_timestamp": 1730482160,
"user_code": "#User function Template for python3\n\nclass Solution:\n def unvisitedLeaves(self, N, leaves, frogs):\n # code here"
} | eJytVEtOAzEMZYE4x9OsKxQ7cZLhJEgMYgFdsBlYtBISAnEIOAU7TogdWolWuNChs4om8fv4xXk5fvs4OWrf+bsuLh672/F+uejO0NEwCjgMI4ERkSDdDN384X5+vZjfXN0tF6uDeuR5GLunGTarE0iG0WozilObnNoMCkYdVAFiQAqQgBwcmN7TQFZnRnRBZgcshhfFIJPorqfMg4wmTTdZBcWojQmuqp58WV8gpmlbEETUKbLX71pcWFaHDRaCAiKQqtVFD47gHpEQCxLtmSSZxOZZw9yNjKQdcdOm4jCw5WQMCRVqg3LLKoErorLm1p2EVCEMya1BCbmiMEpG9TKIRTxXLC2EYJFm9I1Wf1UwNebScolGHnsktnSMX5urw1CaBK1ULX1T4eWVc/7dtkzyHXc5r/5UbNwTvXoHuykbcyvrwZ0yud+RtCv/wvL8bhhWBvU8xbTird5JmvRQ+k1jD2pvqziQ158eZr2uE/Pdcv0H22u4y9fTT0E6xJ0= |
704,178 | Number Formation | Given three integers x, y, and z, the task is to find the sum of all the numbers formed by
having 4 at most x times, having 5 at most y times, and having 6 at most z times as a digit.
Examples:
Input:
X = 1, Y = 1, Z = 1
Output:
3675
Explanation:
4 + 5 + 6 + 45 + 54 + 56
+ 65 + 46 + 64 + 456 + 465
+ 546 + 564 + 645 + 654 = 3675
Input:
X = 0, Y = 0, Z = 0
Output:
0
Explanation:
No number can be formed
Your Task:
You 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
Expected Time Complexity:
O(
X*Y*Z
)
Expected Auxiliary Space:
O(
X*Y*Z
)
Constraints:
0 ≤
X, Y, Z≤ 60 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1616485809,
"func_sign": [
"public int getSum(int X, int Y, int Z)"
],
"initial_code": "// 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 \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GfG",
"solution": "// Back-end template function for JAVA\n\nclass Solution {\n\n public int getSum(int x, int y, int z) {\n int mod = 1000000007;\n\n // exactsum[i][j][k] stores the sum of\n // all the numbers having exact\n // i 4's, j 5's and k 6's\n long exactsum[][][] = new long[x + 1][y + 1][z + 1];\n\n // exactnum[i][j][k] stores numbers\n // of numbers having exact\n\n // i 4's, j 5's and k 6's\n long exactnum[][][] = new long[x + 1][y + 1][z + 1];\n\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\n long ans = 0L;\n exactnum[0][0][0] = 1L;\n\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\n // Computing exactsum[i][j][k]\n // as explained above\n if (i > 0) {\n exactsum[i][j][k] += (exactsum[i - 1][j][k] * 10 +\n 4 * exactnum[i - 1][j][k]) %\n 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 +\n 5 * exactnum[i][j - 1][k]) %\n 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 +\n 6 * exactnum[i][j][k - 1]) %\n mod;\n exactnum[i][j][k] += exactnum[i][j][k - 1] % mod;\n }\n\n ans += exactsum[i][j][k] % mod;\n ans %= mod;\n }\n }\n }\n\n return (int)ans;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// 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 }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1616485809,
"func_sign": [
"getSum(self, X, Y, Z)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n X, Y, Z = map(int, input().split())\n ob = Solution()\n ans = ob.getSum(X, Y, Z)\n print(ans)\n print(\"~\")\n",
"solution": "# Back-end function Template for python3\n\nclass Solution:\n def getSum(self, x, y, z):\n mod = (10**9)+7\n\n # exactsum[i][j][k] stores the sum of\n # all the numbers having exact\n # i 4's, j 5's and k 6's\n exactsum = []\n\n # exactnum[i][j][k] stores numbers\n # of numbers having exact\n # i 4's, j 5's and k 6's\n exactnum = []\n\n for i in range(x+1):\n two = []\n two1 = []\n for j in range(y+1):\n temp = [0]*(z+1)\n temp1 = [0]*(z+1)\n two.append(temp)\n two1.append(temp1)\n exactnum.append(two)\n exactsum.append(two1)\n\n ans = 0\n exactnum[0][0][0] = 1\n\n for i in range(x+1):\n for j in range(y+1):\n for k in range(z+1):\n # Computing exactsum[i][j][k]\n # as explained above\n if (i > 0):\n exactsum[i][j][k] += (exactsum[i - 1][j][k]\n * 10 + 4 * exactnum[i - 1][j][k]) % mod\n exactnum[i][j][k] += exactnum[i - 1][j][k] % mod\n if (j > 0):\n exactsum[i][j][k] += (exactsum[i][j - 1][k]\n * 10 + 5 * exactnum[i][j - 1][k]) % mod\n exactnum[i][j][k] += exactnum[i][j - 1][k] % mod\n if (k > 0):\n exactsum[i][j][k] += (exactsum[i][j][k - 1]\n * 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 %= mod\n\n return int(ans)\n",
"updated_at_timestamp": 1731573228,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef getSum(self, X, Y, Z):\n\t\t# code here"
} | eJydVMFKxDAQ9aD/EXJeZDKZmSR+yYKRPWgPXuIeurAgih+h/2uaVlgwSaslhRbmvXnz8pKP66/DzVV59vv8cf+qn9PxNOo7pU1MAqosvVN6OB+Hx3F4OrycxqWCxRhybGN6j0m/7dQFGmOyoMqKiYMqq8ETyJC3AbEQETIRMXKNNvcyoHCmJVA8yVsV6j2DyYxUKFk8IXmwy193iEI8d+g1IIbME+YJBIwTH9jXOLOtRb6iFpkBK94BQwO+4mbXP/Mz0aZBauCeC4bAWcLQABcPm2AnQNm0lmwppmHTNLFW0ENVeNm/6W1Kb9m0ptoxoBVm04qPXOanbR1ZyRm0Sya7Ado4wtQzxq3Fc/VaOn6httXVfNhmBLp8DkgcdbM8HanadSP8763rcv+Z+uHz9hu8l4qr |
703,636 | Magical String[Duplicate Problem] | You are given a string S, convert it into a magical string.
A string can be made into a magical string if the alphabets are swapped in the given manner: a->z or z->a, b->y or y->b, and so on.
Examples:
Input:
S = varun
Output:
ezifm
Explanation:
Magical string of "varun"
will be "ezifm"
since v->e , a->z ,
r->i , u->f and n->m.
Input:
S = akshay
Output:
zphszb
Explanation:
Magical string of "akshay"
will be "zphszb"
since a->z , k->p , s->h ,
h->s , a->z and y->b.
| geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static String magicalString(String S)"
],
"initial_code": "//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 S = read.readLine();\n\n Solution ob = new Solution();\n System.out.println(ob.magicalString(S));\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730436740,
"user_code": "//User function Template for Java\nclass Solution{\n static String magicalString(String S){\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"magicalString(ob,S)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n S = str(input())\n\n ob = Solution()\n print(ob.magicalString(S))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n # Function to convert a string to its \"magical\" form.\n def magicalString(self, S):\n \"\"\"\n This function takes a string as input and returns its \"magical\" form.\n\n The \"magical\" form of a string is obtained by replacing each character with\n the character at the opposite end of the alphabet. For example, 'a' becomes 'z',\n 'b' becomes 'y', and so on.\n\n Parameters:\n S (str): The input string.\n\n Returns:\n str: The \"magical\" form of the input string.\n \"\"\"\n\n # Define the alphabet string\n alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n\n # Get the length of the input string\n size = len(S)\n ans = \"\"\n\n # Iterate over each character in the input string\n for i in range(size):\n # Calculate the difference between the ASCII value of the current character\n # and the ASCII value of 'a' and use it to find the corresponding character\n # in the \"magical\" string representation\n d = ord(S[i]) - ord('a')\n ans += alphabet[25 - d]\n\n # Return the \"magical\" string\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def magicalString (ob,S):\n # code here "
} | eJy1VEuO1DAUZIHENVpZj5CAWXESJIKQYzu2E/vZ8S+O0YzmEHBBdtwCdw+oGRGnuxk6K0vxq1ev/KoeXn778erF4fvwvRw+fmkEmOCb97vmXQuow4T2jIthlAq0mazzIc5pyS3kJc0xeGcno0HJcRCc9ZTgDrWgBCGSNje7hiZDsafksw7+F+5W4f12z/Ib7DzreDg2dze7P/i+LX0RExjJFpy3ApinzldIQPY2ZX3A4UxY5VnkbA32TQtYKyNpEn6poCUJo47Ysm4N4bYMhboOY0Io7fsWGONciGEYR1m4KgWgtTHTZG1h7rwPIcZ5TqkmYF6WlOY5xhAO/bx3ztppMkY/TgQFVMpxHAYhHkfkjPU9pYRgXBnSWM0sUqroVuk7CulFLi+gfAUD1RhX7ufKfVTDrxXkWkWuUUI1Tsf9O7m/awjPcY25om3GE76Bp8ZRW85Rf1kH1r1zphj91dQI/yrHbzXURTkCW0FycQzAPgf+cwiofQrUI6A4bMP+KqN16x81g6Nojrpt0dQT1XjkJ6EvxVZng+9pn/fGZyw6XGnT1fNX/dPX1z8BfJsCqw== |
703,143 | Remove Spaces | Given a string, remove spaces from it.
Examples:
Input:
S = "geeks for geeks"
Output:
geeksforgeeks
Explanation:
All the spaces have been
removed.
Input:
S = " g f g"
Output:
gfg
Explanation:
All the spaces including
the leading ones have been removed.
| geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"String modify(String S)"
],
"initial_code": "//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 br = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine());\n while(t-- > 0)\n {\n String s;\n s = br.readLine();\n \n Solution ob = new Solution();\n \n System.out.println(ob.modify(s)); \n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution\n{\n \n String modify(String S)\n {\n // your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"modify(self, s)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n\n for _ in range(t):\n s = input().strip()\n ob = Solution()\n ans = ob.modify(s)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n # Function to modify the given string by removing spaces\n def modify(self, s):\n n = len(s)\n i, itr = 0, 0\n chars = list(s)\n\n # Iterate through the string\n while i < n:\n # Check if the current character is not a space\n if chars[i] != ' ':\n # Copy the non-space character to the new list\n chars[itr] = chars[i]\n itr += 1\n i += 1\n\n # Return only the modified part of the string without any extra characters\n return ''.join(chars[:itr])\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def modify(self, s):\n # code here"
} | eJylU8EKwjAM9bAPCTkPYVe/RLAiaZuBl7pDB4IofoQ7ePNTbaseHKRuNYdQSF5fXl57rYZHtUixvofD5oR71/UeV4CNckBYA/KxY+PZ7g69f9dIuYtyeK5hBAABIPSTNpZbiSQVJSYCDQYsMLQSaf6CEKFBhsojR+hsXOKLScdUeAeJGBkRCU0B1zwnv+UV6uMprnLW1hJLx7NPcbnJLrxg3yqE7G+syp/u33elyWkn7e1VzMnN6s0Kph+KP5K3t+UTqfZ0FA== |
702,732 | Sum of Series | Write a program to find the sum of the given series 1+2+3+ . . . . . . (n terms)
Examples:
Input:
n = 1
Output:
1
Explanation:
For n = 1, the sum will be 1.
Input:
n = 5
Output:
15
Explanation:
For n = 5, sum will be 15. 1 + 2 + 3 + 4 + 5 = 15.
Constraints:
1 <= n <= 10**9 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static long seriesSum(int n)"
],
"initial_code": "import 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;\n t = Integer.parseInt(br.readLine());\n while (t-- > 0) {\n\n int n;\n n = Integer.parseInt(br.readLine());\n\n Solution obj = new Solution();\n long res = obj.seriesSum(n);\n\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "\nclass Solution {\n public static long seriesSum(int n) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1663597771,
"func_sign": [
"seriesSum(self, n : int) -> int"
],
"initial_code": "if __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n n = int(input())\n obj = Solution()\n res = obj.seriesSum(n)\n print(res)\n print(\"~\")\n",
"solution": "class Solution:\n # Function to calculate the sum of a series\n def seriesSum(self, n):\n # calculating the sum of the series using the formula.\n sum = (n * (n + 1)) // 2\n return sum\n",
"updated_at_timestamp": 1729753320,
"user_code": "\nclass Solution:\n def seriesSum(self, n : int) -> int:\n # code here\n \n"
} | eJzNVc1OwzAM5sCBx5h6npBjx/nhSZAo4gA7cCk7bBISAvEQ8ELceCucpM06aLZ2aIhKda3I+b7Y/py+nr5/np3E5/JDnKun6r5ZrlfVxayiulEAUDcMEL8Kuqeaz6rF43Jxu1rc3TysV+0OCeQQ+CKxGHZFkxa425uduFw9z2c9Tqwb732mKvBo73kLlouAWrACXIRMuAVQlfC4heWMz8PIEqjiC9G0tvsUWbCtjyLk1kO2DNkHm2sYi2i5kJoa15ERVaceUq9TE/C5j556n9s/TQGpYUkHfSnsaxxFq+MmnkqKHY0wj0p5o+scvzlnSS1Imk3dWOdBfDksG/GDNr2zhjWh6qJCTIHfGhRNkPEm5S0qsYBaIxpMSwoEyikxSCRKTpVx1hIwenLOKTQulS2iOVkMSxBqV5AaKm21I6Nt4Vwo6E4TgFMkMKjQjS/EwJgeqzZSmnbw+gNfSHhnsgJMdjDJzUANJHbYjGlOItt7dPjH5IqOS7/1+9hzQY/9u7AYNcgmGfqJd5VWzvz+ukrq3DmKZKzVZngEtzoDB2Tx7VcZ+tM2J+f3kxL+5Fq/fjv/Anx4d6E= |
702,822 | Pair Sum Closest to 0 | Given an integer arrayofNelements. You need to find the maximum sum of two elements such that sum is closest to zero.
Examples:
Input:
N = 3
arr[] = {-8 -66 -60}
Output:
-68
Explanation:
Sum of two elements closest to
zero is -68 using numbers -60 and -8.
Input:
N = 6
arr[] = {-21 -67 -37 -18 4 -65}
Output:
-14
Explanation:
Sum of two elements closest to
zero is -14 using numbers -18 and 4.
Constraints:
2 ≤ N ≤5 *10**5
-10**6≤ arr[i] ≤ 10**6 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1618833982,
"func_sign": [
"public static int closestToZero(int arr[], int n)"
],
"initial_code": "//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 \n BufferedReader in=new BufferedReader(new InputStreamReader(System.in));\n PrintWriter out=new PrintWriter(System.out);\n int t = Integer.parseInt(in.readLine().trim());\n \n while(t-- > 0)\n {\n int n = Integer.parseInt(in.readLine().trim());\n int[] arr = new int[n];\n String s[]=in.readLine().trim().split(\" \");\n for (int i = 0; i < n; ++i)\n arr[i] = Integer.parseInt(s[i]);\n\n \t\tout.println (new Solution().closestToZero (arr, n));\n \nout.println(\"~\");\n}\n out.close();\n \n }\n}\n",
"script_name": "GfG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution\n{\n public static int closestToZero (int arr[], int n)\n {\n Arrays.sort(arr); // sorting the array\n \tint i = 0, j = n - 1;\n \tint sum = arr[i] + arr[j]; // initializing sum\n \tint diff = Math.abs (sum); // initializing the result\n \n \twhile (i < j)\n \t{\n \t // if we have zero sum, there's no result better. Hence, we return\n \t\tif (arr[i] + arr[j] == 0) \n \t\t\treturn 0;\n \t\t\t\n \t\t// if we get a better result, we update the difference\n \t\tif (Math.abs (arr[i] + arr[j]) < Math.abs (diff))\n \t\t{\n \t\t\tdiff = (arr[i] + arr[j]);\n \t\t\tsum = arr[i] + arr[j];\n \t\t}\n \t\telse if (Math.abs (arr[i] + arr[j]) == Math.abs (diff))\n \t\t{\n \t\t sum = Math.max(sum,arr[i] + arr[j]);\n \t\t}\n \n // if the current sum is greater than zero, we search for a smaller sum\n \t\tif (arr[i] + arr[j] > 0)\n \t\t\tj--;\n \t\t// else, we search for a larger sum\n \t\telse\n \t\t\ti++;\n \t}\n \treturn sum;\n }\n}",
"updated_at_timestamp": 1730468824,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public static int closestToZero (int arr[], int n)\n {\n // your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1618833982,
"func_sign": [
"closestToZero(self,arr, n)"
],
"initial_code": "# Initial Template for Python 3\n\nt = int(input())\nfor tc in range(t):\n n = int(input())\n arr = list(map(int, input().split()))\n ob = Solution()\n print(ob.closestToZero(arr, n))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def closestToZero(self, arr, n):\n arr.sort() # sorting the array\n\n i = 0\n j = n - 1\n sum = arr[i] + arr[j] # initializing sum\n diff = abs(sum) # initializing result\n\n while i < j:\n # if we have zero sum, there's no result better. Hence, we return\n if (arr[i] + arr[j] == 0):\n return 0\n\n # if we get a better result, we update the difference\n if (abs(arr[i] + arr[j]) < abs(diff)):\n diff = (arr[i] + arr[j])\n sum = arr[i] + arr[j]\n elif (abs(arr[i] + arr[j]) == abs(diff)):\n sum = max(sum, arr[i] + arr[j])\n\n # if the current sum is greater than zero, we search for a smaller sum\n if (arr[i] + arr[j] > 0):\n j -= 1\n\n # else, we search for a larger sum\n else:\n i += 1\n\n return sum\n",
"updated_at_timestamp": 1730468824,
"user_code": "#User function Template for python3\n\nclass Solution:\n def closestToZero (self,arr, n):\n # your code here"
} | eJytk0FOxDAMRVnAPb6ynqA6bdoMJ0GiiAV0wabMoiMhIRCHgNuw42I4qUdkOi1qWqKR3Eie7+dv5/388/viLJzrL/64eVGP7W7fqSsoqlvK6lZvw4GmLBxoK5GQgSA3yTokGbWBap53zX3XPNw97TsRZcG3ulWvGxxXclyIWJPrOOgKukSOAnZCRtOEDpkgJIS/6EzNgs7zeWKUEbUEOsAnopMdK+nkXkksj83LpBhMH/I+FH2IPXUDaxPpqhhudHLLdK0MzDAtiH9LBISgkAZN7rkmdKYm7k4aJAyEbeQqrbOzjB6EjMewld7RNYOJ31i4ebw1qLJvE38ZJm/n5oWOE5JTdGfmVgmNje//PzwAPdOE043B0pXRZP906fbj8gfZQo4n |
700,536 | Euler Circuit in an Undirected Graph | Eulerian Pathis a path in a graph that visits every edge exactly once. Eulerian Circuit is an Eulerian Path that starts and ends on the same vertex. Given the number of vertices v and adjacency list adj denoting the graph. Find that there exists the Euler circuit or not. Return 1 if there exist alteast one eulerian circuit else 0.
Examples:
Input:
v = 4
edges[] = {{0, 1},
{0, 2},
{1, 3},
{2, 3}}
Output:
1
Explanation:
corresponding adjacency list will be {{1, 2},{0, 3},{0, 3},{1, 2}}
One of the Eularian circuit
starting from vertex 0 is as follows:
0->1->3->2->0
Input:
v = 3
edges[] = {{0, 1},
{0, 2}}
Output:
0
Explanation:
corresponding adjacency list will be {{1, 2}}
No Eulerian path is found.
Constraints:
1 <= v <= 10**5
1 <= edges <= 2*10**5 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public boolean isEularCircuitExist(int v, ArrayList<ArrayList<Integer>> adj)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\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());\n while (T-- > 0) {\n String[] s = br.readLine().trim().split(\" \");\n int V = Integer.parseInt(s[0]);\n int E = Integer.parseInt(s[1]);\n ArrayList<ArrayList<Integer>> adj = new ArrayList<>();\n for (int i = 0; i < V; i++) adj.add(i, new ArrayList<Integer>());\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.isEularCircuitExist(V, adj);\n if (ans)\n System.out.println(\"1\");\n else\n System.out.println(\"0\");\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n // Method to check if an Eulerian circuit exists in a graph\n public boolean isEularCircuitExist(int V, ArrayList<ArrayList<Integer>> adj) {\n // Iterate through all vertices in the graph\n for (int i = 0; i < adj.size(); i++) {\n // Get the number of neighbors of the current vertex\n int listSize = adj.get(i).size();\n // If the number of neighbors is not even, return false\n if (listSize % 2 != 0) {\n return false;\n }\n }\n // Return true if all vertices have even degrees\n return true;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public boolean isEularCircuitExist(int v, ArrayList<ArrayList<Integer>> adj) {\n // Code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"isEularCircuitExist(self, v, adj)"
],
"initial_code": "# Initial Template for python3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n V, E = map(int, input().split())\n adj = [[] for i in range(V)]\n for _ in range(E):\n u, v = map(int, input().split())\n adj[u].append(v)\n adj[v].append(u)\n obj = Solution()\n ans = obj.isEularCircuitExist(V, adj)\n if (ans):\n print(\"1\")\n else:\n print(\"0\")\n",
"solution": "class Solution:\n\n def __init__(self):\n self.used = [] # list to keep track of whether an edge has been used\n self.eu = [] # list to store the vertices of each edge\n self.ev = [] # list to store the vertices of each edge\n self.ans = [] # list to store the result of the Eulerian circuit\n\n # Depth-first search function to find the Eulerian circuit\n def dfs(self, u, adj):\n while adj[u]: # as long as there are adjacent edges to visit\n e = adj[u].pop() # get the last adjacent edge\n if self.used[e]: # if the edge has been used, continue to the next iteration\n continue\n self.used[e] = True # mark the edge as used\n # recursively visit the other vertex of the edge\n self.dfs(self.eu[e] ^ self.ev[e] ^ u, adj)\n self.ans.append(u) # add the current vertex to the result\n\n # Function to check if an Eulerian circuit exists\n def isEularCircuitExist(self, v, adj):\n st = set() # set to store unique edges\n for i in range(v):\n for k in adj[i]:\n if (i, k) not in st and (k, i) not in st:\n self.eu.append(i) # add i to the list eu\n self.ev.append(k) # add k to the list ev\n st.add((i, k)) # insert the edge (i, k) to the set\n adj1 = [[] for _ in range(v)] # create an empty adjacency list\n # initialize the used list with False values\n self.used = [False] * len(self.eu)\n for i in range(len(self.eu)):\n # add the index of the edge to the adjacency list of eu[i]\n adj1[self.eu[i]].append(i)\n # add the index of the edge to the adjacency list of ev[i]\n adj1[self.ev[i]].append(i)\n for i in range(v):\n if len(adj1[i]) % 2: # check if there is an odd number of adjacent edges to a vertex\n return False # if so, return False\n self.ans.append(0) # add the starting vertex to the result\n self.dfs(0, adj1) # call the dfs function to find the Eulerian circuit\n # check if the number of vertices in the result is not equal to the number of edges + 1\n if len(self.ans) != len(self.eu) + 1:\n return False # if so, return False\n return True # otherwise, return True indicating that an Eulerian circuit exists\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef isEularCircuitExist(self, v, adj):\n\t\t#Code here"
} | eJylVMsOgjAQ5KDxNzY9E9MHEPVLTMR4UA5ekAMkJsbEj9D/tbsQ3sQu9sCj7MxOO1Nei89q6dHYe/bh8BDXNCtysQOh4lSBjFPhg0juWXLOk8vpVuTNZ/H0oQvQYC8S1ARGjmM0YdhAA6YCKqTQIDlSB2hW7wDCLtogo8Q5zeEJIRrhCbABkRke2aa3IUTRZlT4qiHg0EawndIYYtNy1fO4lcTBj1kdGU5mUOhEcb/SvfRHGOwcKxBmXiRJsLviZttrf83fBg+tIlWVXzHdS51t9+qj72qN1eG8zvKQO/8jju/1F5Pdejc= |
701,339 | Evaluation of Postfix Expression | Given string Srepresenting apostfix expression, the task is to evaluate the expression and find the final value. Operators will only include the basic arithmetic operators like *, /, + and -.
Examples:
Input:
S = "231*+9-"
Output:
-4
Explanation:
After solving the given expression,
we have -4 as result.
Input:
S = "123+*8-"
Output:
-3
Explanation:
After solving the given postfix
expression, we have -3 as result.
0 ≤ |S
i
|≤ 9 (And given operators) | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1619436835,
"func_sign": [
"public static int evaluatePostFix(String S)"
],
"initial_code": "import java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nclass GFG {\n \n\tpublic 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());\n\t\twhile(t-->0){\n\t\t System.out.println(new Solution().evaluatePostFix(br.readLine().trim()));\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution\n{\n //Function to evaluate a postfix expression.\n public static int evaluatePostFix(String S)\n {\n // Your code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619436835,
"func_sign": [
"evaluatePostfix(self, S)"
],
"initial_code": "# Initial Template for Python 3\n\nimport atexit\nimport io\nimport sys\n\n# This code is contributed by Nikhil Kumar Singh(nickzuck_007)\n\n_INPUT_LINES = sys.stdin.read().splitlines()\ninput = iter(_INPUT_LINES).__next__\n\n_OUTPUT_BUFFER = io.StringIO()\nsys.stdout = _OUTPUT_BUFFER\n\n\n@atexit.register\ndef write():\n sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())\n\n\nif __name__ == '__main__':\n test_cases = int(input())\n for cases in range(test_cases):\n S = input()\n obj = Solution()\n print('{0:g}'.format(float(obj.evaluatePostfix(S))))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to evaluate a postfix expression.\n def evaluatePostfix(self, S):\n stack = []\n\n # iterating over the given string.\n for i in S:\n # if current character is an operand, we push it to the stack.\n if i.isdigit():\n stack.append(i)\n # else current character is an operator.\n else:\n # we pop and store the values of first two elements of stack.\n val1 = stack.pop()\n val2 = stack.pop()\n\n # we perform required operation and push the result in stack.\n if i == '/':\n p = \"//\"\n stack.append(str(eval(val2 + p + val1)))\n else:\n stack.append(str(eval(val2 + i + val1)))\n\n # returning the top element of the stack.\n return stack.pop()\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to evaluate a postfix expression.\n def evaluatePostfix(self, S):\n #code here"
} | eJytVEFOxDAM5IAEN75Q5ZhsCLGTtOUlSARxgB64hD10JSQE4hHwX0Kzuy1q3Q1se2nTyGPPeOyP06+Ls5PuuTmPH7ev7CmsNy27Lhj6AKi5qKUPGlDwKn7UlbEguHSKrQrWvKybh7Z5vH/etNsoaXx490FieqUTe1sVA2Ttg0MDSvBSEjCAU4HggzUcQShXSa5FrAdNPJSCA4Ukyw5JawKwMtyiku4HrFQmsgRBQGGCkkCQKp01UZuK1MYRgbVREPMTYZSGGlRkzy3J3FLpdD1T5RURhTVdoqYkAS2Rk2GTTaZ9N+Sc78HJxifRD1h8pieTlfcWGMH7A6n6f/x3frJNh2lhl5iw+Fjarr//5X1s1uH0bCtI7tF/tU+/XKioSYOP+rOclLsbnrM4U1vzB8MtspFn3SlyoaklkKtjxuTvR39/v5N7SUPdfV5+Az+BAk0= |
704,961 | Face off Tournament | Ram and Rohan are participating in a tournament where they must compete against contenders whose strengths are given in an array arr[]. Ram's strength is m, and Rohan's strength is n. They take turns competing against the contenders, with Ram always going first. A contender is defeated if their strength is an exact multiple of either Ram's or Rohan's strength. Once defeated, a contender cannot compete again.
Examples:
Input:
arr[] = [4, 5, 7, 6, 9, 10, 14], m = 2, n = 3
Output:
"Ram"
Explanation:
Ram wins against contenders with strengths [4, 6, 10, 14]. Rohan wins against the contender with strength [9].
Input:
arr[] = [1, 9, 9, 10, 9, 18], m = 5, n = 3
Output:
"Rohan"
Explanation:
Ram wins against the contender with strength [10]. Rohan wins against contenders with strengths [9, 9, 9, 18].
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ m, n ≤
10**6
1 ≤ arr[i] ≤
10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public String winner(int[] arr, int m, int n)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\npublic class Main {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n int t = scanner.nextInt();\n scanner.nextLine(); // Consume the newline character\n\n while (t-- > 0) {\n String input = scanner.nextLine();\n String[] inputArray = input.split(\" \");\n int[] arr = new int[inputArray.length];\n for (int i = 0; i < inputArray.length; i++) {\n arr[i] = Integer.parseInt(inputArray[i]);\n }\n\n input = scanner.nextLine();\n String[] mn = input.split(\" \");\n int m = Integer.parseInt(mn[0]);\n int n = Integer.parseInt(mn[1]);\n\n Solution solution = new Solution();\n System.out.println(solution.winner(arr, m, n));\n System.out.println(\"~\");\n }\n scanner.close();\n }\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public String winner(int[] arr, int m, int n) {\n // code here\n }\n}\n"
} | {
"class_name": null,
"created_at_timestamp": 1615292571,
"func_sign": [
"winner(arr, m, n)"
],
"initial_code": "def main():\n t = int(input())\n for _ in range(t):\n arr = list(map(int, input().split()))\n m, n = map(int, input().split())\n print(winner(arr, m, n))\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "def winner(arr, m, n):\n c1, c2 = 0, 0\n\n # Iterating over the array to count the number of divisibles\n for num in arr:\n if num % m == 0:\n c1 += 1\n elif num % n == 0:\n c2 += 1\n\n # Determining the winner based on the counts\n if c1 > c2:\n return \"Ram\"\n elif c2 > c1:\n return \"Rohan\"\n else:\n return \"Both\"\n",
"updated_at_timestamp": 1729753320,
"user_code": "def winner(arr, m, n):\n #code here"
} | eJy1VEtKRDEQdCF4jeKtRdJJ5+fSI7gSfCKiA7rwjYsRBFE8hB7FnYez05l5+OHJxNFmmAozSSrpqtTT9svbzpbW0asMju+7q+HmdtHto6N+IKMFX8EqIlag+pt+O53QD378o9tFN7u7mZ0vZhen89vFctPDs+t+eOyH7mEXn7lyTpbZeQeyjn2IKSOnGDw7S1ieRLeHheuHCKIJkoP54nKSRXgcCsSs4CuETxx+NRpX2KkLzS/PhgkyMpalQZzAJgckyhYUXGI4G0NC8N4FkCMTbT+Mc5pbJ913BsGYIN2xRj6wLNwGnITdIAfZW+5ihapo5X6hTintVE4VYoVQwVfgCrXDcl0FqlAOgHZqGnVfc/RhSbtBirsYSXQSkRBYGprE+AGeRKNQpGu/QYRj2QCiefJyULEBZRFexC9+j0bnUG7e2WuBteC0YLWEohSCFqIWkhaWctLK5GWirGnjn37l0yKumSQbRMkPK9q8Zf7BXMZwO58ouYqhdusVO9ecGT29uaG/ZTW+hnV98B+zOk/1a/2Xv/nD/ymt21PUcfuVJE40DepJ/yITTp733gFPaQTZ |
703,770 | Find the Highest number | Given an integer array a[] of size n, find the highest element of the array. The array will either be strictly increasing or strictly increasing and then strictly decreasing.
Examples:
Input:
11
1 2 3 4 5 6 5 4 3 2 1
Output:
6
Explanation:
Highest element of array a[] is 6.
Input:
5
1 2 3 4 5
Output:
5
Explanation:
Highest element of array a[] is 5.
Constraints:
2 <= n <= 10**6
1 <= a[i] <= 10**6 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1619347091,
"func_sign": [
"public int findPeakElement(List<Integer> a)"
],
"initial_code": "import java.io.*;\nimport java.lang.*;\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());\n while (T-- > 0) {\n String s = br.readLine().trim();\n int n = Integer.parseInt(s);\n String S = br.readLine();\n String[] s1 = S.split(\" \");\n List<Integer> a = new ArrayList<Integer>();\n for (int i = 0; i < n; i++) {\n a.add(Integer.parseInt(s1[i]));\n }\n Solution ob = new Solution();\n int ans = ob.findPeakElement(a);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public int findPeakElement(List<Integer> a) {\n int l = 0;\n int r = a.size() - 1;\n\n // Binary search to find the peak element.\n while (l < r) {\n // Calculating the mid index.\n int mid = (l + r) / 2;\n\n // Checking if the element at mid is greater than the element on its right.\n // If yes, then the peak should be on the left side of the array.\n if (a.get(mid) > a.get(mid + 1)) {\n r = mid;\n }\n // If not, then the peak should be on the right side of the array.\n else {\n l = mid + 1;\n }\n }\n\n // Returning the peak element.\n return a.get(l);\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public int findPeakElement(List<Integer> a) {\n // Code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619347091,
"func_sign": [
"findPeakElement(self, a)"
],
"initial_code": "if __name__ == '__main__':\n T = int(input())\n for i in range(T):\n n = int(input())\n a = list(map(int, input().split()))\n ob = Solution()\n ans = ob.findPeakElement(a)\n print(ans)\n\n print(\"~\")",
"solution": "from typing import List\n\n\nclass Solution:\n\n def findPeakElement(self, a: List[int]) -> int:\n # Initializing left and right pointers.\n l = 0\n r = len(a) - 1\n\n # Binary search to find the peak element.\n while l < r:\n # Calculating the mid index.\n mid = (l + r) // 2\n\n # Checking if the element at mid is greater than the element on its right.\n # If yes, then the peak should be on the left side of the array.\n if a[mid] > a[mid + 1]:\n r = mid\n\n # If not, then the peak should be on the right side of the array.\n else:\n l = mid + 1\n\n # Returning the peak element.\n return a[l]\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nfrom typing import List\n\nclass Solution:\n\tdef findPeakElement(self, a):\n\t\t# Code here\n"
} | eJylVNtqFVEM9UH8jsU8F9m57CS7XyI44oOeBxHGIqcgiMWP0P81ezjQFkzbwxmGYZjZWclaK8nv13+/v3m1X+++5sv7n8uX7eb2uFxjoXWzdSNQ2y8wBIq+XGE5/Lg5fDoePn/8dns8ne7rdrduy68rPIagNjFOsTA4AiMxC5h5/L84vONIYviMz7IE1EEOGuAGCpCBFMSJnkksE3KRhasssW73RU4EKhBGASB5g+rElUr9nt3k1icladCGns8OyS99Eiv1ryj59OARXAKdjcK7i2eyyu9cKlhK0YqO2YXh3Xfdrbfd/Tg1AGcMgwWskyEb2MEBHpO5pLoJKRCdWopBHBKQMUVRgjI0M+oUW9N5hwZ0TL06oTN6upMFpXaG7uiBni3SYARjmMAUlvUazGHZfwPe4ARnuMAVnu4mHYcHfCCySwnBCEEooiMMkWwDMTAaBmEwhmAoRscwjOz9FGOqUQ9QZSHZQ2E9nh/GPPSypop4uq3m/5cgVfFabZc5bkWMXLxILt4kZ67KuW0rV5+YsLK0csIeaJ49pt0ucrDY8M8szg9/3v4DQ7u38Q== |
703,913 | Factorial | Given a positive integer,N. Find the factorial of N.
Examples:
Input:
N = 5
Output:
120
Explanation:
5*4*3*2*1 = 120
Input:
N = 4
Output:
24
Explanation:
4*3*2*1 = 24
Constraints:
0 <= N <= 18 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1619259404,
"func_sign": [
"static long factorial(int N)"
],
"initial_code": "import 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 int N = Integer.parseInt(read.readLine());\n Solution ob = new Solution();\n System.out.println(ob.factorial(N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n static int factorial(int N) {\n int ans = 1;\n for (int i = 2; i <= N; i++) ans = ans * i;\n return ans;\n }\n}\n",
"updated_at_timestamp": 1730473589,
"user_code": "class Solution{\n static long factorial(int N){\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619259404,
"func_sign": [
"factorial(self, N)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n ob = Solution()\n print(ob.factorial(N))\n print(\"~\")\n",
"solution": "class Solution:\n def factorial(self, N):\n ans = 1\n # Calculating the factorial\n for i in range(2, N+1):\n ans = ans*i\n return ans\n",
"updated_at_timestamp": 1730473589,
"user_code": "#User function Template for python3\nclass Solution:\n def factorial (self, N):\n # code here"
} | eJytU7lOw0AQpUD0dJSR6wjNffAlSARRQAoaQxEkJATiI+B/GYeCpJhAUNbFru15x87xfvx5dnK0Xpendbh6Ge7Hx6fVcDEbcDHCMJ8Ny+fH5e1qeXfz8LT6+fW2GIfX+Ww7HqMBmACxs4M6BQB0+D31uJPr+L0BsKqFS3lL6+1Zg3ZqL9RlkI0iWiFqUNTE506Vzpt22WZwc2HbVakS3bda9I2boNBWQhESUggdvXaB3sMG32HZDkGHm5SLdbon4rYfMtH6hkDtgOrIHJxqIhoqmiAeyRSmZAhaJhkjVVk9DBDJBINUgl2DGT2DEklClLOYuCLURSLMlRGxvrsjeNQjVhoEgkZmRgqYYYUEEbOaopTE1CQCm0gqV/UCqV7qZYvK2GSEyqVIGomTlEc0T3AixKhrCDsSkWUZUIK/rN+LOm3pXc/u2SiJ26w7ZvBfLQgHbuoxx3+N3PXH+Rc9grm6 |
706,447 | Shortest Unique prefix for every word | Given an array of words, find all shortest unique prefixes to represent each word in the given array. Assume that no word is prefix of another.
Examples:
Input:
N = 4
arr[] = {"zebra", "dog", "duck", "dove"}
Output:
z dog du dov
Explanation:
z => zebra
dog => dog
duck => du
dove => dov
Input:
N = 3
arr[] = {"geeksgeeks", "geeksquiz",
"geeksforgeeks"};
Output:
geeksg geeksq geeksf
Explanation:
geeksgeeks => geeksg
geeksquiz => geeksq
geeksforgeeks => geeksf
Example 2: | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static String[] findPrefixes(String[] arr, int N)"
],
"initial_code": "//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 arr[] = read.readLine().split(\" \");\n\n Solution ob = new Solution();\n String[] res = ob.findPrefixes(arr,N);\n \n for(int i=0; i<res.length; i++)\n System.out.print(res[i] + \" \");\n System.out.println();\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1727947200,
"user_code": "//User function Template for Java\n\nclass Solution {\n static String[] findPrefixes(String[] arr, int N) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"findPrefixes(self, arr, N)"
],
"initial_code": "# Initial Template for Python 3\n\nimport sys\nsys.setrecursionlimit(10**6)\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n arr = list(map(str, input().split()))\n\n ob = Solution()\n res = ob.findPrefixes(arr, N)\n for i in res:\n print(i, end=\" \")\n print()\n print(\"~\")\n",
"solution": "class TrieNode:\n def __init__(self):\n self.child = dict() # Dictionary to store children nodes\n self.count = 0 # Count of how many times this node has been visited\n self.endOfWord = False # Flag to indicate if this node marks the end of a word\n\n\nclass Trie:\n def __init__(self):\n self.root = TrieNode() # Creating the root node of the trie\n\n # Function to insert a word into the trie\n def insert(self, word):\n ptr = self.root # Starting from the root node\n for c in word:\n ptr.count += 1 # Incrementing the count of the current node\n # Creating a child node if it doesn't exist\n ptr.child[c] = ptr.child.get(c, TrieNode())\n ptr = ptr.child[c] # Updating the pointer to the child node\n ptr.endOfWord = True # Marking the end of the word in the trie\n\n # Function to get the unique prefix of a word in the trie\n def getUniquePrefix(self, word):\n ptr = self.root # Starting from the root node\n ans = '' # Variable to store the unique prefix\n for c in word:\n ans += c # Appending the current character to the prefix\n ptr = ptr.child[c] # Updating the pointer to the child node\n if ptr.count <= 1: # If the current node has been visited only once, break the loop\n break\n return ans # Returning the unique prefix\n\n\nclass Solution:\n def findPrefixes(self, arr, N):\n trie = Trie() # Creating an instance of the trie\n for word in arr:\n trie.insert(word) # Inserting each word into the trie\n unique = [] # List to store the unique prefixes\n for word in arr:\n # Getting the unique prefix of each word and adding it to the list\n unique.append(trie.getUniquePrefix(word))\n return unique # Returning the list of unique prefixes\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def findPrefixes(self, arr, N):\n # code here "
} | eJzFV8ty0zAUZcGWP2BxJ2w7DB3efAkzmGEc69pWI0uJJNMEBoaPgP9Fjys7TavGadLWi+hIkc45lq505T9P/7149iQ8n5878OXnjMtlb2efYHZeyLeFLMcHYjEfcTVAxgJEeuq6LuTsDGa4XmJlkX1TvSXeHTZiiiyAUMjfbuivM7hq5fyV8zKvXI+6aYFfLAR0Ui1hpY2F/vvlGjY/HFnFsIam5RewEJ3Me3BCHDpYQQ8bqKCBRU74QyFbFEJdKi0YBGh6ScCWOqJOKQlYatuGtoC22noCgSTrKuokjSRBAomduBMx8ebcvyvkUmPN16av3S/ESscZE0gVb9gSRtakZpSMkNWIWc+JPTEPpAPjwJfocl7fF7KXfNVj7Aex4n1ExGVDyDsiWPsZi1BsBhDLrGmSSQqJP7En6uu8OetvYnD62HShN8DFCMUIu3xYTue4ZcGFkg0a62KNQcDaoLQoKwzVUjLjJy1g44MLaIRB95Kpm6+3SltXZv0mJZIhemIeWUe+nOvXbv6k5Ywb162cC27aznkuNS8lNx34P1vUKoK+K2/Z2p6HBlD3nKo73tYboZatkggeNbpcthG5cB1aNgHy/MYNLNcYdhp4zsbHQrp5d3GnlJi7w8NXfKzHRt5hRPEP7BQj4GY6AEVl3MhxVKkbzK8byUWlpLOjkkRIgyQS/Z6FdFFl4vHolnT/+h6/6A/g5xjpCbk05k2/HSfYxgN8P8zbHpgmhwR5v/kSr2bLPcnyPlL97lFaPM494Ih9sG34jrvwxsy+dam7KcnvpvIJSZ8O7im5nyxMum2Ge+bUG2cxxMgJ7p6Pc4RkBvsZOcXZgocfLnf9DhlukCf4IPn69+V/IkHhjw== |
702,675 | Count minimum right flips to set all values in an array | A wire connects light bulbs. Each bulb has a switch associated with it, however, due to faulty wiring, a switch also changes the state of all the bulbs to the right of the current bulb. Given the initial state of all bulbs, find the minimum number of switches you have to press to turn on all the bulbs. "0 represents the bulb is off and 1 represents the bulb is on."Examples:
Examples:
Input:
arr[] = [0, 0, 0, 0]
Output:
1
Explanation:
From the given set of bulbs change the state of the first bulb from off to on, which eventually turn the rest three bulbs on the right of it.
Input:
arr[] = [1, 0, 0, 1]
Output:
2
Explanation:
First click the second bulb then click the third bulb.
Constraints:
1 ≤ arr.size() ≤ 10**6
0≤ arr[i] ≤ 1** | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static int countFlips(int[] arr)"
],
"initial_code": "// Initial Template for Java\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\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());\n while (t-- > 0) {\n String line = br.readLine();\n String[] tokens = line.split(\" \");\n\n // Create an ArrayList to store the integers\n ArrayList<Integer> array = new ArrayList<>();\n\n // Parse the tokens into integers and add to the array\n for (String token : tokens) {\n array.add(Integer.parseInt(token));\n }\n\n int[] arr = new int[array.size()];\n int idx = 0;\n for (int i : array) arr[idx++] = i;\n Solution obj = new Solution();\n int res = obj.countFlips(arr);\n\n System.out.println(res);\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n public static int countFlips(int[] arr) {\n int c = 0; // initialize a counter variable\n int n = arr.length;\n // loop through the array\n for (int i = 0; i < n; i++) {\n // check if the current index is even and the element at that index is 0\n if (c % 2 == 0 && arr[i] == 0) {\n c++; // increment the counter\n }\n // check if the current index is odd and the element at that index is 1\n if (c % 2 != 0 && arr[i] == 1) {\n c++; // increment the counter\n }\n }\n return c; // return the final count\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public static int countFlips(int[] arr) {\n // code here.\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"countFlips(self,arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n arr = list(map(int, input().split()))\n ob = Solution()\n res = ob.countFlips(arr)\n print(res)\n print(\"~\")\n t -= 1\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n # Function to count the number of flips required to make all elements same.\n def countFlips(self, arr):\n c = 0\n n = len(arr)\n # iterating over the array.\n for i in range(0, n):\n # if current count is even and current element is 0,\n # increment the count.\n if (c % 2 == 0 and arr[i] == 0):\n c += 1\n # if current count is odd and current element is 1,\n # increment the count.\n if (c % 2 != 0 and arr[i] == 1):\n c += 1\n\n # returning the count.\n return c\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def countFlips(self,arr):\n #code here\n\n"
} | eJxrYJnqyMoABhFWQEZ0tVJmXkFpiZKVgpJhTB4QKekoKKVWFKQml6SmxOeXlkAlDWLy6oCStToKqDoMcOowxKHDUAEKSbcLqAsN47YdlyEYRijg9oIlTodgQDKCAd0M3J4xImAG6TrBuhQMCeg2IRCGMNKAoEkWuEzCFRKkpg14qsKVTkhObWCnkawH7n4ojRbQRPgQV5SR5wGYa6gQwFjinIxINzDAoRqrlWDj8cUEzqyB8DyBcCAveGKn6AEALneC/Q== |
705,573 | Closest Triplet | Given three sorted arrays A[] of size P, B[] of size Q and C[] of size R.Find a number X such that when 3 elements i, j and k are chosen from A, B and C respectively,thenX=max(abs(A[i] – B[j]), abs(B[j] – C[k]), abs(C[k] – A[i])) is minimized. Here abs() indicates absolute value.
Examples:
Input:
P=3
A[] = {1, 4, 10}
Q=3
B[] = {2, 15, 20}
R=2
C[] = {10, 12}
Output:
5
Explanation:
We take 10 from A, 15 from B and
10 from C, so,
X=max(abs(10-15),abs(15-12),abs(10-10))
which gives X=18
Input:
P=3
A[] = {20, 24, 100}
Q=5
B[] = {2, 19, 22, 79, 800}
R=5
C[] = {10, 12, 23, 24, 119}
Output:
2
Explanation:
We take 24 from A,22 from B and 24 from C.X
=max(abs(24-22),max(abs(24-22),abs(24-24)))
which is 2.
Constraints:
1<=P,Q,R<=10**4
1<=A[i],B[j],C[k]<=10**6
where 0<=i<P , 0<=j<Q , 0<=k<R | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int findClosest(int P, int Q, int R, int A[], int B[], int C[])"
],
"initial_code": "// 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 P, Q, R, i;\n P = Integer.parseInt(read.readLine());\n int A[] = new int[P];\n String s1[] = read.readLine().split(\" \");\n for (i = 0; i < P; i++) A[i] = Integer.parseInt(s1[i]);\n Q = Integer.parseInt(read.readLine());\n int B[] = new int[Q];\n String s2[] = read.readLine().split(\" \");\n for (i = 0; i < Q; i++) B[i] = Integer.parseInt(s2[i]);\n R = Integer.parseInt(read.readLine());\n int C[] = new int[R];\n String s3[] = read.readLine().split(\" \");\n for (i = 0; i < R; i++) C[i] = Integer.parseInt(s3[i]);\n Solution ob = new Solution();\n System.out.println(ob.findClosest(P, Q, R, A, B, C));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n // Function to find closest elements in three arrays\n // and return the maximum difference between any two of them.\n int findClosest(int P, int Q, int R, int A[], int B[], int C[]) {\n // Initialize variables to store the minimum difference,\n // and the indices of the elements with the minimum difference.\n int diff = Integer.MAX_VALUE;\n int res_i = 0;\n int res_j = 0;\n int res_k = 0;\n // Initialize loop variables.\n int i = 0, j = 0, k = 0;\n // Iterate through the arrays simultaneously.\n while (i < P && j < Q && k < R) {\n // Find the minimum and maximum elements among the current three elements.\n int minimum = Math.min(A[i], Math.min(B[j], C[k]));\n int maximum = Math.max(A[i], Math.max(B[j], C[k]));\n // Update the minimum difference and indices if a smaller difference is found.\n if (maximum - minimum < diff) {\n res_i = i;\n res_j = j;\n res_k = k;\n diff = maximum - minimum;\n }\n // If the minimum difference is 0, break out of the loop.\n if (diff == 0) break;\n // Move the pointers to the next element in the array with the minimum element.\n if (A[i] == minimum) i++;\n else if (B[j] == minimum) j++;\n else k++;\n }\n // Calculate the absolute differences between the selected elements.\n int x1 = Math.abs(A[res_i] - B[res_j]);\n int x2 = Math.abs(C[res_k] - B[res_j]);\n int x3 = Math.abs(A[res_i] - C[res_k]);\n // Return the maximum difference.\n return Math.max(x1, Math.max(x2, x3));\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n int findClosest(int P, int Q, int R, int A[], int B[], int C[]) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"findClosest(self, P, Q, R, A, B, C)"
],
"initial_code": "# Initial Template for Python 3\n\nimport math\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n P = int(input())\n A = list(map(int, input().strip().split(\" \")))\n Q = int(input())\n B = list(map(int, input().strip().split(\" \")))\n R = int(input())\n C = list(map(int, input().strip().split(\" \")))\n ob = Solution()\n print(ob.findClosest(P, Q, R, A, B, C))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def findClosest(self, P, Q, R, A, B, C):\n # initialize the difference as a very large number\n diff = int(1e10)\n res_i = 0\n res_j = 0\n res_k = 0\n i = 0\n j = 0\n k = 0\n\n # iterate until we reach the end of any list\n while i < P and j < Q and k < R:\n # find the minimum and maximum value from the three lists\n minimum = min(A[i], min(B[j], C[k]))\n maximum = max(A[i], max(B[j], C[k]))\n\n # check if the difference between maximum and minimum is smaller than current minimum difference\n if maximum - minimum < diff:\n # update the indices and difference\n res_i = i\n res_j = j\n res_k = k\n diff = maximum - minimum\n\n # if difference becomes 0, then we have found the closest elements, so break the loop\n if diff == 0:\n break\n\n # increment the index of the list with the minimum value\n if A[i] == minimum:\n i += 1\n elif B[j] == minimum:\n j += 1\n else:\n k += 1\n\n # calculate the absolute differences of the closest elements\n x1 = abs(A[res_i] - B[res_j])\n x2 = abs(C[res_k] - B[res_j])\n x3 = abs(A[res_i] - C[res_k])\n\n # return the maximum absolute difference among the closest elements\n return max(x1, max(x2, x3))\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def findClosest(self, P, Q, R, A, B, C):\n #code here"
} | eJztmMGOJDUMhgeJp4BL1OcVimMnqeJJkFjEAebAZdjDroSEQDwEvCwn/t/5CzVoa2HEsLDQI8We6bK/OLHj1PQP7//03od3+fPJzx/c3X367eWrhxevXl4+Lhd7/mAVo7QSZSs2ircyoljbSuujdGvLwsvAh6VFia3s+H1vxbcoc8Cr+1hWvVgtrZaoZaugVeAqeJXASmK9PCuX+29e3H/x8v7Lz79+9VKBYJrvnz9cvntWfhtdJ7gSCuEUQdEh1sPOhxROERS9Hw8bH1I4RVB0iJMY0u21UWzcIi+9zLIXs2KORefH3LfBneMSi2HnRn5ey++fnExqJ1POtXAuds+fpbal5lJjqb5ULC/M7Ji7Y/aZn/SFSWVLtaV8qViqLzVOIs05/CTcrKLMvWf6O9Jey8w62LEDtcqmI1vIFTKFPJWBLe1lwwJYOv2oomuT6+fYyX6WvLPAVgWVtuqH5cNlIjqGx/gYYEYIQcusGqOt0diyLBLDBWI4RmB0jIExMTaMnamuFJZJp6Ct0di6CcPtwGgYjhEYHWNgTIxtZ8ZJoqCl0dRoazA+O0BntdvyfOOkZiU6z7jtOBXcZJxyR2FH8cmkBepmICAcEu5835Y3/mAdW5b3ZI6blzawAnYLJMo37EcJ9IbJxHeUFVrHvrzZOfY8AkgfuoqxibTJOnEvjo6z42Qy2egsHfWJapzl0Y2i9VXozMo65YiDItQREBMFc96Z9L6vKsgcQtBj0GPQY2SN0GPQY9Bj7KtmMuMQ9Jj0mMESWRFw/UbRcicogqJTDIpJsVHseUoo6DHoMegx6DHoMegx6DHoMegx6THpMekx6THhsSIImvxDYZz21ZOc+R82jbJOUp5HHkeexrxXDFa26STVdS5bViZG5JWAEsWAXV49ex5/zfnGJoQ5s9FgTgyYGGwMRjZZwRiwa7Br5PAUwa4FmRiwa5MnCwN2zqbm62p8a7M+skX2etw1ec3qotVVe1wc66zoAKy+WVfrrOqeRwOt6qFVbbSqk1Y109SCmWgmnO3XcWRalxavidfEa+I18Zp4Tby2Xy8oW/fSx0LFc/FcPBfPxXPxfL/embwGlhYvjp0TL8QL8UK8EC/EW2ZVuehXa1NIImUnU3tiLpbaltqXQjEtLY4JZCKZUCaWCWaimXAmXhOvHXGJ18RrccQrLV4Tr4nXxHPxXDw/Fiqex7FwafFcPBfPxQvxQrwQL46di2MHpcUL8UK8EK8v3srFrq3QCjTxVe7yHtHlUPMGz4wstcu9SotjAplIJpSJZYKZaLYdYSgO8doRl3hNvCZeE6+J18Rr27EeLUg8F8+PhYrn4rl4Lp6L59uxMdoZ8UK8EC+OnRMvxAvxQrzYjh1Off66fvrC/viXHsX0Tr773Br4rYHXWwN/Bxp4vXXwP9nBn+oLhfK6bxSOyvwrXyw8xXdC7KqP/F7oatrO6+rtzfx3ZOTXf9xHqJ6eKEH1DWX3pJv6pPuY/5n/6/byf/WGcXvFSH17xVAubq8Y/5lXjM9+/OgXDqajew== |
702,919 | Maximum Product Subarray | Given an array arr[] that contains positive and negative integers (may contain 0 as well). Find the maximum product that we can get in a subarray of arr.
Examples:
Input:
arr[] = [6, -3, -10, 0, 2]
Output:
180
Explanation:
The subarray [6, -3, -10] gives max product as 180.
Input:
arr[] = [2, 3, 4, 5, -1, 0]
Output:
120
Explanation:
The subarray [2, 3, 4, 5] gives max product as 120.
Input:
arr[] = [2, 3, 4]
Output:
24
Explanation:
For an array with all positive elements, the result is product of all elements.
Constraints:
1 ≤ arr.size() ≤ 500
-10**2≤ arr[i] ≤ 10**2 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1731059423,
"func_sign": [
"int maxProduct(int[] arr)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\npublic class Main {\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());\n while (tc-- > 0) {\n String[] inputLine = br.readLine().split(\" \");\n int n = inputLine.length;\n int[] arr = new int[n];\n for (int i = 0; i < n; i++) {\n arr[i] = Integer.parseInt(inputLine[i]);\n }\n System.out.println(new Solution().maxProduct(arr));\n }\n }\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1731059423,
"user_code": "class Solution {\n // Function to find maximum product subarray\n int maxProduct(int[] arr) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1731059423,
"func_sign": [
"maxProduct(self,arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n tc = int(input())\n while tc > 0:\n arr = list(map(int, input().strip().split()))\n ob = Solution()\n ans = ob.maxProduct(arr)\n print(ans)\n tc -= 1\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n\n # Function to find maximum\n # product subarray\n def maxProduct(self, arr):\n n = len(arr)\n # Variables to store maximum and\n # minimum product till ith index.\n minVal = arr[0]\n maxVal = arr[0]\n\n maxProduct = arr[0]\n\n for i in range(1, n, 1):\n # When multiplied by -ve number,\n # maxVal becomes minVal\n # and minVal becomes maxVal.\n if (arr[i] < 0):\n temp = maxVal\n maxVal = minVal\n minVal = temp\n\n # maxVal and minVal stores the\n # product of subarray ending at arr[i].\n maxVal = max(arr[i], maxVal * arr[i])\n minVal = min(arr[i], minVal * arr[i])\n\n # Max Product of array.\n maxProduct = max(maxProduct, maxVal)\n\n # Return maximum product\n # found in array.\n return maxProduct\n",
"updated_at_timestamp": 1731059423,
"user_code": "#User function Template for python3\nclass Solution:\n\n\t# Function to find maximum\n\t# product subarray\n\tdef maxProduct(self,arr):\n\t\t# code here"
} | eJylUkFOwzAQ5ABP4MZh5XMXrTeOG3gJEkUcIAcuoYdUQkJIPKL9L2s3rSjxWJWwE9mH3fHM7Hxf7m6uLvJ6uLbL46d7G9ab0d2T86vBixB7mh1uQa7/WPcvY//6/L4ZDx2S12pwXws6RbI+VuKGOBC3qF9Br72rQi0JNfY8aY1ACSEB2F866lLKcEL7baKmK0BBVmQnkhEUiZfU0R0AaKJ2XVmSgTSTpxmJIy0RimgogrQJIJlqU9GEIJCJDwHMJhmwZxPyiCr5QPOl43fYEKISLm86JkqVkGmcQcDav3UwLvWMoKHXogOEiv+33WbOCTWQg0RVfnNV+NA8GRzONuqoCabpDKXALVDO83KOkPDT9vYHm2Remw== |
703,592 | Program to print reciprocal of letters | Given a string S, we need to find reciprocal of it. The reciprocal of the letter is found by finding the difference between the position of the letter and the first letter ‘A’. Then decreasing the same number of steps from the last letter ‘Z’. The character that we reach after above steps is reciprocal.Reciprocal of Z is A and vice versa because if you reverse the position of the alphabet A will be in the position of Z.Similarly, if the letter is a small case then the first letter will be 'a'and the last letter will be 'z'. and the definition of reciprocal remains the same.
Examples:
Input:
S = "ab C"
Output:
zy X
Explanation:
The reciprocal of the first letter 'a' is 'z'.
The reciprocal of the second letter 'b' is 'y'.
The reciprocal of the third letter ' ' is ' '.
The reciprocal of the last letter 'C' is 'X'.
Input:
S = "Ish"
Output:
Rhs
Explanation:
The reciprocal of the first letter 'I' is 'R'.
The reciprocal of the second letter 's' is 'h'.
The reciprocal of the third letter 'h' is 's'.
Constraints:
1<= |S| <= 10**4 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static String reciprocalString(String S)"
],
"initial_code": "//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 S = read.readLine();\n Solution ob = new Solution();\n String reciprocal = ob.reciprocalString(S);\n System.out.println(reciprocal);\n }\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730436740,
"user_code": "//User function Template for Java\nclass Solution{\n static String reciprocalString(String S){\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"reciprocalString(self, S)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n S = input()\n ob = Solution()\n print(ob.reciprocalString(S))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n # Function to reverse the characters in the string based on their ASCII values\n def reciprocalString(self, S):\n ans = ''\n\n # Iterating over each character in the string\n for i in S:\n # Checking if the character is lowercase alphabetic\n if ord(i) >= ord('a') and ord(i) <= ord('z'):\n # Reversing the character based on its ASCII value\n i = chr(ord('z') - (ord(i) - ord('a')))\n\n # Checking if the character is uppercase alphabetic\n elif ord(i) >= ord('A') and ord(i) <= ord('Z'):\n # Reversing the character based on its ASCII value\n i = chr(ord('Z') - (ord(i) - ord('A')))\n\n # Appending the reversed character to the final answer string\n ans += i\n\n # Returning the final answer string\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def reciprocalString(self, S):\n # code here"
} | eJydk9tugjAYx3exvUfl2izxdncqnhVFVJB1WRBQ0dKichKzZQ+xve9AvDHmqweumvDr1/+h/Xn+016ejp8mp4v3g+BQL/CFNySUMDWEIhLs2LNN37Y+WeCffiWYfmMqfBXROZ8AvAHwZYDXAV4H+DLAuwBPAb4H8BLAI4BHAG/MTMueL5bOak1cyrzNducHYRTvoeCSfRyFgb/bbjxGXbJeOcvF3LbMGZhopSrW6o1mq93p9qT+QB4qo/FE1aZQdPpUUyfjkTKUB32p1+20W81GvSZWK1CmTZsQhlS2JVYBmKmEjBEkEodFhVt13qWRp+9isn7X6DJvdgnjrMU8A+hx5BDQP8bZDeD0jXHWONjv8WRe7Jx93At4Q6WwKzO1xXUVp7auuLpQZ5zJe0DXdc8Pmc0rvFLgaffH7+s/lsnQcg== |
706,073 | Help Classmates | Professor X wants his students to help each other in the chemistry lab. He suggests that every student should help out a classmate who scored less marks than him in chemistry and whose roll number appears after him. But the students are lazy and they don't want to search too far. They each pick the first roll number after them that fits the criteria. Find the marks of the classmate that each student picks.Note: one student may be selected by multiple classmates.
Examples:
Input:
N = 5, arr[] = {3, 8, 5, 2, 25}
Output:
2 5 2 -1 -1
Explanation:
1. Roll number 1 has 3 marks. The first person
who has less marks than him is roll number 4,
who has 2 marks.
2. Roll number 2 has 8 marks, he helps student
with 5 marks.
3. Roll number 3 has 5 marks, he helps student
with 2 marks.
4. Roll number 4 and 5 can not pick anyone as
no student with higher roll number has lesser
marks than them. This is denoted by -1.
Output shows the marks of the weaker student that
each roll number helps in order. ie- 2,5,2,-1,-1
Input:
N = 4, a[] = {1, 2, 3, 4}
Output:
-1 -1 -1 -1
Explanation:
As the marks ars in increasing order.
None of the students can find a classmate who has
a higher roll number and less marks than them.
Constraints:
1 ≤ N ≤ 5*10**5 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static int[] help_classmate(int arr[], int n)"
],
"initial_code": "//Initial Template for Java\nimport java.util.*; \nimport java.io.*; \n\nclass GFG \n{ \n\tpublic static void main (String[] args) { \n\t\tScanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while(t > 0){\n \tint n = sc.nextInt();\n int array[] = new int[n];\n for (int i = 0; i < n; ++i)\n {\n array[i] = sc.nextInt();\n }\n\n Solution ob = new Solution();\n\n int ans[] = ob.help_classmate(array,n);\n\n \tfor (int i=0; i<n; i++) \n System.out.print(ans[i]+\" \"); \n System.out.println();\n t--;\n \nSystem.out.println(\"~\");\n}\n\t} \n} \n\n",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution {\n // Function to find next smaller element for each element in the array\n public static int[] help_classmate(int arr[], int n) {\n // Create a stack to store indices of elements\n Stack<Integer> s = new Stack<Integer>();\n // Initialize an array to store the results\n int result[] = new int[n];\n // Initialize all elements of result array to -1\n Arrays.fill(result, -1);\n\n // Iterate through the array\n for (int i = 0; i < n; i++) {\n // If the stack is empty, push the current index to stack and continue\n if (s.empty()) {\n s.push(i);\n continue;\n }\n\n // If the top element of stack is greater than current element,\n // it means we have found the next smaller element for the top element\n // so update the result array and pop the element from stack\n while (s.empty() == false && arr[s.peek()] > arr[i]) {\n result[s.peek()] = arr[i];\n s.pop();\n }\n\n // Push the current index to stack\n s.push(i);\n }\n // Return the result array\n return result;\n }\n}",
"updated_at_timestamp": 1730479928,
"user_code": "//User function Template for Java\n\nclass Solution {\n\tpublic static int[] help_classmate(int arr[], int n) \n\t{ \n\t // Your code goes here\n\t} \n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"help_classmate(self, arr, n)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n for _ in range(int(input())):\n n = int(input())\n arr = [int(x) for x in input().split()]\n obj = Solution()\n result = obj.help_classmate(arr, n)\n for i in result:\n print(i, end=' ')\n print()\n\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nfrom collections import deque\n\n\nclass Solution:\n # Function to find the next smaller element for each element in the array.\n def help_classmate(self, arr, n):\n stack = deque()\n ret = [-1 for _ in range(n)]\n\n # iterating over each element in the array.\n for i in range(n):\n # popping elements from the stack until a smaller element is found.\n while len(stack) and arr[i] < arr[stack[-1]]:\n ret[stack.pop()] = arr[i]\n # appending current element to the stack.\n stack.append(i)\n\n return ret\n",
"updated_at_timestamp": 1730479928,
"user_code": "#User function Template for python3\n\nclass Solution:\n def help_classmate(self, arr, n):\n # Your code goes here\n # Return the list"
} | eJztV81u00AQ5sAL8AaffG6Rd2d/OfEYSARxgBy4hB5SCQmBeAh4X76ZtdsQaqdWozaRmqw3tmZ3duab+SbjXy//vH31wj7vKm/ef+++bK6ut90bdG61cb1e8D2kR4SPcBHCWZ9C312gW3+7Wn/arj9//Hq9HTZG6PfS6WKutMV84lhtfq423Y8L7B0TeXEdT0KtENSCgJq5ryYk1IiMGlAmDqRmr+pFp6CTHZh0yjqVmcM9faQz3OyhRqByeeZmtT7ACRwFTkFwFa7AZbg0YcmohseNahSHHTX6eKtmxq6o2Ju6gGiaSrOu6Rl0NjNNWzPQe3gaG+C5NWnIfIHPGkBPaD2ESmmmQJKGUgokM5aQisCzCGBAEISEQFgYCIahR6gHsG8jDb/V/GzeypAKOufBf91lUm9Sb1JvUm9SMamYVEwqJhWTBpOGFm+TBpOGOhfoqKDqmubV4GHztnluKDREBnQaUg01Q7Ch6ScT4Dja58jSGyl7ZQp5QpZUYwj5UckcMojw9yjMv4KSUZg4EYXsERSPQjb0yBWZ6ZmREzKzKyALskcmYXqkilSQmHNkX0QKSILkkRhgkrkiFkSmRUIk05megugRHY4HryVuS+KW0P+wb5+bO6y9ofJEgJ5Rm0VtLvE4povAFOk4JmMxd1rcqcqHi+20Ei1PoiV02vTdcc9iLA+txrXcUY8ZzKNX5PHf7xQr8hOXMpwNK0+qlhE27bBOH7YH9VZOFndX7inaK71JC8h8OVp5VDJPvQrM9vp1t9nHom5f9912+3m/3z/U7dewpN+vYabjlwUdf5rv+BfaprfHsa7cx7q7OeNH0jDpz+CV5Mb5E/kD/O/FVxuDR3z5fcS+xp1HYzOauSywH36//gufKpX5 |
703,049 | Reverse sub array | Given an array arr, you need to reverse a subarray of that array. The range of this subarray is given by indices L and R (1-based indexing).
Examples:
Input:
arr[] = [1, 2, 3, 4, 5, 6, 7] and L = 2 and R = 4
Output:
[1, 4, 3, 2, 5, 6, 7]
Explanation:
After reversing the elements in range 2 to 4 (2, 3, 4), modified array is 1,
4, 3, 2
, 5, 6, 7.
Input:
arr[] = [1, 6, 7, 4] and L = 1 and R = 4
Output:
[4, 7, 6, 1]
Explanation:
After reversing the elements in range 1 to 4 (1, 6, 7, 4), modified array is
4, 7, 6, 1
.
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ 10**6
1 ≤ L ≤ R ≤ arr.size() | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static ArrayList<Integer> reverseSubArray(ArrayList<Integer> arr, int l,\n int r)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass Main {\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 int l = Integer.parseInt(read.readLine());\n int r = Integer.parseInt(read.readLine());\n ArrayList<Integer> arr = new ArrayList<Integer>();\n String line = read.readLine();\n String[] tokens = line.split(\" \");\n for (String token : tokens) {\n arr.add(Integer.parseInt(token));\n }\n ArrayList<Integer> v = new ArrayList<Integer>();\n\n v = new Solution().reverseSubArray(arr, l, r);\n\n for (int i = 0; i < v.size(); i++) System.out.print(v.get(i) + \" \");\n\n System.out.println();\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": "// User function Template for Java\nclass Solution {\n public static ArrayList<Integer> reverseSubArray(ArrayList<Integer> arr, int l, int r) {\n // Calculating the length of the subarray.\n int len = r - l + 1;\n // Loop to reverse the subarray by swapping elements.\n for (int i = 0; i < len / 2; i++) {\n // Swap elements\n int temp = arr.get(l + i - 1);\n arr.set(l + i - 1, arr.get(r - i - 1));\n arr.set(r - i - 1, temp);\n }\n return arr;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public static ArrayList<Integer> reverseSubArray(ArrayList<Integer> arr, int l,\n int r) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"reverseSubArray(self,arr,l,r)"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n l = int(input())\n r = int(input())\n arr = list(map(int, input().split()))\n ob = Solution()\n ans = ob.reverseSubArray(arr, l, r)\n print(*ans)\n print(\"~\")\n t -= 1\n\n",
"solution": "# User function Template for python3\nclass Solution:\n\n def reverseSubArray(self, arr, l, r):\n # Convert l and r to 0-based indices\n l -= 1\n r -= 1\n # Calculating the length of the subarray\n len_subarray = r - l + 1\n # Loop to reverse the subarray by swapping elements\n for i in range(len_subarray // 2):\n arr[l + i], arr[r - i] = arr[r - i], arr[l + i]\n return arr\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef reverseSubArray(self,arr,l,r):\n\t\t# code here"
} | eJytlN1Kw0AQhb0Qn+Ow10Vmf5P6JIIRQc1Fb9ZepCCI4kPo+zo7pMQUJj/aMg2FnTMz/c5kPy+/d1cX8rl95B93b2aX94fO3MDYJpeg8sUWNSokRAR4OFizgWlf9+1T1z4/vBy6o4jPPOdEzq1Ys0Up8NFk877BuLhvcuSA5XQWKQXLeWkYlCrHKUkbiLT+HI6fcIqS/6SidDK8nZhaZtb7VhxrYSrVmEsShxzBEwIhEhKhItRsm46lFyQRhEGg9IkSTJN1RVg0RTrB/TRT58E0ZcGUWrJIuhdlLgvLHD1sgOWVSdpUVo6DpLIgraNa95iGjN9kKC/iXY+Iazs24j3euQXYZ6uufluiFJ0xSs40m8O/5Ce3hU5ALoxYMKh3xh/cteHM/vYdEp11iqHc4j1jX4dLSThPv4sz9mrW9rL7r+sfDejLHA== |
703,095 | Equal 0, 1 and 2 | Given a string str of length N which consists of only 0, 1 or 2s, count the number of substring which have equal number of 0s, 1s and 2s.
Examples:
Input:
str = “0102010”
Output:
2
Explanation:
Substring str[2, 4] = “102” and
substring str[4, 6] = “201” has equal number
of 0, 1 and 2
Input:
str = “11100022”
Output:
0
Explanation:
There is no substring with
equal number of 0 , 1 and 2.
Constraints:
1 ≤ N≤ 10**5 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"long getSubstringWithEqual012(String str)"
],
"initial_code": "//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 str = read.readLine().trim();\n Solution obj = new Solution();\n System.out.println(obj.getSubstringWithEqual012(str));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Backend complete function Template for Java\nclass Solution {\n long getSubstringWithEqual012(String str) {\n // map to store, how many times a difference\n // pair has occurred previously (key = diff1 *\n // diff2)\n HashMap<String, Integer> map = new HashMap<>();\n map.put(\"0*0\", 1);\n // zc (Count of zeroes), oc(Count of 1s)\n // and tc(count of twos)\n // In starting all counts are zero\n int zc = 0, oc = 0, tc = 0;\n int ans = 0;\n // looping into string\n for (int i = 0; i < str.length(); i++) {\n // increasing the count of current character\n if (str.charAt(i) == '0') zc++;\n else if (str.charAt(i) == '1') oc++;\n else tc++;\n // making key of differences (z[i] - o[i],\n // z[i] - t[i])\n String key = (zc - oc) + \"*\" + (zc - tc);\n // Count of previous occurrences of above pair\n // indicates that the subarrays forming from\n // every previous occurrence to this occurrence\n // is a subarray with equal number of 0's, 1's\n // and 2's\n ans += map.getOrDefault(key, 0);\n\n map.put(key, map.getOrDefault(key, 0) + 1);\n }\n // increasing the count of current difference\n // pair by 1\n return ans;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution \n{ \n long getSubstringWithEqual012(String str) \n { \n // code here\n }\n} "
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"getSubstringWithEqual012(self, Str)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n\n for _ in range(t):\n Str = input()\n\n solObj = Solution()\n print(solObj.getSubstringWithEqual012(Str))\n print(\"~\")\n",
"solution": "# Backend complete function Template for python3\n\nclass Solution:\n\n def getSubstringWithEqual012(self, string):\n n = len(string)\n # map to store, how many times a difference\n # pair has occurred previously\n mp = dict()\n mp[(0, 0)] = 1\n\n # zc (Count of zeroes), oc(Count of 1s)\n # and tc(count of twos)\n # In starting all counts are zero\n zc, oc, tc = 0, 0, 0\n\n # looping into string\n res = 0 # Initialize result\n for i in range(n):\n # increasing the count of current character\n if string[i] == '0':\n zc += 1\n elif string[i] == '1':\n oc += 1\n else:\n tc += 1 # Assuming that string doesn't contain\n # other characters\n\n # making pair of differences (z[i] - o[i],\n # z[i] - t[i])\n tmp = (zc - oc, zc - tc)\n\n # Count of previous occurrences of above pair\n # indicates that the subarrays forming from\n # every previous occurrence to this occurrence\n # is a subarray with equal number of 0's, 1's\n # and 2's\n if tmp not in mp:\n res += 0\n else:\n res += mp[tmp]\n\n # increasing the count of current difference\n # pair by 1\n if tmp in mp:\n mp[tmp] += 1\n else:\n mp[tmp] = 1\n\n return res\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n\n def getSubstringWithEqual012(self, Str):\n # code here"
} | eJylksEKwjAMhj3sQUbPQ5IcfRLBigftwUvcoUNBHD6Ee1/TdiA7hJHa9jBYvv7J//fdTGOzyWt/l4/D0125H6LbtQ49g+taFx59OMdwOd2GOP8Cz6Nn9+raZT0a68lYD6gRqBJpW9sCkmPvrRytQ9JMQyTRA81sdTSAgho5IYSz6yVPBMz+mNk054qungZXxCFU0VRJrVfv1QejjpfEZBEXn/BnVFULUJ9tyagupAzTP/DS+PkqWrvr+Nl+AbQSX98= |
702,767 | Find Maximum Sum Strictly Increasing Subarray | Given an array of positive integers. Find the maximum sum of strictly increasing subarrays.
Examples:
Input:
arr[] = {1, 2, 3, 2, 5, 1, 7}
Output:
8
Explanation :
Some Strictly increasing subarrays are -
{1, 2, 3} sum = 6,
{2, 5} sum = 7,
{1, 7} sum = 8,
maximum sum = 8
Input:
arr[] = {1, 2, 2, 4}
Output:
6
Constraints:
1 ≤ N ≤ 10**5
1 ≤ A[i] ≤ 1000 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1617813667,
"func_sign": [
"static int maxsum_SIS(int arr[], int n)"
],
"initial_code": "//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nclass GFG\n{\n\tpublic static void main(String[] args) throws IOException\n\t{\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 arr[] = new int[n];\n String inputLine[] = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) {\n arr[i] = Integer.parseInt(inputLine[i]);\n }\n \n Solution obj = new Solution();\n System.out.println( obj.maxsum_SIS(arr, n) );\n \n }\n\t}\n}\n",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\n// Java program to find the maximum sum of strictly\n// increasing subarrays\npublic class Solution {\n // Returns maximum sum of strictly increasing\n // subarrays\n static int maxsum_SIS(int arr[], int n) {\n // Initialize max_sum be 0\n int max_sum = 0;\n // Initialize current sum be arr[0]\n int current_sum = arr[0];\n // Traverse array elements after first element.\n for (int i = 1; i < n; i++) {\n // update current_sum for strictly increasing subarray\n if (arr[i - 1] < arr[i]) {\n current_sum = current_sum + arr[i];\n } else // strictly increasing subarray break\n {\n // update max_sum and current_sum ;\n max_sum = Math.max(max_sum, current_sum);\n current_sum = arr[i];\n }\n }\n return Math.max(max_sum, current_sum);\n }\n}\n",
"updated_at_timestamp": 1727947200,
"user_code": "//User function Template for Java\n\npublic class Solution { \n\n// Return maximum sum of strictly increasing \n// subarrays \n\tstatic int maxsum_SIS(int arr[], int n) \n\t{\n\t // Your code goes here \n\t}\n} "
} | {
"class_name": "Solution",
"created_at_timestamp": 1617813667,
"func_sign": [
"maxsum_SIS(self, arr, n)"
],
"initial_code": "# Initial Template for Python 3\n\ndef main():\n T = int(input())\n\n while T > 0:\n n = int(input())\n arr = [int(x) for x in input().strip().split()]\n ob = Solution()\n print(ob.maxsum_SIS(arr, n))\n\n T -= 1\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Python3 program to find the maximum sum of strictly\n # increasing subarrays\n\n # Returns maximum sum of strictly increasing\n # subarrays\n def maxsum_SIS(self, arr, n):\n # Initialize max_sum be 0\n max_sum = 0\n\n # Initialize current sum be arr[0]\n current_sum = arr[0]\n\n # Traverse array elements after first element.\n for i in range(1, n):\n # update current_sum for strictly increasing subarray\n if (arr[i-1] < arr[i]):\n current_sum = current_sum + arr[i]\n\n else:\n # strictly increasing subarray break\n # update max_sum and current_sum\n max_sum = max(max_sum, current_sum)\n current_sum = arr[i]\n\n return max(max_sum, current_sum)\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def maxsum_SIS(self, arr, n): \n # Your code goes here "
} | eJzNVbtOA0EMpKCgpqOzro7QPuy7W74EiSAKSEETUlwkJATiI+B/Ge89conikIhEItJqH/aOZ8f25fP8++riLP9uL7G4eyue54tlU9xQ4adz7zAoUCQmoRKDsQ7FhIrZ62L22MyeHl6WTXch4MbHdF68T2gDRhSKeiQg0Bi1otpAjKWBGEBMr7YwPZhfA+52BrRy2g6tZAEh4JXIewLzRDV2mameuRxj5YA4IIH4YgRLljJRBXYOEZLiOo3mAglOYh5ggn10qhmDQZ2jq4VWJEcm36nrLEUBv0NT1WyVGL+RpmoQwELnHRUgYwHXdc11ZWCKWQNtVbVisINoxEJRKCD3ogXgdIYdB3CBhbOLOibimrgiLvWE2SrpyioTDxlVaq2z4V2tXpY4ZnvUuQjAtM066yztOmBWm5fWHrpztasfy5q/9Qxc/UNmxMy3WAkfCvs/VPbhZE7JZrvi+zWDN7vhqG88+iPL8pCW92Uy226PcrXomtpt6WXtp93tnGJlPr7/kjq35z+nc7/mdUhr7PN6sk4a5fX+6/oHocb9aA== |
705,739 | Word Wrap | Given an array nums[] of size n, wherenums[i]denotes the number of characters in one word.Let Kbe thelimit 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.
Assume 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.
Examples:
Input:
nums = {3,2,2,5}, k = 6
Output:
10
Explanation:
Given a line can have 6
characters,
Line number 1: From word no. 1 to 1
Line number 2: From word no. 2 to 3
Line number 3: From word no. 4 to 4
So total cost = (6-3)
**2
+ (6-2-2-1)
**2 = 3
**2
+1
**2 = 10.
As in the first line word length = 3 thus
extra spaces = 6 - 3 = 3 and in the second line
there are two word of length 2 and there already
1 space between two word thus extra spaces
= 6 - 2 -2 -1 = 1. As mentioned in the problem
description there will be no extra spaces in
the last line. Placing first and second word
in first line and third word on second line
would take a cost of 0
**2
+ 4
**2 = 16 (zero spaces
on first line and 6-2 = 4 spaces on second),
which isn't the minimum possible cost.
Input:
nums = {3,2,2}, k = 4
Output:
5
Explanation:
Given a line can have 4
characters,
Line number 1: From word no. 1 to 1
Line number 2: From word no. 2 to 2
Line number 3: From word no. 3 to 3
Same explaination as above total cost
= (4 - 3)
**2
+ (4 - 2)
**2 = 5
.
Constraints:
1 ≤ n ≤ 500
1 ≤ nums[i] ≤ 1000
max(nums[i]) ≤ k ≤ 2000 | geeksforgeeks | Hard | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int solveWordWrap(int[] nums, int k)"
],
"initial_code": "import 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 \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution\n{\n public int solveWordWrap (int[] nums, int k){\n \n int[][] memo = new int[nums.length][k + 1];\n for (int i = 0; i < nums.length; i++) {\n Arrays.fill(memo[i], -1);\n }\n return solveWordWrapUsingMemo(nums, nums.length, k, 0, k, memo);\n }\n \n private int solveWordWrap(int[] words, int n, int length, int wordIndex, int remLength, int[][] memo) {\n \n //base case for last word\n if (wordIndex == n - 1) {\n memo[wordIndex][remLength] = words[wordIndex] < remLength ? 0 : square(remLength);\n return memo[wordIndex][remLength];\n }\n \n int currWord = words[wordIndex];\n //if word can fit in the remaining line\n if (currWord < remLength) {\n return Math.min(\n //if word is kept on same line\n solveWordWrapUsingMemo(words, n, length, wordIndex + 1, remLength == length ? remLength - currWord : remLength - currWord - 1, memo),\n //if word is kept on next line\n square(remLength) + solveWordWrapUsingMemo(words, n, length, wordIndex + 1, length - currWord, memo)\n );\n } else {\n //if word is kept on next line\n return square(remLength) + solveWordWrapUsingMemo(words, n, length, wordIndex + 1, length - currWord, memo);\n }\n }\n \n private int solveWordWrapUsingMemo(int[] words, int n, int length, int wordIndex, int remLength, int[][] memo) {\n if (memo[wordIndex][remLength] != -1) {\n return memo[wordIndex][remLength];\n }\n \n memo[wordIndex][remLength] = solveWordWrap(words, n, length, wordIndex, remLength, memo);\n return memo[wordIndex][remLength];\n }\n \n private int square(int n) {\n return n * n;\n }\n }",
"updated_at_timestamp": 1730274241,
"user_code": "class Solution\n{\n public int solveWordWrap (int[] nums, int k)\n {\n // Code here \n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"solveWordWrap(self, nums, k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n n = int(input())\n nums = list(map(int, input().split()))\n k = int(input())\n obj = Solution()\n ans = obj.solveWordWrap(nums, k)\n print(ans)\n",
"solution": "# User function Template for python3\n\nimport sys\n\n\nclass Solution:\n def solveWordWrap(self, nums, k):\n n = len(nums)\n dp = [0] * n # initialize dp array with 0\n ans = [0] * n # initialize ans array with 0\n dp[n - 1] = 0 # set value of dp for last word to 0\n ans[n-1] = n-1 # set value of ans for last word to n-1\n\n # iterate from second last word to first word\n for i in range(n-2, -1, -1):\n currlen = -1 # initialize currlen with -1\n # set value of dp for current word to maximum possible value\n dp[i] = sys.maxsize\n for j in range(i, n):\n # update currlen with length of current word\n currlen += (nums[j] + 1)\n if currlen > k: # if currlen exceeds the given limit, break the loop\n break\n if j == n - 1: # if the current word is the last word, set cost to 0\n cost = 0\n else:\n cost = ((k - currlen)*(k - currlen) +\n dp[j + 1]) # calculate the cost\n # if current cost is less than dp for the current word, update dp and ans\n if cost < dp[i]:\n dp[i] = cost\n ans[i] = j\n\n i = 0 # initialize i to 0\n res = 0 # initialize res to 0\n while i < n:\n pos = 0 # initialize pos to 0\n for j in range(i, ans[i] + 1):\n # calculate the sum of lengths of words in the line\n pos = pos + nums[j]\n x = ans[i] - i # calculate the number of extra spaces in the line\n if ans[i] + 1 != n:\n # calculate the additional cost for the line\n res = res + (k - x - pos)**2\n i = ans[i] + 1 # move to the next line\n return res # return the total cost of word wrapping\n",
"updated_at_timestamp": 1730274241,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef solveWordWrap(self, nums, k):\n\t\t#Code here"
} | eJztVsFOwzAM5cCZb7BynlDi1E3LlyBRxAF64FJ26BASmsRHwP/iuGWgNdnWtRPV1EXZEq9+SfOeHX9cfq2vLuRz+8qDu3f1XC1XtboBZYrKaO7QaUVFagGqfFuWj3X59PCyqlsffl6tF7CFQh4JMsjBAYGFBFJAHmU8z3lmiwp1BDFzIUjkhSwjpOztkQx/N/iJWJEt5JEB/foRbJOEwXm/juEaeCvbJNl0zuO0nfnlkX8dWwhy3k/sFWwaWsXK2SIc2eMcmCRIgub1SPZ6Np1fKHbmCQapJS1SRA1WQyIDnrJ+mEtWJsE//CncxKTjKMgmNmzObSLNJ41YOObB8HfUhL9tM5aT/OV10jUFnzvcOAxxR/50LhhkxkeZVzk1Qvcq1z4KZtvkbZJaInSTJuzyDaOVCVrCSPd0m1Ph7vSDwQtkuulnlNLoL3LsZCzRYWoeUBFuEDa1R7+IGFiz9XP4DaZTVWyjcNuC/RC1rxIMnOw2yewdjZ+Yu5mGSE6n18IdpdjuTbD3Irj/vP4GA/oSPw== |
704,728 | Prime Pair with Target Sum | Given a number n, find out if n can be expressed as a+b, where both a and b are prime numbers. If such a pair exists, return the values of a and b, otherwise return [-1,-1] as an array of size 2.Note: If [a, b] is one solution with a <= b, and [c, d] is another solution with c <= d, and a < c then [a, b] is considered as our answer.
Examples:
Input:
n = 10
Output:
3 7
Explanation:
There are two possiblities 3, 7 & 5, 5
are both prime & their sum is 10, but we'll pick 3, 7 as 3 < 5.
Input:
n = 3
Output:
-1 -1
Explanation:
There are no solutions to the number 3.
Constraints:
2 <= n <= 10**6 | geeksforgeeks | Medium | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static ArrayList<Integer> getPrimes(int n)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\nimport java.util.ArrayList;\n\nclass IntArray {\n public static int[] input(BufferedReader br, int n) throws IOException {\n String[] s = br.readLine().trim().split(\" \");\n int[] a = new int[n];\n for (int i = 0; i < n; i++) a[i] = Integer.parseInt(s[i]);\n\n return a;\n }\n\n public static void print(int[] a) {\n for (int e : a) System.out.print(e + \" \");\n System.out.println();\n }\n\n public static void print(ArrayList<Integer> a) {\n for (int e : a) 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 Solution obj = new Solution();\n ArrayList<Integer> res = obj.getPrimes(n);\n\n IntArray.print(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public static ArrayList<Integer> getPrimes(int n) {\n boolean[] primes = new boolean[n + 1];\n ArrayList<Integer> result = new ArrayList<>();\n\n // Mark all numbers as primes initially\n for (int i = 2; i <= n; i++) {\n primes[i] = true;\n }\n\n // Sieve of Eratosthenes algorithm to find primes\n for (int i = 2; i * i <= n; i++) {\n if (primes[i]) {\n for (int j = i * i; j <= n; j += i) {\n primes[j] = false;\n }\n }\n }\n\n // Find the pair of primes that sum up to n\n boolean found = false;\n for (int i = 2; i <= n; i++) {\n if (primes[i] && primes[n - i]) {\n result.add(i);\n result.add(n - i);\n found = true;\n break;\n }\n }\n\n // If no such pair exists, return -1\n if (!found) {\n result.add(-1);\n result.add(-1);\n }\n\n return result;\n }\n}",
"updated_at_timestamp": 1730476142,
"user_code": "\nclass Solution {\n public static ArrayList<Integer> getPrimes(int n) {\n // code here\n }\n}\n"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"getPrimes(self, n : int) -> List[int]"
],
"initial_code": "class IntArray:\n\n def __init__(self) -> None:\n pass\n\n def Input(self, n):\n arr = [int(i) for i in input().strip().split()] # array input\n return arr\n\n def Print(self, arr):\n for i in arr:\n print(i, end=\" \")\n print()\n\n\nif __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n n = int(input())\n\n obj = Solution() # Note: 'Solution' is not defined in the given code\n res = obj.getPrimes(n)\n\n IntArray().Print(res)\n\n print(\"~\")\n",
"solution": "from typing import List\n\n\nclass Solution:\n def getPrimes(self, n: int) -> List[int]:\n primes = [True] * (n + 1)\n result = []\n\n # Mark 0 and 1 as not prime\n primes[0] = primes[1] = False\n\n # Sieve of Eratosthenes algorithm to find primes\n for i in range(2, int(n**0.5) + 1):\n if primes[i]:\n for j in range(i * i, n + 1, i):\n primes[j] = False\n\n # Find the pair of primes that sum up to n\n found = False\n for i in range(2, n // 2 + 1):\n if primes[i] and primes[n - i]:\n result.append(i)\n result.append(n - i)\n found = True\n break\n\n # If no such pair exists, append -1\n if not found:\n result.extend([-1, -1])\n\n return result\n",
"updated_at_timestamp": 1730476142,
"user_code": "\nfrom typing import List\nclass Solution:\n def getPrimes(self, n : int) -> List[int]:\n # code here\n \n"
} | eJytkkEKwjAQRV30IEPWVTKJJY4nEay40C7cxC5aEETxEHoad57MJHWjMKWMHbIIhDeT/+ffsscrm6RaPcNlfVYHX7eNWoLC0huVg6pOdbVrqv322DafpylCOKW/ll5dcviG5gxkwHCIY5GCQ8yCYQowloOIuEm9ilBrknAUamGFE2MxKDroWrPmiL6L3DwLjpfY2SrylchKDSJNLgqN3/bC9QSTMYYvRJbjDcRNUJ+AZLd8yynK/KoHpORHySid9Dit/u2VUo6DvN3cZ2/qFmwd |
704,949 | Least Prime Factor | Given a number N, find the least prime factors for all numbers from 1 to N. The least prime factor of an integer X is the smallest prime number that divides it.Note :
Examples:
Input:
N = 6
Output:
[0, 1, 2, 3, 2, 5, 2]
Explanation:
least prime factor of 1 = 1,
least prime factor of 2 = 2,
least prime factor of 3 = 3,
least prime factor of 4 = 2,
least prime factor of 5 = 5,
least prime factor of 6 = 2.
So answer is[1, 2, 3, 2, 5, 2].
Input:
N = 4
Output:
[0, 1, 2, 3, 2]
Explanation:
least prime factor of 1 = 1,
least prime factor of 2 = 2,
least prime factor of 3 = 3,
least prime factor of 4 = 2.
So answer is[1, 2, 3, 2].
Constraints:
2<= n <=10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int[] leastPrimeFactor(int n)"
],
"initial_code": "//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 PrintWriter out=new PrintWriter(System.out);\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.leastPrimeFactor(n);\n for(int i = 1; i <=n; i++)\n {\n out.print(ans[i] + \" \");\n }\n out.println();\n \nout.println(\"~\");\n}\n out.close();\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution\n{\n public int[] leastPrimeFactor(int n)\n {\n // code here\n int least_prime[]=new int[n+1]; \n \n // We need to print 1 for 1. \n least_prime[1] = 1; \n \n for (int i = 2; i <= n; i++) \n { \n // least_prime[i] == 0 \n // means it i is prime \n if (least_prime[i] == 0) \n { \n // marking the prime number \n // as its own lpf \n least_prime[i] = i; \n \n // mark it as a divisor for all its \n // multiples if not already marked \n for (int j = 2*i; j <= n; j += i) \n if (least_prime[j] == 0) \n least_prime[j] = i; \n } \n } \n \n // Return least prime factor of \n // of numbers till n \n return least_prime;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution\n{\n public int[] leastPrimeFactor(int n)\n {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"leastPrimeFactor(self, n)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n n = int(input())\n ob = Solution()\n ans = ob.leastPrimeFactor(n)\n for i in range(1, n+1):\n print(ans[i], end=\" \")\n print()\n",
"solution": "class Solution:\n def leastPrimeFactor(self, n):\n # Create a list to store least primes.\n # Initialize all entries as 0.\n least_prime = [0] * (n+1)\n\n # We need to assign 1 for 1.\n least_prime[1] = 1\n\n for i in range(2, n+1):\n # least_prime[i] == 0\n # means i is prime\n if least_prime[i] == 0:\n # Marking the prime number\n # as its own least prime factor\n least_prime[i] = i\n\n # Mark it as a divisor for all its multiples if not already marked\n for j in range(2*i, n+1, i):\n if least_prime[j] == 0:\n least_prime[j] = i\n\n # Return the least prime factor of numbers till n\n return least_prime\n",
"updated_at_timestamp": 1727776457,
"user_code": "#User function Template for python3\nclass Solution:\n def leastPrimeFactor (self, n):\n # code here "
} | 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 |
704,003 | Chocolate lengths | Adam has N chocolates of unequal lengths. He wants that each chocolate should be of equal lengths. In order to do so,at each step, he picks two unequal length chocolates and takes their length difference 'd' and then he eats the bigger one andmake it's length 'd' . He stops when all the chocolates are ofequal length . Find the final length of all chocolates.
Examples:
Input:
N =
2
A[] =
{10 , 12}
Output:
2
Explanation:
{10,12} -> {10,2} -> {8,2} -> {6,2}
-> {4,2} -> {2,2}
So, the final length is 2.
Input:
N =
3
A[] =
{6 , 10 , 15}
Output:
1
Explanation:
{6,10,15}-> {6,10,9}-> {6,4,9}->
{6,4,3}-> {2,4,3} -> {2,4,1}->
{2,2,1} -> {1,2,1} -> {1,1,1}
So, the final length is 1.
[Note:this is one way of eating chocolates,
there could be many..]
Constraints:
1 <= N <= 10**5
1 <= A[i] <= 10**8 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int chocolateLength(int N , int[] A)"
],
"initial_code": "import 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[] A = new int[N];\n \n for(int i=0 ; i<N ; i++)\n A[i] = Integer.parseInt(S[i]);\n\n Solution ob = new Solution();\n System.out.println(ob.chocolateLength(N,A));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n // helper method to get GCD of 2 numbers\n static int gcd(int a, int b) {\n // base case, if a is 0 then gcd is b\n if (a == 0) return b;\n else\n // recursively calculate gcd by taking remainder\n return gcd(b % a, a);\n }\n\n // method to calculate the length of chocolate bar\n static int chocolateLength(int N, int[] A) {\n // initializing result as the first element of the array\n int result = A[0];\n // looping through the array to calculate gcd\n for (int i = 1; i < N; i++) result = gcd(A[i], result);\n // return the final result (gcd of the array elements)\n return result;\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n static int chocolateLength(int N , int[] A) {\n // code here\n }\n};"
} | {
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"chocolateLength(self, N , A)"
],
"initial_code": "# Initial Template for Python 3\n\nimport math\n\nif __name__ == '__main__':\n t = int(input())\n\n for _ in range(t):\n N = int(input())\n\n A = list(map(int, input().split()))\n\n ob = Solution()\n print(ob.chocolateLength(N, A))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def chocolateLength(self, N, A):\n result = A[0]\n\n # Getting GCD of the Array\n for i in range(1, N):\n result = math.gcd(result, A[i])\n\n return result\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def chocolateLength(self, N , A):\n # code here "
} | eJy9VU1Lw0AU7EHRnzHsuUj2e+MvEYx40By8xB5SKIjij9C/K+6Wt2uQvtqkqUPgDWzydiazeXk/+zy/XGxx83WxWNy+iKdute7FNYRsunRVBLGEaDer9qFvH++f132+K6833VvTidclfrWIC0ob63yoQVWCqgJVDaoGVC2oOlD1oBqQG3KaGC12YAcHsom2fdxKQVrIqFZCGSgPzXXTTBedBMenKxWf1awUzq9rupqAQIAnwBFgCTAEbiPCnqTza4mSiehMTCY2E5eJzyRkUo/NgdFk4huANCkCbUeelvBjRxYdqjBdmCnMFuYK84WFkQJS+uXTqYN31uhoJMcgmXb1afwcbWcwTBLdfiF/xTrlZE842PPNC8ntocaksjuW6rS5cBEl7IvpyHnwvwNht9k53A66zfLjnG38VIcejLuPq28/CBA7 |
703,052 | Immediate Smaller Element | Given an integer array arr of size n. For each element in the array, check whether the right adjacent element (on thenextimmediate position) of the array is smaller. If next element is smaller, update the current index to that element.If not, then-1.
Examples:
Input:
n = 5, arr[] = {4, 2, 1, 5, 3}
Output:
2 1 -1 3 -1
Explanation:
Array elements are 4, 2, 1, 5, 3. Next to 4 is 2 which is smaller, so we print 2. Next of 2 is 1 which is smaller,so we print 1. Next of 1 is 5 which is greater, so we print -1. Next of 5 is 3 which is smaller, so we print 3. Note that for last element, output is always going to be -1 because there is no element on right.
Input:
n = 6, arr[] = {5, 6, 2, 3, 1, 7}
Output:
-1 2 -1 1 -1 -1
Explanation:
Next to 5 is 6 which is greater, so we print -1. Next of 6 is 2 which is smaller, so we print 2. Next of 2 is 3 which is greater, so we print -1. Next of 3 is 1 which is smaller, so we print 1. Next of 1 is 7 which is greater, so we print -1. Note that for last element, output is always going to be -1 because there is no element on right.
Constraints:
1 ≤ n ≤ 10**7
1 ≤ arr[i] ≤ 10**5 | geeksforgeeks | Easy | {
"class_name": "Solution",
"created_at_timestamp": 1619346551,
"func_sign": [
"void immediateSmaller(int arr[], int n)"
],
"initial_code": "//Initial Template for Java\n\n\nimport java.util.*;\nimport java.io.*;\n\npublic class Main {\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[] 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 new Solution().immediateSmaller(arr, n);\n for (int i = 0; i < n; i++) {\n System.out.print(arr[i] + \" \");\n }\n System.out.println();\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution {\n void immediateSmaller(int arr[], int n) {\n // code here\n }\n}"
} | {
"class_name": "Solution",
"created_at_timestamp": 1619346551,
"func_sign": [
"immediateSmaller(self,arr,n)"
],
"initial_code": "if __name__ == '__main__':\n tcs = int(input())\n\n for _ in range(tcs):\n n = int(input())\n arr = [int(x) for x in input().split()]\n ob = Solution()\n ob.immediateSmaller(arr, n)\n for x in arr:\n print(x, end=\" \")\n print()\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n\n # Function to find the immediate smaller element\n def immediateSmaller(self, arr, n):\n # Iterate through the array elements\n for i, e in enumerate(arr[:-1]):\n # If the next element is smaller, update the current element\n if arr[i+1] < e:\n arr[i] = arr[i+1]\n else:\n arr[i] = -1\n # Update the last element in the array to -1\n arr[n-1] = -1\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n\n\tdef immediateSmaller(self,arr,n):\n\t\t# code here"
} | eJztmM1OwzAMxznwCDyA1fNAc9JPTjwGEkMcoAcuY4dOQkIgHgLeF//dVUzakrQV7bTRaP21U2MntfPh+PP8++biTMttIQ93b9HzcrWuomuKeLHkOS4qKKeMUkooJkuG5E00o6h8XZWPVfn08LKuNjI7NemSabH8EIH3Ge1RrrVQFxKQy5y6RZOBOgvEQAJ4GkhwEcfUjs6WWVtrw8DXzlGoQFHmykyZKhNlrLRKo/SYvI82T0eNusWImWMxcCruFL0ko4DlI8WjtjFZSpwR58QFQcbttd4/pylrW8qn0HQb4uYZbPDLxDb0jl5dG4/+8s16ncH/DeFFC/MLyIEMSIEEiAELGIAbTCKnIOJeVLu0i+Vlqn9U9cMRIVOLB3d46lqNvIH3boTXM4bztbId3wcDfNs1vnfspHzobXHaSkfYSnub+vC+nvzez++e87wZ/0Av6p3JhPG7Ez62Y8fa9Mb+nt2Lvzi9s67UorL+a7zbXjOBB8uI9DJSMUR6g43vrTcuQNLNts66ibZOabc6p1dbf1swkNoTrfsbuf+6+gEc4RxT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.