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
|
|---|---|---|---|---|---|---|---|
705,422
|
Number of Rectangles in a Circle
|
Given a circular sheet of radius, r. Find the total number of rectangles with integral length and width that can be cut from the sheet that can fit on the circle, one at a time.
Examples:
Input:
r
=1
Output:
1
Explanation:
Only 1 rectangle of dimensions 1x1.
Input:
r
=2
Output:
8
Explanation:
The 8 possible rectangles are
(1x1)(1x2)(1x3)(2x1)(2x2)(2x3)(3x1)(3x2).
Constraints:
1<=r<=1000
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int rectanglesInCircle(int r)"
],
"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 = 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 Solution ob = new Solution();\n int ans = ob.rectanglesInCircle(N);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n int rectanglesInCircle(int r) {\n // code here\n int limit = 4 * r * r;\n int numRects = 0;\n int tempRects = -1;\n int diff = -1;\n\n for (int l = 1; ; ++l) {\n diff = limit - l * l;\n if (diff <= 0)\n break;\n tempRects = (int) Math.sqrt(diff);\n if (tempRects == 0)\n break;\n numRects += tempRects;\n }\n return numRects;\n }\n};",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n int rectanglesInCircle(int r) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"rectanglesInCircle(self,r)"
],
"initial_code": "# Initial Template for Python\n\nimport math\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N = int(input())\n ob = Solution()\n ans = ob.rectanglesInCircle(N)\n print(ans)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python\n# Function to count the number of rectangles in a circle\nclass Solution:\n\n def rectanglesInCircle(self, R):\n ans = 0\n # Loop through all possible pairs of lengths\n for i in range(1, 2 * R + 1):\n for j in range(1, 2 * R + 1):\n # Check if the square of the lengths is less than or equal to the square of the diameter of the circle\n if i * i + j * j <= 2 * R * 2 * R:\n # Increment the count of rectangles\n ans += 1\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function template for Python\n\nclass Solution:\n def rectanglesInCircle(self,r):\n #code here"
}
|
eJylksEKwjAQRD30Q0rORbJJN5v6JYIVD9qDl9pDC0JRxG/Q/7U0qeBhCmppIVBeZmZnb8nznizGZ90Ph02vjnXTtWqVKiprq7JUVeem2rfVYXfq2vjLmLK+lrW6ZOknwABwBQBII4kiB4hBCBlyyBdiRBjpkEaQJaMFusP22DA2CB363HqkJjAYiWOXo56GbDicLdgjn4jSSCh+EkRxTMsoY5jOzFzRSGfb8Np5WOFomuKc5lyTcUxogVgH9/Ge2RDiBVykf1z5afKBl5jmnxa+buD9arxuE7t9LF896WLf
|
702,736
|
Maximum AND Value
|
You are given an array arr[] of positive integers. Your task is to find the maximum value that can be obtained by performing a bitwise AND operation on any two different elements in the array.Note: AND refers to the bitwise '&' operator.
Examples:
Input:
arr[] = [4, 8, 12, 16]
Output:
8
Explanation:
The pair {8, 12} has the maximum AND value of 8.
Input:
arr[] = [4, 8, 16, 2]
Output:
0
Explanation:
No pair gives a non-zero AND value, so the output is 0.
Constraints:
1 ≤ arr.size() ≤ 5*10**5
1 ≤ arr[i] ≤ 5*10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int findMaxAnd(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 = scanner.nextInt();\n scanner.nextLine(); // Consume the newline character\n for (int i = 0; i < t; i++) {\n String input = scanner.nextLine();\n String[] inputArray = input.split(\" \");\n int[] arr = new int[inputArray.length];\n for (int j = 0; j < inputArray.length; j++) {\n arr[j] = Integer.parseInt(inputArray[j]);\n }\n\n Solution solution = new Solution();\n System.out.println(solution.findMaxAnd(arr));\n System.out.println(\"~\");\n }\n scanner.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public int findMaxAnd(int[] arr) {\n int res = 0;\n for (int bit = 31; bit >= 0; bit--) {\n int count = 0;\n int pattern = res | (1 << bit);\n for (int num : arr) {\n if ((pattern & num) == pattern) {\n count++;\n }\n }\n if (count >= 2) {\n res |= (1 << bit);\n }\n }\n return res;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public int findMaxAnd(int[] arr) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"findMaxAnd(self, arr)"
],
"initial_code": "def main():\n t = int(input())\n for _ in range(t):\n arr = list(map(int, input().split()))\n solution = Solution()\n print(solution.findMaxAnd(arr))\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def findMaxAnd(self, arr):\n res = 0\n\n for bit in range(31, -1, -1):\n count = 0\n pattern = res | (1 << bit)\n\n for num in arr:\n if (pattern & num) == pattern:\n count += 1\n\n if count >= 2:\n res |= (1 << bit)\n\n return res\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def findMaxAnd(self, arr):\n # code here\n"
}
|
eJytlEFOAzEMRVkgzvE16wrFTuxkOAkSRSygCzZDF62EhEAcAm7FjgvhZEoFUt3Slr/JRDN5iv+35/X0/fPspOnywx6unrr7Yb5cdBfoaDpQSEWyQDhxyWBlShEUKWTqJuhmj/PZ7WJ2d/OwXKxOjZ9Oh5fp0D1P8JsXOWsBaSwJhXpGCr06oOAwCHYMlYLI0ATiAhaFEO+JUpEo2HgpsJUOCpwcZjvlcPsmSKiyu7WF2gqti8NMUnJJXt0tCx2zKGMWaczCbLBKdKxkTw/Gq5Yq5CpoFaQKqQqxyuFqia4PvgGIdQcS2zlg5j5m9cgWjUVkUaEYRg3InqvqORopkfTgTMVayDaJCZSNJGCOGrzWNO9T8KgS+IiqiZKWQ/vq+5OD+mvdCN6cHtog4v0N1KYvekbsGP+qPf4A9vb/ym4dclzp3jDLH6d5dd6lb+KV7UCJvbAHbH4flxT9iGqn71vd3hZ0XM/l9dv5FxGIz8Y=
|
711,654
|
Pattern 3
|
Geek is very fond of patterns. Once, his teacher gave him apattern to solve. He gave Geekan integer n and asked him to build a pattern.
Examples:
Input:
5
Output:
1
1 2
1 23
1 234
1 2 3 4 5
Input:
3
Output:
1
1 2
1 23
Constraints:
1<=
n
<= 100
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1662576775,
"func_sign": [
"void printTriangle(int n)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass Main {\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 int n = Integer.parseInt(br.readLine().trim());\n Solution obj = new Solution();\n obj.printTriangle(n);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "Main",
"solution": "class Solution {\n\n // Method to print a triangle of numbers\n void printTriangle(int n) {\n // Loop from 1 to n\n for (int i = 1; i <= n; i++) {\n // Loop from 1 to i\n for (int j = 1; j <= i; j++) {\n // Print the value of j followed by a space\n System.out.print(j + \" \");\n }\n // Move to the next line after printing the current row\n System.out.println();\n }\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n\n void printTriangle(int n) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1663240280,
"func_sign": [
"printTriangle(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 ob.printTriangle(N)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to print the triangle pattern.\n def printTriangle(self, N):\n # looping from 1 to N.\n for i in range(1, 1 + N):\n # looping from 1 to i.\n for j in range(1, i + 1):\n # printing j with a space.\n print(j, end=' ')\n # printing a new line after each row.\n print()\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def printTriangle(self, N):"
}
|
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
|
703,317
|
Digits in a set
|
Given a numbern, count the numbers from1ton,which comprise only digitsfromset {1, 2, 3, 4,5}.
Examples:
Input:
n = 20
Output:
10
Explanation:
The numbers whose digits are from the given set are: 1, 2, 3, 4, 5, 11, 12, 13, 14, 15.
Input:
n = 100
Output:
30
Constraints:
1 ≤ n ≤ 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int countNumbers(int n)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\npublic class GFG {\n\n public static void main(String[] args) throws Exception {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int tc = Integer.parseInt(br.readLine().trim());\n while (tc-- > 0) {\n String[] inputLine;\n inputLine = br.readLine().trim().split(\" \");\n int n = Integer.parseInt(inputLine[0]);\n\n long ans = new Solution().countNumbers(n);\n System.out.println(ans);\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n // Function to count the numbers satisfying the given condition.\n public int countNumbers(int n) {\n int ans = 0;\n // Iterating from 1 to n.\n for (int i = 1; i <= n; i++) {\n int m = i;\n boolean allInSet = true; // Flag to check if all digits are in the set.\n // Checking each digit of the number.\n while (m > 0) {\n int digit = m % 10;\n // If any digit is not in the set {1, 2, 3, 4, 5}, set the flag to\n // false.\n if (digit < 1 || digit > 5) {\n allInSet = false;\n break; // No need to check further if one digit is outside the set.\n }\n m /= 10;\n }\n // If all digits are in the set, increment the count.\n if (allInSet) {\n ans++;\n }\n }\n // Returning the count of numbers satisfying the condition.\n return ans;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n // Function to count the numbers satisfying the given condition.\n public int countNumbers(int n) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"countNumbers(self, n)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n tc = int(input())\n while tc > 0:\n n = int(input())\n ob = Solution()\n ans = ob.countNumbers(n)\n print(ans)\n tc -= 1\n print(\"~\")\n",
"solution": "class Solution:\n # Function to count the numbers satisfying the given condition.\n def countNumbers(self, n):\n ans = 0\n\n # Iterating from 1 to n.\n for i in range(1, n + 1):\n m = i\n all_in_set = True # Flag to check if all digits are in the set.\n\n # Checking each digit of the number.\n while m > 0:\n digit = m % 10\n\n # If any digit is not in the set {1, 2, 3, 4, 5}, set the flag to False.\n if digit < 1 or digit > 5:\n all_in_set = False\n # No need to check further if one digit is outside the set.\n break\n m //= 10\n\n # If all digits are in the set, increment the count.\n if all_in_set:\n ans += 1\n\n # Returning the count of numbers satisfying the condition.\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n # Function to count the numbers satisfying the given condition.\n def countNumbers(self, n):\n # code here"
}
|
eJydkzELwjAUhB36Q0rmInlJn2n8JYIVB+3gEjtUEERxdxP9v5q2CqKXYt5UCF/v3eVyTu7XZNTO7PL8mB/ExtW7RkxTQaVjKbJUVPu6WjXVerndNf2Z4tKdSieOWfpJGAaEloBgiUQIMtZaxDDaLNeKAMTFBECkdI4cWYOkOKClDRF2BX1pK5EaST//c4WfCLk+FXhrKJRQOxS6gI4ayBTSnnknBGmrwzt3pg1HrVCEYibLsOM+5PZ5vH6CexhaP2LlL+UIaV/nttCc//Si1UB9FrfxA9x3Zvc=
|
706,298
|
Number of Provinces
|
Given an undirectedgraph with V vertices. We say two vertices u and v belong to a single province if there is a path from u to v or v to u. Your task is to find the number of provinces.Note: A province is a group of directly or indirectly connected cities and no other cities outside of the group.
Examples:
Input:
[
[1, 0, 1],
[0, 1, 0],
[1, 0, 1]
]
Output:
2
Explanation:
The graph clearly has 2 Provinces [1,3] and [2]. As city 1 and city 3 has a path between them they belong to a single province. City 2 has no path to city 1 or city 3 hence it belongs to another province.
Input:
[
[1, 1],
[1, 1]
]
Output:
1
Constraints:
1 ≤ V ≤ 500
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1616347539,
"func_sign": [
"static int numProvinces(ArrayList<ArrayList<Integer>> adj, int V)"
],
"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 V = Integer.parseInt(read.readLine());\n \n ArrayList<ArrayList<Integer>> adj = new ArrayList<>();\n \n for(int i=0; i<V; i++)\n {\n String S[] = read.readLine().split(\" \");\n ArrayList<Integer> temp = new ArrayList<>();\n for(int j=0; j<V; j++)\n temp.add(Integer.parseInt(S[j]));\n adj.add(temp);\n }\n\n Solution ob = new Solution();\n System.out.println(ob.numProvinces(adj,V));\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 numProvinces(ArrayList<ArrayList<Integer>> adj, int V) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1616347539,
"func_sign": [
"numProvinces(self, adj, V)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n V = int(input())\n adj = []\n\n for i in range(V):\n temp = list(map(int, input().split()))\n adj.append(temp)\n\n ob = Solution()\n print(ob.numProvinces(adj, V))\n print(\"~\")\n",
"solution": "class Solution:\n def numProvinces(self, adj, n):\n # Function to count the number of provinces\n\n n = len(adj) # Get the number of cities/provinces\n visited = [0 for _ in range(n)] # Initialize visited array\n\n def dfs(i):\n # Recursive function to perform depth-first search\n\n visited[i] = 1 # Mark the current city as visited\n\n for city in range(n):\n # Iterate through all the cities adjacent to the current city\n\n if not visited[city] and adj[i][city]:\n # If the adjacent city has not been visited and there is a connection between the two cities\n\n dfs(city) # Recursively call dfs on the adjacent city\n\n count = 0 # Initialize count of provinces\n for i in range(0, n):\n # Iterate through all the cities\n\n if not visited[i]:\n # If the current city has not been visited\n\n dfs(i) # Call dfs on the current city\n count += 1 # Increment the count of provinces\n\n return count # Return the count of provinces\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def numProvinces(self, adj, V):\n # code here "
}
|
eJztV0tOw0AMZcEJOACKIrGrkN1SQJwEiSAW0AWb0EUqISEQh4D7EvKZeGae51MhIUrbRp2xX54dj+2ZvB9+nhwddJ/r43Zw81I+1utNU14VJVf1sqq54ILaL09DqupO8j2dhh1gmJSzolw9r1f3zerh7mnTTIxvVV2+zgrbzHl/qzHUD7k3NQ4HY0JDRmNsh6zPFetM090jB43GbIURsiu0sSYwjsIWsiskKVRcMhPfkEArIThTQnAhFrfnNMsOHhBMzcpLz9l3T3NsoTh2KTPDsiZiKqdulvhRBwKecgkElbfwm0lGlKSvQOimT1gYzClPKJLNFwLkUE5eRmXnFC/h07rBUAGw1FCAIGAqFQiAhYjUEACjq6kDqwghmhp0CwDAaiUFPICu3qaxzu3ubRelH9EkKGZUVjgJqjPC3p8ADTMqvSwIjTNyOqPV0qOX3HOClyypJMYoFLWmKGMQivpaEqMK1coxiRFCc08v7S/zuLUYGrP5o1y7pBvd/fPVWI05+yFlRssJy985ORQ/cXTYbxwR6H7jwBCfMkL7b3cOGjpNWl+i3P7l+gm7/Q63+5YlOWK//o4bS6DxJff24/QLqTS5nA==
|
705,801
|
Rearrange Geek and his Classmates
|
Geek and his classmates are playing a prank on their Computer Science teacher. They change places every time the teacher turns to look at the blackboard.
Examples:
Input:
N = 6
a[] = {0, 5, 1, 2, 4, 3}
Output:
0 3 5 1 4 2
Explanation:
After reshuffling, the modified
position of all the students would be
{
0, 3, 5, 1, 4, 2}.
Input:
N = 5
a[] = {4, 3, 2, 1, 0}
Output:
0 1 2 3 4
Explanation:
After reshuffling, the modified
position of all the students would be
{
0, 1, 2, 3, 4}.
Constraints:
1 ≤ N ≤ 10**5
0 ≤ a[i] ≤ N-1
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1618329863,
"func_sign": [
"void prank(long[] a, int n)"
],
"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 int n = Integer.parseInt(read.readLine());\n \n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n long a[]= new long[n];\n for(int i = 0; i < n; i++)\n a[i] = Long.parseLong(input_line[i]);\n\n Solution ob = new Solution();\n ob.prank(a, n); \n\n for (int i=0;i<n;i++) \n System.out.print(a[i]+\" \"); \n System.out.println();\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 void prank(long[] a, int n) \n { \n // code here\n }\n} "
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1618329863,
"func_sign": [
"prank(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().strip().split()))\n ob = Solution()\n ob.prank(a, n)\n for i in a:\n print(i, end=\" \")\n print()\n print(\"~\")\n",
"solution": "class Solution:\n # Function to perform the prank.\n def prank(self, a, n):\n # Transforming the array elements using the given formula.\n for i in range(n):\n a[i] = a[i] + (a[a[i]] % n) * n\n\n # Bringing back the original elements by dividing with n.\n for i in range(n):\n a[i] = a[i]//n\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def prank(self, a, n): \n #code here"
}
|
eJztms/qZkcRhl14IYdZSpBzqqurq70SwREXZhYijFlMQBDFi9D79XmrS9HRbzQm0c0EAoG8vz7n9NNdf976/vjDP//6Rz+of376Jf/xs9+9+dX7r77+8OYn15vn7fvnfvt+X3mtK655+TUuu57rfvPF9ebdb79698sP7778xW++/tB/cPP/DI2jDf4mr329ff+Ht+/f/P6L66OFJ//69YzrYcXneu7r2z2HBbSM1ZL+6rHG9yBEfj2pZyyWeYKVnsli/GFogaWFUgtq4ddvUUvVYrVerViL1rK1cq3dy796KfbC/LovG/owYxV7tAW3/nbrvVLvpWVZMbXYrkXveog++8U78jasjKKUWl97x5/ylK23nXpUnk3geUtPXHponMe+eOXJPvq+PC/nT/hGoPnlILHLn8vva+xrsC4bEdeY14DpuAbU+DK+lIezW+syHjv1jryb1Xfb4ZP1HqE3/D7PiZavrdUDtx5uB8Gol5r1gqteduvF9fpWn+L1WVGfmPpcPlqfbrUNXlsStT1s0ut7wHl8+favzgt/9slvfvWsc/g/3pLv4DLfChPcBDTr2nFtDqhfe1ybY8Yluq+EGheEZTjA80q/clzJJeP0cez2tYDKAedJ81p+LS6hXeu51n0Fp5ELAHOuEy/DJR1X2BXPFfc1uSB5zXVNjgS3jPcd17RrPte8r8+H9JscUjZM22a1hV7bGbW1qW1ms7XlVtvvhSIKSwoRoITLCp0XxiikKbxAFmor7F5HIOo4pI4GB0THxOrIeB2fqKPEZnzq1NWx489Lh1x/pT/WGlpKK2phra/H8LSdWhYdr7B5k80Lbd5r83qbt9y87F46yOiW3gId37P5rM3XbT5y862bT958+Q6deHShl0bH5mz2aLNVmx3bbNxm/zbbuKeuBrqpb0THTm82fLPvm+3fUNjA2DDZrjuEzrUl6MC2obeBuGG5QbohuwG8hy4buqEdRMcZ2ByFzYnYHIzN+dgck81p2aZbic604dp3dJyrzfHanLKt5MKZ2xy9/ej6otOBvoUJ3Y3uRneju9Hd6G50t+65Ljqwt6gCFx4Jj4RHwiPhkfBIBYSKCOjqEKDTkdDJ0AHROdFx0anR4VkKHeiWzgw6eCQ8Eh4Jj4RHwiPhkaEYgy50xNDBI+GR8Eh4JDwSHgmPnApG6KZOJDp4JDwSHgmPhEfCI+GRrqiFznWA0cEj4ZHwSHgkPBIeCY8cCm/ohs47OngkPBIeCY+ER8Ij4ZGmOIhOedh0S9CploBHKtvDI+GR8EhVJfBIeOStS4UOHgmPhEfCI+GR8MhbkVWhlau5dQe5ivBY8FjwWPBY8FjwWPBYqRiMLnVl0cFjwWPBY8FjwWMpVCtWV7BGVzccne67rr1uv4KAYoFCAjxWKKqjCwUEdPBY8FjwWPBY8FjwWPBYU+Ef3VT8QAePBY8FjwWPBY8FjwWP5coT6FzhBh08FjwWPBY8FjwWPBY81lBCQTcUndDBY8FjwWPBY8FjwWPBY5kyDzpTMFNMQwePpfILHgseCx5LZeKjFIUOHutWCEQHjwWPBY8FjwWPBY91K5cpmRFItyImgRMeAY+AR8Aj4BHwCHhEKuuhSwVYdPAIeAQ8Ah4Bj4BHwCOW0iO6pXiMDh4Bj4BHwCOURJVFFakrj6Kr8I1OwVwxXaFdEV6BHh4Bj5hKuOimoj06eAQ8Ah4Bj4BHwCPgEa7MjM6VHNDBI+AR8Ah4BDwCHgGPGErh6IZyCTp4BDwCHgGPgEfAI+ARplyPzpR6lIHQqR6GR6i+hkeobodHPCoK0MEjbiUsdPAIeAQ8Ah4Bj4BH3KoeVD6Q9rbyG2kOHhMeEx4THhMeEx4THjNVZ6BLpUN08JjwmPCY8JjwmPCY8JhLBQm6peyJDh4THhMeEx4THhMeEx4zVLmgCyVbdPCY8JjwmCpvVN8o/yoNV4mDrnIzOmVqJWzlbaVveEx4THhMVy2EzpXK0cFjwmPCY8JjwmPCY8JjDhVN6IYyPzp4THhMeEx4THhMeEx4TFN1hc5UKKheQAePCY8Jj6lOBx4THvNRGYYOHvNWeYEOHhMeEx4THhMeEx7zVr2mgo0iZasaoSiBh8PD4eHwcHg4PBwenqrs0KWKF3TwcHg4PBweDg+Hh8PDl0pAdEu1Djp4ODwcHg4Ph4fDw+HhoVoRXag0QgcPh4fDw+Hh8HB4ODx8qqhEN1VJoYOHw8NVeKryVFWl4ko1VlWf6KrwQqcyTNWYijJ4ODwcHg4PHypT0Q3Vaejg4fBweDg8HB4OD4eHm+pZdKayTtUdOng4PFydLTwcHg4Pf1T4ooOH3yoG0cHD4eHwcHg4PBwefqtCVolMSblVO1JCwmPAY8BjwGPAY8BjwGOkaml0qVITHTwGPAY8BjwGPAY8BjzGUtGNbqkyRQePAY8BjwGPAY8BjwGPEarO0YUKWXTwGPAY8BjwGPAY8BjwGFNlPLqpuhcdPAY8BjwGPAY8BjwGPIar3kfnKpPRwWOoJVBPoFpZJbMqZxXQ1Rigq6oanWpsldrwGPAY8BjwGPAYpg4CnVp4Uy2ODh5DVgM8BjwGPAY8xqNWAx08xq3SHR08BjwGPAY8BjwGPMatnkRNCQ3AVqVPwQ8Pg4fBw+Bh8DB4GDws1b2gSzUG6OBh8DB4GDwMHgYPg4cttTnolvoIdPAweBg8DB4GD4OHwcNC/RC6UNuBDh4GD4OHwcPgYfAweNhU44RuqktBBw+Dh8HD4GHwMHgYPMzVYaFzNTWyLdC5PBF08DB4GDwMHjbUisnPUA+ETs2aujV1QGqE1A+pLVJ3VD0bumqZ1Dmhk/cDD5PpURYIOvkjskvgYfCwW40WOnjYLXMEHTzsljGD7lYXqDaQdm2rL5NtQpcGj2fLt6F1g8cDjwceT6pfRJdq49Cl/BV08Hjg8aQsJHTweJYaS3RLXR+6JVcG3ZK5hA4eDzweeDyhDhRdqElEF/Jy0MHjgccDj2fKM0I31aqim+op0U05QOjg8bgsJXTweODxuHpaeVdqQdG5fCPZSOjg8cDjGXLL0A01v3K81LGig8cDjwcej8lMQwePR16UTCiTT6YGV30uOvW1am/V5arZVc9bzpbaablr8trUFqODxwOPBx7PLQ9Mpha6W333fX22IT7bEN+PDaHTdU6Z9anzPoXRpzLPKa1te/r0jj7Ns0/36tO+z+mvW2B9K7xvSfStyXOLdJvqVlnfMu9bF30L89xK3c66pda31vsWR9/qPLdct71uvXUU8I4K0VEiT9RQ9KgoYh1VvKNMdNTJE4UUjSoqWUcp76gVHcXyRDVFt4py1lHPOwpGR8U8UVLRsqKmdRT1jqrRUTYr6ir6nihsHZW9o3R01M4TxRXNK6pbR3nvqB+dBfJkBR3oOtHWWcM7i0RnlTxZRneyso51FvLOStFZKk/WUvaqLGad1byzXHTWy5MFlQ0rK1pnSe+sGZ1F82RVZdfKstZZ1zsLR2flPFla2bqytnUW987q0Vk+T9ZX9q8qwLoq8K4SoquGPFWEqomqKqyrDO+qI7oKyapKVJ2cKsW6avGuYqKrmjxVjqqdqnqsqyDvqii6SspTNal6qirKuqryrrKiq648VZhCTVVl1lWad9UWXcXlqeoUaavKs676vKvA6KowT5WoarGqRusq0ruqjK4y81Sdqj6rCrWuSr2r1OiqNU8Vq2q2qlrrKte76o2ugvNUxaqOq0q2rpq9q+joqjpPla1qu6pu6yrcuyqPrtKzqnZV76eKt67qvav86Ko/TxegbqC6AusuwbtriO4i8nQV6i6qy7DuOry7kOiuJE+Xom6luhbrLsa7q4nucvJ0PUoC1QVZd0XeXVJ015Sni1L+rK7Kusvy7rqiu7A8XZm6s+rSrLs27y4uuqvL0+Wp26uuz7oL9O4Ko7vEPF2jusfqIq27Su8uM7rrzNOFqhutrtS6S/XuWqO72KyuVt3t6XKtu17vLji6K87TJatbrq7Zuov27qqju+w8Xbe67+rCrbty7y49umvP08Wrm6+u3rrL9+76o12APK6A3IFyCaxdA28XIdpVyOMyKD2X62DtQni7EtEuRR7XQlVRuRjWroa3yxHteuRxQeSGlCti7ZJ4uybRLkoeV0XuSrks1q6LtwsT7crkcWnk1pRrY+3ieLs60S5Plusj9+e4QNaukLdLFO0a5XGR5CaVq2TtMnm7TtEuVB5XSu5UuVTWrpW3ixXtauVxueR2letl7YJ5u2LRLlke10zuWblo1q6at8sW7brlceHkxpUrZ+3Sebt20S5eHldPhVO5fNaun7cLGO0K5nEJVeuWa2jtInq7itEuYx7XUe5juZDWrqS3SxntWuZxMeVmlqtp7XJ6u57RLmiWKyp39Lik1q6pt4sa7armcVnltpbrau3Ceruy0S5tHtdW7m25uNaurrfLG+365nGB5QaXK2ztEnu7xtEuch5XWe5yuczWrrO3Cx3tSudxqeVWl2tt7WJ7u9rRLnce11vud7ng1q64t0se7ZrncdFV0parbu2ye7vu0S58HldeHUy59NauvbeLH+3q53H55faX6289BfCeCkRPCbKmBpoenCmC9VTBe8oQPXXIM4XQNKKmEtZTCu+pRfQUI89UQ9ONmnJYTz28pyDRU5E8UxJNS2pqYj1F8Z6qRE9Z8kxdNH2pKYz1VMZ7ShM9tckzxdE0p6Y61lMe76lP9BQoz1RI06GaEllPjbynSNFTpTxTJk2baupkPYXynkpFT6nyTK3UbNQUy3qq5T3lip565ZmCVV/69HRs9LRs9vRs9TRt13TtTNmsp27eU7joqVyeKZ36vpraWU/xvKd60VO+PFM/Tf9qCmg9FfSeEkZPDfNMETVNrKmi9ZTRe+oYPYXMM5XUdLKmlNZTS+8pZvRUM8+UU9POmnpaT0G9p6LRU9I8U1NNT2uKaj1V9Z6yRk9d80xhNY2tqaz1lNZ7ahs9xc0z1dV0t6a81lNf7ylw9FQ4z5RYbWBNja2nyN5T5egps9rBT4yl//5XFt/pzyxe/Wbqe/7R1H/43Hzx4Pw3D45v99zv9rGvdu/l2/1vX+9TP7367Cd9w99evfox4P/314B/O1fXf3ewnqu2+MXO6xeGL3/V969/7fkR71cbsP4JuP3jH/71qT//04//ApAuSZk=
|
702,931
|
Check if a string is repetition of its substring of k-length
|
Given a string s, check if it is possible to convert it into a string that is the repetition of a substring of length k. Conversion has to be done by following the steps mentioned below only once:
Examples:
Input:
N = 4
K = 2
S = "bdac"
Output:
1
Explanation:
We can replace either
"bd" with "ac" or "ac" with "bd"
Input:
N = 5
K = 2
S = "abcde"
Output:
0
Explanation:
Since
n
%
k
!= 0, it's not
possible to convert
s
into a string which
is a concatanation of a substring with
length
k
.
Constraints:
2 <= k < n <= 10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int kSubstrConcat(int n, String s, 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 \n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n \n while(t-- > 0)\n {\n int n = sc.nextInt();\n String s = sc.next();\n int k = sc.nextInt();\n int answer = new Solution().kSubstrConcat(n,s,k);\n \t\tSystem.out.println(answer);\n \nSystem.out.println(\"~\");\n}\n \n }\n}\n\n// Contributed By: Pranay Bansal\n",
"script_name": "GfG",
"solution": "class Solution\n{\n int kSubstrConcat(int n, String s, int k)\n {\n // check if n is equal to k, then return 1\n if (n == k) return 1;\n \n // check if n is not divisible by k, then return 0\n\t\tif (n % k != 0) return 0;\n\t\t\n\t\t// create a HashMap to store substrings and their frequencies\n\t\tHashMap <String, Integer> m=new HashMap<>();\n\t\t\n\t\t// iterate over the string in increments of k\n\t\tfor (int i = 0; i < n; i += k)\n\t\t{\n\t\t\t// store substring from i to i+k in HashMap with its frequency\n\t\t\tm.put(s.substring (i, i+k),m.getOrDefault(s.substring(i,i+k),0)+1);\n\t\t}\n\n\t\t// check if there is only one unique substring, then return 1\n\t\tif (m.size () == 1) return 1;\n\t\t\n\t\t// check if there are not exactly two unique substrings, then return 0\n\t\tif (m.size () != 2) return 0;\n\n int val=0;\n // get the frequency value of one substring\n for(int i:m.values()){\n val=i;\n break;\n }\n \n\t\t// check if the frequency value is equal to (n/k - 1) or 1, then return 1\n\t\tif ((val == (n / k - 1)) || (val == 1))\n\t\t\treturn 1;\n\t\t\n\t\t// return 0 if none of the above conditions are satisfied\n\t\treturn 0;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n int kSubstrConcat(int n, String s, int k)\n {\n // Your Code Here \n \n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"kSubstrConcat(self, n, s, k)"
],
"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 s = input()\n k = int(input())\n ob = Solution()\n print(ob.kSubstrConcat(n, s, k))\n print(\"~\")\n",
"solution": "class Solution:\n # Function to check if k substring concatenation is possible or not\n def kSubstrConcat(self, n, s, k):\n # If string length is 1, then k substring concatenation is possible\n if n == 1:\n return 1\n\n # If string length is not divisible by k, then k substring concatenation is not possible\n if n % k:\n return 0\n\n # Create a dictionary to store the count of each substring of length k\n m = {}\n for i in range(0, n, k):\n # If substring is not present in the dictionary, add it with count 0\n if s[i:i+k] not in m:\n m[s[i:i+k]] = 0\n\n # Increment the count of the current substring\n m[s[i:i+k]] += 1\n\n # If there is only one unique substring present, k substring concatenation is possible\n if len(m) == 1:\n return 1\n\n # If there are more than 2 unique substrings, k substring concatenation is not possible\n if len(m) != 2:\n return 0\n\n # Get the count of one unique substring\n v = list(m.values())[0]\n\n # If count is equal to (n//k-1) or 1, k substring concatenation is possible\n if v == (n//k-1) or v == 1:\n return 1\n\n # Otherwise, k substring concatenation is not possible\n return 0\n",
"updated_at_timestamp": 1731510762,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef kSubstrConcat(self, n, s, k):\n\t\t# Your Code Here"
}
|
eJytVEsOgjAUdGE8B+naGP+iV3DnysRnjED9JPhABUWNxkPofS0gikLVFgu8kNCZdqbzOOevvUIuGP0uexkcyBxt1yEdhVQAm4DjsabpOmCNFBVCPZvqDjVGlus8Z50AybGovEIrZYbVdINOWJ3y8WUevgro7faPW2IHDcAFWt4uKoANQYpqICJ5sS+CTCrg/j4A64LgVmTldMZfmWtkHdBertbPh78BLocaWOnDHXez9VgyBBnagDNqmtbWWpmGeBrY+o84Jo6WJzI88jC9383/6F+KAlkr+XTyZP+0J2tU4vpCgQAZJMYaR6JzAvTnRpbOheqXtD9d3IHQw6zdkx4aeBP2rkw+o7F2Tx7BbxKGl9IN91MyNg==
|
713,999
|
Partition the Array
|
Given an arrayA[]ofNintegers. The task is to partition the array into four non-empty contiguous subarraysP, Q, R, and S such that each element of the array A[] should be present in any subarray.
LetW, X, Y, and Z be the sum of the elements inP, Q, R, and S respectively.
Find the smallest absolute difference between the maximum and the minimum among W, X, Y, and Z.
Examples:
Input:
N = 5
A[] = [4,2,2,5,1]
Output:
4
Explanation:
let partition the array
P,Q,R,S = [4],[2,2],[5],[1]
W = 4, X = 4, Y = 5, Z = 1
Differnce = max(W,X,Y,Z)-min(W,X,Y,Z)= 5-1 = 4
Input:
N = 4
A[] = {4,4,4,4}
Output:
0
Explanation:
There is only one way to partition
the array. P,Q,R,S = [4],[4],[4],[4]
Constraints:
4
<
N
<
10**5
1
<
A[i]
<
10**9
|
geeksforgeeks
|
Hard
|
{
"class_name": "Solution",
"created_at_timestamp": 1676008416,
"func_sign": [
"long minDifference(int N, int A[])"
],
"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 int N = Integer.parseInt(read.readLine());\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int A[]= new int[N];\n for(int i = 0; i < N; i++)\n A[i] = Integer.parseInt(input_line[i]);\n\n Solution ob = new Solution();\n long ans = ob.minDifference(N, A); \n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n } \n} ",
"script_name": "GFG",
"solution": "class Solution \n{\n\tArrayList<long []> help(int [] a){\n int n=a.length;\n long [] p = new long[n+1];\n for(int i=0;i<n;i++){\n p[i]=a[i];\n if(i>0){\n p[i]+=p[i-1];\n }\n }\n ArrayList<long []> tmp = new ArrayList<>();\n long arr[] = {0,0};\n tmp.add(arr);\n for(int i=1;i<n;i++){\n int l=1,h=i;\n long dif = (long)2e18;\n long [] t = new long[2];\n \n while(l<=h){\n int mid=(l+h)/2;\n long x=p[mid-1];\n long y=p[i]-x;\n \n if(Math.abs(x-y)<dif){\n dif=Math.abs(x-y);\n t[0] = x; t[1] = y;\n }\n \n if(x>y){\n h=mid-1;\n }\n else{\n l=mid+1;\n }\n }\n tmp.add(t);\n }\n \n return tmp;\n }\n\tvoid reverse(int a[])\n {\n\t\tint n = a.length;\n int i, k, t;\n for (i = 0; i < n / 2; i++) {\n t = a[i];\n a[i] = a[n - i - 1];\n a[n - i - 1] = t;\n }\n \n }\n \n\tlong minDifference(int N, int A[]) \n\t{ \n\t\tlong ans = (long)2e18;\n\t\tArrayList<long []> x = help(A);\n\t\treverse(A);\n ArrayList<long []> y = help(A);\n Collections.reverse(y);\n for(int i=1;i+2<N;i++) {\n ans=Math.min(ans, Math.max(Math.max(x.get(i)[0],x.get(i)[1]), Math.max(y.get(i+1)[0],y.get(i+1)[1])) - Math.min(Math.min(x.get(i)[0],x.get(i)[1]), Math.min(y.get(i+1)[0],y.get(i+1)[1])));\n }\n\t\treturn ans;\n\t}\n}",
"updated_at_timestamp": 1730482194,
"user_code": "//User function Template for Java\nclass Solution \n{ \n long minDifference(int N, int A[]) \n { \n // code here\n }\n} "
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1676008416,
"func_sign": [
"minDifference(self, N, A)"
],
"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().strip().split()))\n ob = Solution()\n ans = ob.minDifference(N, A)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n\n def minDifference(self, N, A):\n # code here\n x = self.partition(A, N)\n A.reverse()\n y = self.partition(A, N)\n y.reverse()\n ans = 10**18\n for i in range(1, N-2):\n ans = min(ans, max(x[i][0], x[i][1], y[i+1][0], y[i+1]\n [1]) - min(x[i][0], x[i][1], y[i+1][0], y[i+1][1]))\n return ans\n\n def partition(self, A, n):\n tmp = [(0, 0)]\n p = A[:]\n for i in range(1, n):\n p[i] += p[i-1]\n for i in range(1, n):\n diff = 10**18\n hi = i\n lo = 1\n ans = (0, 0)\n while lo <= hi:\n mid = (lo + hi) // 2\n x = p[mid-1]\n y = p[i] - x\n if abs(x-y) < diff:\n diff = abs(x-y)\n ans = (x, y)\n if x > y:\n hi = mid-1\n else:\n lo = mid + 1\n tmp.append(ans)\n return tmp\n",
"updated_at_timestamp": 1730482194,
"user_code": "#User function Template for python3\nclass Solution:\n def minDifference(self, N, A): \n #code here\n"
}
|
eJylVEFOwzAQ5IB4x8jnCnkdx0l4CRJBHCAHLqGHVqpAIPgD/BfX6wKNMkkAO9Jair07np3x6+nH29lJGpePcXH1ZO779XZjLmCk7au2FwtnUVh4i9IiWFTWrGC63bq73XR3Nw/bTT5Q2LZ/aXvzvMJxmnqfJg00aWioNVQagoZSg9dQkFLiSCmJGARaDQsWLH/6SWqU8UOe5HxJjoaE7jDtFARlikMQOBTwFAJjqDmCoJOxwEj+WR4BFWIr43UgMZeDFBAPYcDYnfyXSnKDKK7mMDjL3zJTlanIVGMqMT+RnLVv6AeZNoQvRyWE3MCE0YWZPuZtrJ0KSYkbGNVSYGo4pu9RD/3BRHWifyGVyuS/xUXfoKwuN6+u/TZZLK9f66ueSj16+fwgLvZXQsK8O+eNZhZ8YO4YoZiKesjx9fv5J3iswrc=
|
704,401
|
Euler Totient Sum and Divisors
|
Given a number N find the sum ofthe Euler Totient values of all the divisors of N.
Examples:
Input:
N = 5
Output:
5
Explanation:
1 and 5 are the factor
of 5 and Φ(1) = 1 and
Φ(5) = 4 and their sum
is 4 + 1 = 5
Input:
N = 1
Output:
1
Explanation:
1 is the only factor of
1 and Φ(1) = 1
Constraints:
1 <= N <= 10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int phiSum(int N)"
],
"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 int N = Integer.parseInt(read.readLine());\n Solution ob = new Solution();\n System.out.println(ob.phiSum(N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n // function to calculate the phi sum of N\n static int phiSum(int N) {\n // return N as the answer.\n return N;\n }\n}\n",
"updated_at_timestamp": 1730474736,
"user_code": "//User function Template for Java\nclass Solution{\n static int phiSum(int N) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"phiSum(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.phiSum(N))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def phiSum(self, N):\n # return N as the answer\n return N\n",
"updated_at_timestamp": 1730474736,
"user_code": "#User function Template for python3\nclass Solution:\n def phiSum (self, N):\n # code here"
}
|
eJyVlEEKwjAURF30ICXrIk1SU/UkghUX2oWb2kULgigeQg/jzqOZhn6o0JliVoXJy5/8P+kjen2iWVibt//YXtWpqttGrWOli0qnYRWVSmJVXury0JTH/bltZIvod7/llsS/9MqvpYWwyKOsTk1GynbiKOewWYd95sRkDijrINRJo4yBiEF9MDZb4Eoiw/5r2n4NyHzpMovNikwcS1u5cVRfGzp+g+cftEHf+CGkPgNJ9kI0iz4efycxuO7hiaFj64Mj2PXJGX6009FD8+9zJa974geALLhBCsmTFnz3nH8Bf9R4KQ==
|
700,419
|
Palindromic Array
|
Given an array arr[] of positive integers. Return true if all the array elements are palindrome otherwise, return false.
Examples:
Input:
arr[]
= [
111, 222, 333, 444, 555]
Output:
true
Explanation:
arr[0] = 111, which is a palindrome number.
arr[1] = 222, which is a palindrome number.
arr[2] = 333, which is a palindrome number.
arr[3] = 444, which is a palindrome number.
arr[4] = 555, which is a palindrome number.
As all numbers are palindrome so This will return true.
Input:
arr[] = [121, 131, 20]
Output:
false
Explanation:
20 is not a palindrome hence the output is false.
Constraints:
1 <=arr.size<= 20
1 <=arr[i]<= 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1617623982,
"func_sign": [
"public static boolean palinArray(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.palinArray(arr) ? \"true\" : \"false\");\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "/*Complete the Function below*/\nclass Solution {\n public static boolean palinArray(int[] arr) {\n // add code here.\n }\n}"
}
|
{
"class_name": null,
"created_at_timestamp": 1617623982,
"func_sign": [
"PalinArray(arr)"
],
"initial_code": "# Driver Program\nif __name__ == '__main__':\n t = int(input())\n for i in range(t):\n arr = list(map(int, input().strip().split()))\n if PalinArray(arr):\n print(\"true\")\n else:\n print(\"false\")\n print(\"~\")\n# Contributed By: Harshit Sidhwa\n",
"solution": "def PalinArray(arr):\n # iterating over each element in the array\n for i in arr:\n # checking if the string representation of the element\n # is not equal to its reverse, if so return False\n if str(i) != str(i)[::-1]:\n return False\n # if all elements pass the condition, return True\n return True\n",
"updated_at_timestamp": 1729753320,
"user_code": "# Your task is to complete this function\n# Function should return true/false\ndef PalinArray(arr):\n # Code here\n"
}
|
eJzFlc+KFDEQxj148DGKPi9S+duJTyLYi4iOsCDtojMgiOLFm8f1ff2lOuDB3WUmu4NVU2HorqS+fF9S/ePp71/Pnpi9/MmfV1+nq/X6sJ9eyOSWtf2mC5l2X653b/e7d68/Hvb97f7TYbes35d1+nYh/8yqp8/yykxVceoITwQiEonIxEwUoopz5DnyHHmOPEeeI8+R58hz5Lm7QLx/8+HzvSjEewkSoyTJWWYpRaipAPMKsqBAiwq2pIDLCrpZgVcUfFUBWLHB6m1qpSQmczMwYJKaAQqT0AyUWOOhMaENntU2FIbHkBlGQ2u4bQe2Fx2lxwfvJKacosylFuj2PAgxBkk5Jx7yrKJjI63J6R0ugXnwFnBJEZfMGlCXcSkzLpX1at/Stj3b6ihS1S5al60L16Xr4nX5uoBdwkbkwEYVHwCbjNXYym1FTVJv1VM8/S6Fbb0EnwCXDLd54B53Ct12Xrh0hkobvqCBMWpkTJoYs2bGWWfGouWuvnGEZve1gO0unL8PoIj3yzIqwHAbWR+tj2xE/tdmykq3EnHmLtq0e4RLdCyJeguLf2nUc32UWPKEA2Vfj86roRrkNtBNygOOwhFTL2+e/wETITYH
|
704,565
|
Second Binary Digit
|
Given two numbers A and Bcount all the number between the given range whose second least significant digit in the binary representation of the number is 1.
Examples:
Input:
A = 1
B = 4
Output:
2
Explanation:
In the given range 2 (10)
and 3 (11) are the numbers
whose second least
significant digit in its
binary representation is 1.
Input:
A = 8
B = 10
Output:
1
Explanation:
In the given range 10 (1010)
is the number whose second
least significant digit in its
binary representation is 1
Constraints:
1 <= A,B<= 10**9
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int find(int A,int B)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])throws IOException\n {\n Scanner in = new Scanner(System.in);\n int t = in.nextInt();\n while(t-- > 0)\n {\n int A = in.nextInt();\n int B = in.nextInt();\n Solution ob = new Solution();\n System.out.println(ob.find(A,B));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n int find(int A, int B) {\n int ans = 0;\n // if A%4 == 1 A+1 , and A+2 will have\n // 1 at there 2nd least significant bit\n if (A % 4 == 1) {\n A += 3;\n ans += 2;\n }\n // if A%4 == 2 A and A+1 will have\n // 1 at there 2nd least significant bit\n else if (A % 4 == 2) {\n A += 2;\n ans += 2;\n }\n // if A%4 == 3 then only A will have\n // 1 at there 2nd least significant bit\n else if (A % 4 == 3) {\n A += 1;\n ans += 1;\n }\n // if B%4 == 2 then only B will have\n // 1 at there 2nd least significant bit\n if (B % 4 == 2) {\n B = B - 2;\n ans += 1;\n }\n // if A%4 == 3 B , and B-1 will have\n // 1 at there 2nd least significant bit\n else if (B % 4 == 3) {\n B = B - 3;\n ans += 2;\n }\n // every number which has remainder when devided by 4\n // as 2 or 3 will have 1 at there 2nd least significant bit\n ans += (B - A) / 4 * 2;\n return ans;\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution{\n int find(int A,int B){\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"find(self, A, B)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n A, B = input().split()\n ob = Solution()\n print(ob.find(int(A), int(B)))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def find(self, A, B):\n ans = 0\n # if A%4 == 1 A+1 , and A+2 will have\n # 1 at there 2nd least significant bit\n if A % 4 == 1:\n A += 3\n ans += 2\n # if A%4 == 2 A and A+1 will have\n # 1 at there 2nd least significant bit\n elif A % 4 == 2:\n A += 2\n ans += 2\n # if A%4 == 3 then only A will have\n # 1 at there 2nd least significant bit\n elif A % 4 == 3:\n A += 1\n ans += 1\n # if B%4 == 2 then only B will have\n # 1 at there 2nd least significant bit\n if B % 4 == 2:\n B = B - 2\n ans += 1\n # if A%4 == 3 B , and B-1 will have\n # 1 at there 2nd least significant bit\n elif B % 4 == 3:\n B = B - 3\n ans += 2\n # every number which has remainder when devided by 4\n # as 2 or 3 will have 1 at there 2nd least significant bit\n ans += ((B - A) // 4) * 2\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def find(self, A, B):\n # code here"
}
|
eJydkkEKwjAURF30IJ+sW0napBpPIhhxoV24SbtoiyCKh9D7GmOLiExK/KtC+iYzk39LHn0y87Ou3cfmzI626Vq2IiaMFSRYSqw6NdW+rQ67umuHQ27s1Vh2SembyKkARA6IAhICEJJktCsV6YqT4ABRABGOQcYKwOhx3HXjRLYxKpTTEijsB5zWQBW/0sP4CuWXDkNQlnNoGC9mBp8nCCGK/3aDNKTWyv8QasjvO0oM4wZrWsCa+D9b7E0GuiqDJt+wf1jc03KQ2N7nT+R/WJ8=
|
705,146
|
Next Permutation
|
Implement the next permutation, which rearranges the list of numbers into Lexicographically next greater permutation of the list of numbers. If such an arrangement is not possible, it must be rearranged to the lowest possible order i.e. sorted in ascending order. You are given a list of numbers arr[ ].
Examples:
Input:
arr = [1, 2, 3, 6, 5, 4]
Output:
[1, 2, 4, 3, 5, 6]
Explanation:
The next permutation of the given array is {1, 2, 4, 3, 5, 6}.
Input:
arr = [3, 2, 1]
Output:
[1, 2, 3]
Explanation:
As arr[] is the last permutation. So, the next permutation is the lowest one.
Constraints:
1 ≤ arr.size() ≤ 10**5
1 ≤ arr[i] ≤ 10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1730982469,
"func_sign": [
"void nextPermutation(int[] arr)"
],
"initial_code": "import java.io.BufferedReader;\nimport java.io.InputStreamReader;\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()); // Number of test cases\n while (tc-- > 0) {\n String[] inputLine = br.readLine().split(\" \");\n int[] arr = new int[inputLine.length];\n for (int i = 0; i < inputLine.length; i++) {\n arr[i] = Integer.parseInt(inputLine[i]);\n }\n int N = arr.length;\n Solution ob = new Solution();\n ob.nextPermutation(arr); // Generate the next permutation\n StringBuilder out = new StringBuilder();\n for (int i = 0; i < N; i++) {\n out.append(arr[i] + \" \"); // Corrected: use arr[i] instead of arr.get(i)\n }\n System.out.println(out.toString().trim()); // Print the output\n }\n }\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1730982469,
"user_code": "// User function Template for Java\n\nclass Solution {\n void nextPermutation(int[] arr) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1730982469,
"func_sign": [
"nextPermutation(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\n ob = Solution()\n ob.nextPermutation(arr)\n for i in range(N):\n print(arr[i], end=\" \")\n print()\n",
"solution": "# Backend Complete function Template for python3\nclass Solution:\n\n # Function to find the next permutation of the array.\n def nextPermutation(self, arr):\n ind = 0\n N = len(arr)\n # iterating from second last element to the first element.\n # to find the element where the next permutation needs to be done.\n for i in range(N - 2, -1, -1):\n # if the current element is smaller than the next element,\n # then we have found the position to perform the next permutation.\n if arr[i] < arr[i + 1]:\n ind = i\n break\n\n # iterating from last element to the indth element of the array.\n # to find the smallest element greater than the element at ind.\n for i in range(N - 1, ind, -1):\n # if we find the smallest element, we swap it with the element at ind.\n if arr[i] > arr[ind]:\n arr[i], arr[ind] = arr[ind], arr[i]\n break\n\n # reversing the elements from ind+1 to the end of the array.\n for i in range((N - ind) // 2):\n arr[i + ind], arr[N - i - 1] = arr[N - i - 1], arr[i + ind]\n",
"updated_at_timestamp": 1730982469,
"user_code": "#User function Template for python3\n\nclass Solution:\n def nextPermutation(self, arr):\n # code here"
}
|
eJyVU8GKwkAM3YP7H2HOIp3pxNbFDxFUPKw9eKkeWhBkYT9i/V+TGafikoy1A20hr+8l76W/k+vy8yNcK6SX9cUc2lPfmS8wdtNaKMGBhzmgmYJpzqfmu2v2u2PfJdADAZvW/EzhmQGpVlGNURYKhQWhoKojVERLTAuoqcY6PrKpHUUeJGxF3yxENkt6CHzXedKR+4kK+bn8MBdj5T7KUHcvZooI5uKn7DQGFTqqywNC6QXJL393ucx0wzgbXJ6reaWc8kmlrCSGOHF0WPeYUcU9KcaqW1hClesGg7sJJ7JU7p2ZFJZhgV2uF5/SFkg0J/JaWSlZiLdc3WzFZzvSoADV97ges8i1usmquIj+n8rY/yDSbf9mN46aYm0=
|
701,429
|
Longest Common Subsequence
|
Given two strings str1 & str 2 of length n & m respectively, return the length of their longest common subsequence. If there is no common subsequence then, return 0.
Examples:
Input:
n = 6, str1 = ABCDGH and m = 6, str2 = AEDFHR
Output:
3
Explanation:
LCS for input strings “ABCDGH” and “AEDFHR” is “ADH” of length 3.
Input:
n = 3, str1 = ABC and m = 2, str2 = AC
Output:
2
Explanation:
LCS of "ABC" and "AC" is "AC" of length 2.
Input:
n = 4, str1 = XYZW and m = 4, str2 = XYWZ
Output:
3
Explanation:
There are two common subsequences of length 3 “XYZ”, and”XYW”, and no common subsequence. of length more than 3.
Constraints:
1<= n, m <=10**3**str1 and str2 are in uppercase alphabet
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1618298485,
"func_sign": [
"static int lcs(int n, int m, String str1, String str2)"
],
"initial_code": "import java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\nclass GFG {\n public static void main(String[] args) {\n\n Scanner sc = new Scanner(System.in);\n int test = sc.nextInt();\n while (test-- > 0) {\n int n = sc.nextInt(); // Take size of both the strings as input\n int m = sc.nextInt();\n\n String str1 = sc.next(); // Take both the string as input\n String str2 = sc.next();\n\n Solution obj = new Solution();\n\n System.out.println(obj.lcs(n, m, str1, str2));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n // Function to find the length of longest common subsequence in two strings.\n static int lcs(int n, int m, String str1, String str2) {\n // your code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1618298485,
"func_sign": [
"lcs(self, n, m, str1, str2)"
],
"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\n for cases in range(test_cases):\n n, m = map(int, input().strip().split())\n str1 = str(input())\n str2 = str(input())\n\n ob = Solution()\n print(ob.lcs(n, m, str1, str2))\n\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n # Function to find the length of longest common subsequence in two strings.\n def lcs(self, n, m, str1, str2):\n\n # using dp[][] array to store length of LCS.\n dp = [[0] * 1001 for _ in range(1001)]\n\n # Following steps build dp[x+1][y+1] in bottom up fashion. Note that\n # dp[i][j] contains length of LCS of s1[0..i-1] and s2[0..j-1].\n for i in range(n + 1):\n for j in range(m + 1):\n\n # if i or j is 0, we mark dp[i][j] as 0.\n if i == 0 or j == 0:\n dp[i][j] = 0\n\n # else if the current char in both strings are equal, we add 1\n # to the output we got without including these both characters.\n elif str1[i - 1] == str2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1] + 1\n\n # else s1[i-1]!=s2[j-1] so we check the max output which\n # comes from s1 or s2 without considering current character.\n else:\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n\n # returning the result.\n return dp[n][m]\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to find the length of longest common subsequence in two strings.\n def lcs(self, n, m, str1, str2):\n \n # code here"
}
|
eJy9VEtOwzAQZQH3sLyukB2IitjZTv//fxKMWEAWbEwXqYSEQBwCjsmOAzBOm4SosUUKIlFGVmbe+M3zjF+P3z9PjpLH/4DF1RO+V+tNjC8RplJRBIZJxaXCNYSjx3V0G0d3Nw+beBdEpHoB53MNFZEOcgDJtp8B6xiw6a5mJC1DQjoXuQDjwmtI1Wy1O11N5EwqP5Aq1MZahYkPQeDXb0UNqMaxA4BEC3CI6i6iJBOAMcY5F0J4xjznZXlAL0ryRDsde/3BcDSeTGfzoswNT3Co8QLV83ipWs3kv5U+/WZLSiHILVDICSyWKz8IzR4bKgz81XIxn00n49Fw0O91O207V6deQaP/FimZFDsL6xyV9pG92feDbR1uHKasy6WuQLd69elKa1dp8fvD/6uk2S2k77O/22ErGal+JqATIT8+Foi3A67fTr8AD8rhIw==
|
706,254
|
Open the gates
|
Geek and his friends went on a trip to one of the hill stations in Geekland. While trekking they found a treasure map, it was in the form of r x c size board, each cell on the map denotes a latin uppercase letter. On the bottom of the map it was written that there are n gates with a specific name and if they could find out the name of the gate on the map that gate would open. Help Geek and his friends to find out the gates they could possibly open with the map they found.
Examples:
Input:
n = 3
gate_names = {"ZARA", "ZETH", "MYTH"}
r = 3, c = 3
map = A Z E
R Y T
M A H
Output:
{"ZARA", "ZETH", "MYTH"}
Explanation:
Opening gate ZARA
A
Z
E
R
Y T
M
A
H
Opening gate ZETH
A
Z
E
R Y
T
M A
H
Opening gate MYTH
A Z E
R
Y
T
M
A
H
Input:
n = 5
gate_names = {"NYX","ONYX","VIRA","KARA", "NYX"}
r = 3, c = 3
map = N O A
P Y V
K R X
Output:
{"NYX", "ONYX"}
Explanation:
Opening gate NYX
N
O A
P
Y
V
K R
X
Opening gate ONYX
N
O
A
P
Y
V
K R
X
Note that NYX is counted only once.
Expected Time Complexity:
O(4^(N^2))
Expected Auxiliary Space:
O(N^2)
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public String[] wordBoggle(char board[][], String[] dictionary)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG\n{\n public static void main(String args[])\n {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while(t>0)\n {\n int N = sc.nextInt();\n String[] dictionary = new String[N];\n for(int i=0;i<N;i++)\n {\n dictionary[i] = sc.next();\n }\n \n int R = Integer.parseInt(sc.next());\n int C = Integer.parseInt(sc.next());\n \n char board[][] = new char[R][C];\n for(int i=0;i<R;i++)\n {\n for(int j=0;j<C;j++)\n {\n board[i][j] = sc.next().charAt(0);\n }\n }\n \n Solution obj = new Solution();\n String[] ans = obj.wordBoggle(board, dictionary);\n \n if(ans.length == 0) System.out.println(\"-1\");\n else\n {\n Arrays.sort(ans);\n for(int i=0;i<ans.length;i++)\n {\n System.out.print(ans[i] + \" \");\n }\n System.out.println();\n }\n \n t--;\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n // Alphabet size\n static int SIZE = 26;\n static int M, N;\n\n // trie Node\n static class TrieNode {\n TrieNode[] Child = new TrieNode[SIZE];\n // isLeaf is true if the node represents\n // end of a word\n boolean leaf;\n\n // constructor\n public TrieNode() {\n leaf = false;\n for (int i = 0; i < SIZE; i++) Child[i] = null;\n }\n }\n\n static int char_int(char c) {\n return c - 'A';\n } // If not present, inserts a key into the trie\n\n // If the key is a prefix of trie node, just\n // marks leaf node\n void insert(TrieNode root, String Key) {\n int n = Key.length();\n TrieNode pChild = root;\n for (int i = 0; i < n; i++) {\n int index = Key.charAt(i) - 'A';\n if (pChild.Child[index] == null) pChild.Child[index] = new TrieNode();\n\n pChild = pChild.Child[index];\n }\n // make last node as leaf node\n pChild.leaf = true;\n }\n\n // function to check that current location\n // (i and j) is in matrix range\n static boolean isSafe(int i, int j, boolean[][] visited) {\n return (i >= 0 && i < M && j >= 0 && j < N && !visited[i][j]);\n }\n\n // A recursive function to print all words present on boggle\n static void searchWord(\n TrieNode root,\n char boggle[][],\n int i,\n int j,\n boolean visited[][],\n String str,\n Set<String> fans) {\n // if we found word in trie / dictionary\n if (root.leaf == true) fans.add(str);\n // If both I and j in range and we visited\n // that element of matrix first time\n if (isSafe(i, j, visited)) {\n // make it visited\n visited[i][j] = true;\n // traverse all childs of current root\n for (int k = 0; k < SIZE; k++) {\n if (root.Child[k] != null) {\n // current character\n char ch = (char) (k + 'A');\n // Recursively search reaming character of word\n // in trie for all 8 adjacent cells of boggle[i][j]\n if (isSafe(i + 1, j + 1, visited) && boggle[i + 1][j + 1] == ch)\n searchWord(root.Child[k], boggle, i + 1, j + 1, visited, str + ch, fans);\n if (isSafe(i, j + 1, visited) && boggle[i][j + 1] == ch)\n searchWord(root.Child[k], boggle, i, j + 1, visited, str + ch, fans);\n if (isSafe(i - 1, j + 1, visited) && boggle[i - 1][j + 1] == ch)\n searchWord(root.Child[k], boggle, i - 1, j + 1, visited, str + ch, fans);\n if (isSafe(i + 1, j, visited) && boggle[i + 1][j] == ch)\n searchWord(root.Child[k], boggle, i + 1, j, visited, str + ch, fans);\n if (isSafe(i + 1, j - 1, visited) && boggle[i + 1][j - 1] == ch)\n searchWord(root.Child[k], boggle, i + 1, j - 1, visited, str + ch, fans);\n if (isSafe(i, j - 1, visited) && boggle[i][j - 1] == ch)\n searchWord(root.Child[k], boggle, i, j - 1, visited, str + ch, fans);\n if (isSafe(i - 1, j - 1, visited) && boggle[i - 1][j - 1] == ch)\n searchWord(root.Child[k], boggle, i - 1, j - 1, visited, str + ch, fans);\n if (isSafe(i - 1, j, visited) && boggle[i - 1][j] == ch)\n searchWord(root.Child[k], boggle, i - 1, j, visited, str + ch, fans);\n }\n }\n // make current element unvisited\n visited[i][j] = false;\n }\n }\n\n // Prints all words present in dictionary.\n static String[] findWords(char boggle[][], TrieNode root) {\n // Mark all characters as not visited\n M = boggle.length;\n N = boggle[0].length;\n boolean[][] visited = new boolean[M][N];\n TrieNode pChild = root;\n String str = \"\";\n Set<String> fans = new HashSet<String>();\n // traverse all matrix elements\n for (int i = 0; i < M; i++) {\n for (int j = 0; j < N; j++) {\n // we start searching for word in dictionary\n // if we found a character which is child\n // of Trie root\n if (pChild.Child[char_int(boggle[i][j])] != null) {\n str = str + boggle[i][j];\n searchWord(pChild.Child[char_int(boggle[i][j])], boggle, i, j, visited, str, fans);\n str = \"\";\n }\n }\n }\n String[] ans = new String[fans.size()];\n int i = 0;\n for (String el : fans) ans[i++] = el;\n return ans;\n }\n\n public String[] wordBoggle(char boggle[][], String[] dictionary) {\n TrieNode root = new TrieNode();\n int n = dictionary.length;\n for (int i = 0; i < n; i++) insert(root, dictionary[i]);\n return findWords(boggle, root);\n }\n}\n;\n",
"updated_at_timestamp": 1730271844,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public String[] wordBoggle(char board[][], String[] dictionary)\n {\n // Write your code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"wordBoggle(self,board,dictionary)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n N = int(input())\n dictionary = [x for x in input().strip().split()]\n line = input().strip().split()\n R = int(line[0])\n C = int(line[1])\n board = []\n for _ in range(R):\n board.append([x for x in input().strip().split()])\n obj = Solution()\n found = obj.wordBoggle(board, dictionary)\n if len(found) == 0:\n print(-1)\n continue\n found.sort() # sorting output\n for i in found:\n print(i, end=' ')\n print()\n print(\"~\")\n",
"solution": "SIZE = 26\n\n\nclass TrieNode():\n def __init__(self):\n self.leaf = False\n self.child = [None]*SIZE\n for i in range(SIZE):\n self.child[i] = None\n\n\nclass Solution():\n\n def insert(self, root, key):\n\n n = len(key)\n pChild = root\n\n for i in range(n):\n index = ord(key[i]) - ord('A')\n if pChild.child[index] == None:\n pChild.child[index] = TrieNode()\n\n pChild = pChild.child[index]\n\n pChild.leaf = True\n\n def isSafe(self, i, j, visited):\n if i >= 0 and i < self.M and j >= 0 and j < self.N and visited[i][j] == False:\n return True\n return False\n\n def searchWord(self, root, boggle, i, j, visited, s, fans):\n if root.leaf == True:\n fans.add(s)\n\n if self.isSafe(i, j, visited):\n visited[i][j] = True\n\n for k in range(SIZE):\n if root.child[k] != None:\n ch = chr(k+ord('A'))\n\n if self.isSafe(i + 1, j + 1, visited) and boggle[i + 1][j + 1] == ch:\n self.searchWord(\n root.child[k], boggle, i + 1, j + 1, visited, s + ch, fans)\n\n if self.isSafe(i, j + 1, visited) and boggle[i][j + 1] == ch:\n self.searchWord(\n root.child[k], boggle, i, j + 1, visited, s + ch, fans)\n\n if self.isSafe(i - 1, j + 1, visited) and boggle[i - 1][j + 1] == ch:\n self.searchWord(\n root.child[k], boggle, i - 1, j + 1, visited, s + ch, fans)\n\n if self.isSafe(i + 1, j, visited) and boggle[i + 1][j] == ch:\n self.searchWord(\n root.child[k], boggle, i + 1, j, visited, s + ch, fans)\n\n if self.isSafe(i + 1, j - 1, visited) and boggle[i + 1][j - 1] == ch:\n self.searchWord(\n root.child[k], boggle, i + 1, j - 1, visited, s + ch, fans)\n\n if self.isSafe(i, j - 1, visited) and boggle[i][j - 1] == ch:\n self.searchWord(\n root.child[k], boggle, i, j - 1, visited, s + ch, fans)\n\n if self.isSafe(i - 1, j - 1, visited) and boggle[i - 1][j - 1] == ch:\n self.searchWord(\n root.child[k], boggle, i - 1, j - 1, visited, s + ch, fans)\n\n if self.isSafe(i - 1, j, visited) and boggle[i - 1][j] == ch:\n self.searchWord(\n root.child[k], boggle, i - 1, j, visited, s + ch, fans)\n\n visited[i][j] = False\n\n def findWords(self, boggle, root):\n # Mark all characters as not visited\n self.M = len(boggle)\n self.N = len(boggle[0])\n visited = [[False for i in range(self.N)] for i in range(self.M)]\n\n pChild = root\n\n s = \"\"\n fans = set()\n\n # traverse all matrix elements\n for i in range(self.M):\n for j in range(self.N):\n # we start searching for word in dictionary\n # if we found a character which is child\n # of Trie root\n index = ord(boggle[i][j]) - ord('A')\n if pChild.child[index] != None:\n s = s + boggle[i][j]\n self.searchWord(\n pChild.child[index], boggle, i, j, visited, s, fans)\n s = \"\"\n\n ans = []\n for el in fans:\n ans.append(el)\n return ans\n\n def wordBoggle(self, boggle, dictionary):\n root = TrieNode()\n n = len(dictionary)\n for i in range(n):\n self.insert(root, dictionary[i])\n\n return self.findWords(boggle, root)\n",
"updated_at_timestamp": 1730271844,
"user_code": "#User function Template for python3\n\nclass Solution:\n def wordBoggle(self,board,dictionary):\n # return list of words(str) found in the board"
}
|
eJztWUuP40QQ5sAPKc0NaUGTEbuw3Dp2j90bu+2xOzPJYMQB9sDF7GFXQkIgDty4wv/lq+p24mRsZ3aWxz48ozjtrqru+urVj/z28V9/fPKR/G1+R+Prn89+aF+8enn2FZ0tmvZJ06plFOvdp2kXj2nxGN20pIhi0kPfTTtBpLhpJ4ikm3aCSFBhgjjP/dC5m/bsEZ09/+nF8+9ePv/+2x9fvQxhcBgA1LS/gvWXR3QYKV80baqzrKCbospiKrcuLSwlWq8oUzamqIg15aps2otzujgHNybP8F/QZKtpTzB0raY9OZZvvQZjcVo/bjGYe7GyC+/Fyjrei5UZ78XqwdyDtQNzknUP5gRrH8wk6yGYCdZjMKOsd8GMsA6BGWQdBjPAOgbmDus4mCPWiRz1qTeSmp837WVR0FJV+NzS1XqDKn5OCyThJUYu6ODJ6tzp9pxH3R3nkfjJMQc4/5ExRXzURGyCEQNhOYuKvMz0hlJVoXitb28zmHtxQYsLLpwF5VSKOzbUe2MVBgkEC48QuFCPELrgGiBQzgE6SCCU1BECx9ZbovyoWzrDj7iGg1RlZYrthnaKEpXnimKdoa3L2mRYY26ZwB+X8tMUeKxUWapdlO/3KpeUIJMMPWtarEtQ00K9kq6ooppc067pmm6g9ZZuSXULZ0+MghQbbydGQappe2LdZE3bE+sma9qeWDdZt0IfTMauONCRpSbM+eli0IqI8Fy5ymzoWkeuqMhpW+OrjlTGZcFYVW2p1qqKUgLBUa6rRKNWmGhFqVYlMqMGySm8X631WpOrtKakUmW62xTmwOGgpwGqa0CJ8FbgvcQHBciHnZaGETCctFugfoY3rnMxDLJi+1wBp4KUwygVxmJihB62hbeYYReylQqJNTZTjVYNARaMYMON994mTKbB4tBWUlD3FtXsjki6lUy2V9wLsW7iM99l0JVgQtYskekyfDPNeMUN5FfUsafCAgPiWePpfFJmYGSllzIeT7wV22n8JzwdHkGuFsJatFoLCytvOa8YB2uU43Mr1jcY2wrTpWgo20omqIFxeFqeZesjUoniDEHLp6cPq8KraSQ4KmH1zvHGZcw1prScROyhTLwVQ6uleP8Gb0b6oOdEBIdYlMDyQSfhF8K3C0sOQB+cIYT7seujNIS4hGmI+pEi82XTWt6e6hhjl8oB5TbKQnCT1Q572hW+15XKQq5AiFgMwGKx43Ct4HKpJAZCGnOATBeNvuNDbeCt/T5IrDgHAdJ5x4qnbnyQnrKrYAzAGLPAHSu+vPhl69rpqrN/ZwyVJUVlXJpTrFBva1etI7eusJ0xFp7A2Da01BJEFTmcAGxUaQeIaxs5g8ptbKoxiLJRf7HlxKhDbPXeDqtLL+c4odIQy65vDDjAcvHvcYojQjow6W5GZGJp7XPUglDJgFrcZz2Z3cyzXULGiqxPOiGlISmcxHqENx5Qenkt2HdzEUokb5YMh9XZ83v4l5JmmtXpnO2rSiKjcMprf7TzS66RrOvUyTk4pw52Ox92Tt65SJy681Pw5FEI7F289/5IID3h5Udn4Cswmcq2ZY1cwLGwqAAwNchq+MJU2nKC58rEIb/Y5Wwp76eCkbI/t1LoZWNRhjJT+JrE9jehNit/LK7RUYkDc+8ET+WhDQRrjoSjJbZpj7YB49uXAGYPLwDYwfOwxg1TausUEjJHndv4Bswco5eiqqihnl2hrpnEIESe0lOG7FcyFepy7oNus+/gzYTPlDjwhhsALsS1rJFhc8LGW/X3Nt5eiYRSsErTHlQstsrAnqppB7Y5Y5HHkDy6Hei9HQTrzggf9n3D9Bl9vnCYLxzewguHOTdPY5lz83/Kzfvwvs/J+V/cBcyXAfNlwLt6GfDQQ29gms++79fZ9+GH3vlXhTdW/l/9WYHm3xXe9HeF8YtT/Z7enJ68M53PPqexzGef+ewzxPpaZ59rXVQPOf98OMvyO7gujywoNx/SivLNn5/9Db2pCOg=
|
703,884
|
Find n-th term of series 1, 3, 6, 10, 15, 21
|
Given a number N, find the N**th term in the series 1, 3, 6, 10, 15, 21…
Examples:
Input:
N =
4
Output:
10
Explanation:
The 4
**th
term of the Series is 10.
Input:
N =
3
Output:
6
Explanation:
The 3
**rd
term of the Series is 6.
Constraints:
1 <= N <= 10**4
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int findNthTerm(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 Solution ob = new Solution();\n System.out.println(ob.findNthTerm(N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n static int findNthTerm(int N) {\n int ans = (N * (N + 1)) / 2; // Formula to get nth term of the Series.\n return ans;\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution {\n static int findNthTerm(int N) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"findNthTerm(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.findNthTerm(N))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def findNthTerm(self, N):\n ans = (N*(N+1))//2 # Formula to get nth term of the Series\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def findNthTerm(self, N):\n # code here "
}
|
eJzlVD1PwzAQZWBlYmOKMlfIZ/scl1+CRBADZGAJHVoJCYH4EfB/OV/s0JIvh6QRElF7ypPj8917z/d++nlxdsLP9Tm93Lykj+Vmt02vkhTyEtJVkhbPm+J+WzzcPe2230tveZm+rpIf3wt6OvYgLbl/21ZJW/t3Vyf25VDVcl6u6RlIJlHQr0qj6fM6Z98BmoukUlVMqYqjGcwKwmcLhVOwHDOOhiNy1BwVR8kROEZRftAnAUsAAsgIqAAMARMAooB6jyaAASgisU7gGLUBAAplejXKmP1ojaQFaWnPIJu4pxGxhdES+R59d01nO206kh0Q2+IZqVwlJnOqgqNcK9l1sTIDLLYrxYCUxnqGQYM1WIG1UllYGOmmRX00zToE6FDdKgj6eTHD1Yn0CmLTe91MxKgijiwLLcFaLCzMfqeNeXm01rXxV6Z18rpDNJMzgZvfGDDSf7kfL8f3YT2NZpcpjLfxidvzxY/JVkKCIeKm8cShOXGYS8ogxpYrJtT759td1J35RDqG3N1sYHm7z0Qo/EdGbz8uvwCHPMpF
|
705,230
|
Count Sorted Rows
|
Given two integers N and M and a matrix of dimensions N*M.Count all the rows in a matrix that are sorted either in strictly increasing order or in strictly decreasing order.
Examples:
Input:
N=3,M=3
Mat=[[1,2,3],[6,5,4],[7,9,8]]
Output:
2
Explanation:
The first row is sorted in strictly
increasing order while the second row
is sorted in strictly decreasing order.
Input:
N=3,M=3
Mat=[[1,2,3],[4,5,6],[7,8,9]]
Output:
3
Explanation:
All the rows are sorted in strictly
increasing order.
Constraints:
1<=N,M,Mat[i][j]<=1000
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int sortedCount(int N, int M, int Mat[][])"
],
"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 M = Integer.parseInt(S[1]);\n int Mat[][] = new int[N][M];\n for (int i = 0; i < N; i++) {\n String S1[] = read.readLine().split(\" \");\n for (int j = 0; j < M; j++) {\n Mat[i][j] = Integer.parseInt(S1[j]);\n }\n }\n Solution ob = new Solution();\n System.out.println(ob.sortedCount(N, M, Mat));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n int sortedCount(int N, int M, int Mat[][]) {\n int result = 0; // Initialize result\n // Start from left side of matrix to\n // count increasing order rows\n for (int i = 0; i < N; i++) {\n // Check if there is any pair ofs element\n // that are not in increasing order.\n int j;\n for (j = 0; j < M - 1; j++) if (Mat[i][j + 1] <= Mat[i][j]) break;\n // If the loop didn't break (All elements\n // of current row were in increasing order)\n if (j == M - 1) result++;\n }\n // Start from right side of matrix to\n // count increasing order rows ( refrence\n // to left these are in decreasing order )\n for (int i = 0; i < N; i++) {\n // Check if there is any pair ofs element\n // that are not in decreasing order.\n int j;\n for (j = M - 1; j > 0; j--) if (Mat[i][j - 1] <= Mat[i][j]) break;\n // If the loop didn't break (All elements\n // of current row were in decreasing order)\n if (M > 1 && j == 0) result++;\n }\n return result;\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n int sortedCount(int N, int M, int Mat[][]) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"sortedCount(self,N,M,Mat)"
],
"initial_code": "# Initial Template for Python 3\n\nimport math\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N, M = map(int, input().strip().split(\" \"))\n Mat = []\n for i in range(N):\n Mat.append(list(map(int, input().strip().split(\" \"))))\n ob = Solution()\n ans = ob.sortedCount(N, M, Mat)\n print(ans)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def sortedCount(self, N, M, Mat):\n result = 0 # Initialize result\n\n # Start from left side of matrix to\n # count increasing order rows\n for i in range(N):\n # Check if there is any pair of elements\n # that are not in increasing order.\n j = 0\n while (j < M - 1):\n if Mat[i][j + 1] <= Mat[i][j]:\n break\n j += 1\n # If the loop didn't break (All elements\n # of current row were in increasing order)\n if j == M - 1:\n result += 1\n\n # Start from right side of matrix to\n # count increasing order rows (reference\n # to left these are in decreasing order)\n for i in range(N):\n # Check if there is any pair of elements\n # that are not in decreasing order.\n j = M - 1\n while (j > 0):\n if Mat[i][j - 1] <= Mat[i][j]:\n break\n j -= 1\n # If the loop didn't break (All elements\n # of current row were in decreasing order)\n if M > 1 and j == 0:\n result += 1\n\n return result\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def sortedCount(self,N,M,Mat):\n #code here\n "
}
|
eJztV8tuUzEUZMEvsD/KukLXb5sPQUikYgFdsAksWgkJgfgI+F9mJs6ridUATYqgrdza947Pc86x77enPy6fPdHPq5eYvP48e7/4eHM9e2EzN18kS/OFM2/BIqcJ/wKWeOUma1atWCYiWMK0zRf9maXZhc2uPn28ent99e7Nh5vrLhRCvs4Xsy8XtqspU07G1gqxkO2oAoqcrRRtGSKdyVw0F2yFonUbAfOFhxDMqrliLpsbWZQHFkWLFElbkvkuUGv44GFGtjpfVPyL5gey40B2sdBD1b2iOrnVoys31hC67X7RfK8gwFqYHSaLMHuyPFmZrCKi8GXSe82rnmdhovB0dhqo9AOVDNW0k6atdGz4YtsscspfUC6T8lSUs7YO+U4Ot3OO11DlzUMWUoAkZfPFfDXf4AJiOXHGddG7JFzQHuwOoC0sDRZgTrKQLSAv1UJDDJCQiTOui94l4YL2kB7OIlgAR0EUeAQaFIvVYkMQQZyJM66L3iXhgvaMUskwHQxsXTLtVuxuRXmr9paYvUwclCEei+VewWVpZc3IIOv8XiIrkwD/M98irCkPPKkjhkCm7Dr4u+fSshEsGYJdm1q/TaWtFiRAEFWKaIQgYDPT7kSmoneBuIYNibV1MBDkHQhItqCOSR2vslAU9gMUMGl6mLTTiW2FxUTWsLazZpP4GGVPFdpjY142gSoJWYojuUu6ZRYl+YO4klJRRapUMA1RZmXurLtNi5yn/iQBieWdEN1RYbOmDucNItNdQVaBwTMwkWVXtP6zsKts67qYq9Z3JWLArm2O0YnuwtL+oJ7hWOssbLAQbZelG7hmB3DqJWHlixxZuuGZt2OcQL7gh7fjXDkmj5YTG3dBbopmWU+TEFHooJ1eUtbHF9u+n9jo2e/Z9tn9eQjwLOCRoPOB1cc/hDpiHcEu6eRI63VYY9xqX+uCShecuqLQFffDB0HFCBgRI2FkjIJRMdrEWucfIh2hjlhHMPSLmOt1WGPcal/rgkoXnLqi0BUDOKqE0cmdevjgYmsY6FINBdFQ3q0lTCJGwEBNN8eHQFYgK5AVyEpkBbICWYGsQFYieSwXIAuQBcgy6q6jO9SJz1+Y/88fwe08od27n/7PsR2UVD1rTY3q/eivALXS4YdA+J3PHrSrk375PFAfORXRkdy/nuv3dAGOjzfgE92AR59gjzfgM9+A3eMV+IGvwKMz657Oa0o4zZk9MBCn6cbEc9wpVgG8/P78J4i2lwI=
|
712,033
|
Pattern 16
|
Geek is very fond of patterns. Once, his teacher gave him a pattern to solve. He gave Geekan integer n and asked him to build a pattern.
Examples:
Input:
5
Output:
A
BB
CCC
DDDD
EEEEE
Constraints:
1<= N <= 20
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1662630518,
"func_sign": [
"void printTriangle(int n)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass Main {\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 int n = Integer.parseInt(br.readLine().trim());\n Solution obj = new Solution();\n obj.printTriangle(n);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1730481444,
"user_code": "class Solution {\n\n void printTriangle(int n) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1663316374,
"func_sign": [
"printTriangle(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().strip())\n ob = Solution()\n ob.printTriangle(N)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n\n # Function to print a triangle of characters.\n def printTriangle(self, N):\n # Iterating over the range of characters from 65 to 65+N.\n for i in range(65, 65 + N):\n # Iterating over the range of characters from 65 to i+1.\n for j in range(65, i + 1):\n # Printing the character in the range as per the ASCII value.\n print(chr(i), end='')\n print() # Printing a new line after each iteration.\n",
"updated_at_timestamp": 1730481444,
"user_code": "#User function Template for python3\n\nclass Solution:\n def printTriangle(self, N):\n # Code here"
}
|
eJzt3Nly22aXheE+6JO+C5eOXV0AZ+YsVuZ5jhNvxyEBMHGGbSWREieOXX0HfdIX3BQXbYsWKQLgAHzAu+rXk0lOkdhrb0muv/I//3n3f8/+6z/uPTl56GcX5yev3Trpmsfz/0Xmnejk9q2T7PFZlpxn6YNHF+fLT3nd/Jn53Dt3zE9PT83fmMf8zcuYv7WI+duK+TvLmL/7PObvvci+/23vv4z5B1di/uHVmH+0EvOPV2P+ySsx//TVmH92LeafX4/5F2uyePMnT2/fujKCzvz59837mx9/DR/VTTO8/hZ75sP5u7ws23jetJ3faVUNaklzX77N66O8vBa7D3CXZ3P9Nc23Z16t0fyVDeYf8c237MUrLDnMgDpwwJca0FM4xg3P27m2P6f+5XPSV4H4cl8vvyoMeG7Xn1sb3nzz3mbY7yigV3/9snT1XXTcu/w+M6iLUpfHXuE31Wt+IoqO8hNR4R9jFl+9nn+n2QuqZ3zlavhJr8tLXbs4V3+jqeDvBeh98XtQe9vSL9fF/Ku1Mf96fczvboj5N5ti/u3GmN/bHHMrG79/U8y/uzHmD26O+fdbYj7ZFvPp1pgn22Oe5oh5lifms1wx/yFfzH/MGfOHeWP+U+6Y/5w/5r8UiPmvRWJeLOaPisX8rGDMfysa898Lx/yP4jE/LxHzizIx/7NUzP8qF/PHJWP+d9mY/1M65k/Kx/zfHWL+dJfMv/bvlPkXoosoGs6wAhfPfhRhZWoCMVas5tDBWqhpdLFGaiY9rJ2aTB9rquYzwFqrKQ0xADWrEQajJjbGwNTcJhikmt4UA1YzTDB4NckUG6LmmWGj1FRn2EAXsx1H2Fg14RgbrubcwVaoaXexRWrmPWydmnwfW6rmP8BWqxYMEZddGCEuVSPGiCuqFxPENaodU8SNqiMJ4hbVlBQxl+pLhlhAtWaGWNhFdyYRYknVoBhxJ9WjDuIeVJu6iHtTneoh7lk1q494ENWvAeIBVcuGiAdXXRshHkk1box4VNW7CWIFqn1TxMpUBxPEilUTU8RaqD5miDVSrZwh1s5FN6cRYk1VQ2PEWquedhADUG3tIgajOttDDEw1t48YpOrvADFg1eIhYvCqyyPEhqhGjxEbpXo9QWygavcUsbGq4wliw1XTU8RWqL5niC1SrZ8hts5F95MIsaVqA2LEVqs96CDichu6iLhUO9FDxBW1GX1EXKP2Y4CIG9WWDBFxi9qVESLmUhszRsQCam8miFhYbc8UEUuqHUoQcSe1SSki7kHtU4aIe1NbNUPEPbvYrTRCxIOoDYsR8YBqzzqIeHC1bV1EPJLauR4iHlVtXh8RK1D7N0DEytQWDhGxYrWLI0SshdrIMSLWSO3lBBFrp7Zziog1VTuaIGKt1aamiBiA2tcMEYNRWztDxMBc7G4WIWKQaoNjRAxY7XEHEYNX29xFxIaone4hYqPUZvcRsYFqvweI2Fi15UNEbLja9REitkJt/BgRW6T2foKIrVPbP0XElqobkCBiq9UlSBERl/cgQ0RcqqswQ0RccXEbZhEi4hp1IWJExI3qTnQQEbeoa9FFRMylbkYPEbGAuhx9RMTC6n4MEBFLqisyRETcSd2SESLiHtRFGSMi7k3dlQki4p7VdZkiIh5E3ZgEEfGA6tKkiIgHV/cmQ0Q8kro6M0TEo3p5e+IoQkSsQF2gGBGxMnWHOoiIFatr1EVErIW6ST1ExBqpy9RHRKyduk8DRMSaqis1RESstbpVI0TEANTFGiMiBqPu1gQRMTB1vaaIiEGqG5YgIgasLlmKiBi8umcZImJD1FWbISI2Sn9mfvL09q0nJw/97OL85LVbJ33zrvnIPDbvROb9k9u3TrLHZ1lynqUPHl2cLz/vdfM7d8xPT08X/5arf/nGPOZvXsb8rUXM31bM31nm+S8r+YvffR7z917E/P2XMf/gSsw/vBrzj1Zi/vFqzD95Jeafvhrzz67F/PPrMf9iTW5+89dn0zMfzgfT02TiyyFd/h+V48Woet7JMaqbH29dZlGX11G7ToT55tc2+UWFLxvcW1R45/4G8TTaXoVQ3lFAL3X/zftyXcy/Whvzr9fH/O6GmH+zKebfboz5vc2Z/6hWNn7/pph/d2PMH9wc8++3xHyyLebTrTFPtsc8zRHzLE/MZ7li/kO+mP+YM+YP88b8p9wx/zl/zH8pEPNfi8S8WMwfFYv5WcGY/1Y05r8XjvkfxWN+XiLmF2Vi/mepmP9VLuaPS8b877Ix/6d0zJ+Uj/m/O8T86S6Zf+3fKfpv2A9nWIGLZz+KsDI1gRgrVnPoYC3UNLpYIzWTHtZOTaaPNVXzGWCt1ZSGGICa1QiDURMbY2BqbhMMUk1vigGrGSYYvJpkig1R88ywUWqqM2ygi9mOI2ysmnCMDVdz7mAr1LS72CI18x62Tk2+jy1V8x9gq1ULhojLLowQl6oRY8QV1YsJ4hrVjiniRtWRBHGLakqKmEv1JUMsoFozQyzsojuTCLGkalCMuJPqUQdxD6pNXcS9qU71EPesmtVHPIjq1wDxgKplQ8SDq66NEI+kGjdGPKrq3QSxAtW+KWJlqoMJYsWqiSliLVQfM8QaqVbOEGvnopvTCLGmqqExYq1VTzuIAai2dhGDUZ3tIQammttHDFL1d4AYsGrxEDF41eURYkNUo8eIjVK9niA2ULV7ithY1fEEseGq6SliK1TfM8QWqdbPEFvnovtJhNhStQExYqvVHnQQcbkNXURcqp3oIeKK2ow+Iq5R+zFAxI1qS4aIuEXtyggRc6mNGSNiAbU3E0QsrLZniogl1Q4liLiT2qQUEfegPzM/eXr71pOTh352cX7y2q2TnvnQPJ7/oRPN/zgy75t3zed/Eg/mH/HlP3j+SfoL7yw4uX3rJHt8liXnWfrg0cX58l/4uvmdO+anp6fmb8xj/uZlzN9axPxtZfFi8n/yO8uYv/s85u+9iPn7L2P+wZWYf3g15h+tpD6v4+PVmH/ySsw/fTXmn12L+efXY/7FmjTxzV/vePy8v+XLXuZXxM1ZkUqq+eW6mH+1NuZfr4/53Q0x/2ZTzL/dGPN7mzP/lqVs/P5NMf/uxpg/uDnm32+J+WRbzKdbY55sj3maI+ZZnpjPcsX8h3wx/zFnzB/mjflPuWP+c/6Y/1Ig5r8WiXmxmD8qFvOzgjH/rWjMfy8c8z+Kx/y8RMwvysT8z1Ix/6tczB+XjPnfZWP+T+mYPykf8393iPnTXTL/2r9T9LPzcIYVuHj2owgrUxOIsWI1hw7WQk2jizVSM+lh7dRk+lhTNZ8B1lpNaYgBqFmNMBg1sTEGpuY2wSDV9KYYsJphgsGrSabYEDXPDBulpjrDBrqY7TjCxqoJx9hwNecOtkJNu4stUjPvYevU5PvYUjX/AbZatWCIuOzCCHGpGjFGXFG9mCCuUe2YIm5UHUkQt6impIi5VF8yxAKqNTPEwi66M4kQS6oGxYg7qR51EPeg2tRF3JvqVA9xz6pZfcSDqH4NEA+oWjZEPLjq2gjxSKpxY8Sjqt5NECtQ7ZsiVqY6mCBWrJqYItZC9TFDrJFq5Qyxdi66OY0Qa6oaGiPWWvW0gxiAamsXMRjV2R5iYKq5fcQgVX8HiAGrFg8Rg1ddHiE2RDV6jNgo1esJYgNVu6eIjVUdTxAbrpqeIrZC9T1DbJFq/QyxdS66n0SILVUbECO2Wu1BBxGX29BFxKXaiR4irqjN6CPiGrUfA0TcqLZkiIhb1K6MEDGX2pgxIhZQezNBxMJqe6aIWFLtUIKIO6lNShFxD2qfMkTcm9qqGSLu2cVupREiHkR/Zv66+Z075qenp+ZvzGP+5mXM31rE/G2l4Ce/s4z5u89j/t6LmL//MuYfXIn5h1dj/tFK6vM6Pl6N+SevxPzTV2P+2bWYf3495l+sSRPf/E3v6JV/VvLNB/TMDvhSA3oK+1+bL9fF/Ku1Mf96fczvboj5N5ti/u3GmN/bnPk3QGXj92+K+Xc3xvzBzTH/fkvMJ9tiPt0a82R7zNMcMc/yxHyWK+Y/5Iv5jzlj/jBvzH/KHfOf88f8lwIx/7VIzIvF/FGxmJ8VjPlvRWP+e+GY/1E85uclYn5RJuZ/lor5X+Vi/rhkzP8uG/N/Ssf8SfmY/7tDzJ/ukvnX/p2in8SHM6zAxbMfRViZmkCMFas5dLAWahpdrJGaSQ9rpybTx5qq+Qyw1mpKQwxAzWqEwaiJjTEwNbcJBqmmN8WA1QwTDF5NMsWGqHlm2Cg11Rk20MVsxxE2Vk04xoarOXewFWraXWyRmnkPW6cm38eWqvkPsNWqBUPEZRdGiEvViDHiiurFBHGNascUcaPqSIK4RTUlRcyl+pIhFlCtmSEWdtGdSYRYUjUoRtxJ9aiDuAfVpi7i3lSneoh7Vs3qIx5E9WuAeEDVsiHiwVXXRohHUo0bIx5V9W6CWIFq3xSxMtXBBLFi1cQUsRaqjxlijVQrZ4i1c9HNaYRYU9XQGLHWqqcdxABUW7uIwajO9hADU83tIwap+jtADFi1eIgYvOryCLEhqtFjxEapXk8QG6jaPUVsrOp4gthw1fQUsRWq7xlii1TrZ4itc9H9JEJsqdqAGLHVag86iLjchi4iLtVO9BBxRW1GHxHXqP0YIOJGtSVDRNyidmWEiLnUxowRsYDamwkiFlbbM0XEkmqHEkTcSW1Sioh7UPuUIeLe1FbNEHHPLnYrjRDxIGrDYkQ8oNqzDiIeXG1bFxGPpHauh4hHVZvXR8QK1P4NELEytYVDRKxY7eIIEWuhNnKMiDVSezlBxNqp7ZwiYk3VjiaIWGu1qSkiBqD2NUPEYNTWzhAxMBe7m0WIGKTa4BgRA1Z73EHE4NU2dxGxIWqne4jYKLXZfURsoNrvASI2Vm35EBEbrnZ9hIitUBs/RsQWqb2fIGLr1PZPEbGl6gYkiNhqdQlSRMTlPcgQEZfqKswQEVdc3IZZhIi4Rl2IGBFxo7oTHUTELepadBERc6mb0UNELKAuRx8RsbC6HwNExJLqigwREXdSt2SEiLgHdVHGiIh7U3dlgoi4Z3VdpoiIB1E3JkFEPKC6NCki4sHVvckQEY+krs4MEfGoXt6eOIoQEStQFyhGRKxM3aEOImLF6hp1ERFroW5SDxGxRuoy9RERa6fu0wARsabqSg0REWutbtUIETEAdbHGiIjBqLs1QUQMTF2vKSJikOqGJYiIAevPzF83v3PH/PT01PyNeczfvIz5W4uYv60U/OR3ljF/93nM33sR8/dfxvyDKzH/8GrMP1qJ+cerMf/klZh/+mrMP7sW88+vx/yLNTH/cl3Mv1ob86/Xx/zuhph/synm326M+b3NmX+lKhu/f1PMv7sx5g9ujvn3W2I+2Rbz6daYJ9tjnuaIeZYn5rNcMf8hX8x/zBnzh3lj/lPumP+cP+a/FIj5r0ViXizmj4rF/KxgzH8rGvPfC8f8j+IxPy8R84syMf+zVMz/KhfzxyVj/nfZmP9TOuZPysf83x1i/nSXzL/27xT9J5WGM6zAxbMfRViZmkCMFas5dLAWahpdrJGaSQ9rpybTx5qq+Qyw1mpKQwxAzWqEwaiJjTEwNbcJBqmmN8WA1QwTDF5NMsWGqHlm2Cg11Rk20MVsxxE2Vk04xoarOXewFWraXWyRmnkPW6cm38eWqvkPsNWqBUPEZRdGiEvViDHiiurFBHGNascUcaPqSIK4RTUlRcyl+pIhFlCtmSEWdtGdSYRYUjUoRtxJ9aiDuAfVpi7i3lSneoh7Vs3qIx5E9WuAeEDVsiHiwVXXRohHUo0bIx5V9W6CWIFq3xSxMtXBBLFi1cQUsRaqjxlijVQrZ4i1c9HNaYRYU9XQGLHWqqcdxABUW7uIwajO9hADU83tIwap+jtADFi1eIgYvOryCLEhqtFjxEapXk8QG6jaPUVsrOp4gthw1fQUsRWq7xlii1TrZ4itc9H9JEJsqdqAGLHVag86iLjchi4iLtVO9BBxRW1GHxHXqP0YIOJGtSVDRNyidmWEiLnUxowRsYDamwkiFlbbM0XEkmqHEkTcSW1Sioh70J+Znzy9fevJyUM/uzg/ee3WSd+8E5nH43j5J6P5x3D+MTi5feske3yWJedZ+uDRxfnyF7xufueO+enpqfkb85i/eRnztxYxf1sxf2cZ83efx/y9FzF//2XMP7gS8w+vxvyjlZh/vBrzT16J+aevxvyzazH//HrMv1iTxcNr75v/cl3Mv1ob86/Xx/zuhph/synm326M+b3NmX/9KBu/f1PMv7sx5g9ujvn3W2I+2Rbz6daYJ9tjnuaIeZYn5rNcMf8hX8x/zBnzh3lj/lPumP+cP+a/FIj5r0ViXizmj4rF/KxgzH8rGvPfC8f8j+IxPy8R84syMf+zVMz/KhfzxyVj/nfZmP9TOuZPysf83x1i/nSXzL/27xT9IDOcYQUunv0owsrUBGKsWM2hg7VQ0+hijdRMelg7NZk+1lTNZ4C1VlMaYgBqViMMRk1sjIGpuU0wSDW9KQasZphg8GqSKTZEzTPDRqmpzrCBLmY7jrCxasIxNlzNuYOtUNPuYovUzHvYOjX5PrZUzX+ArVYtGCIuuzBCXKpGjBFXVC8miGtUO6aIG1VHEsQtqikpYi7VlwyxgGrNDLGwi+5MIsSSqkEx4k6qRx3EPag2dRH3pjrVQ9yzalYf8SCqXwPEA6qWDREPrro2QjySatwY8aiqdxPEClT7poiVqQ4miBWrJqaItVB9zBBrpFo5Q6ydi25OI8SaqobGiLVWPe0gBqDa2kUMRnW2hxiYam4fMUjV3wFiwKrFQ8TgVZdHiA1RjR4jNkr1eoLYQNXuKWJjVccTxIarpqeIrVB9zxBbpFo/Q2ydi+4nEWJL1QbEiK1We9BBxOU2dBFxqXaih4grajP6iLhG7ccAETeqLRki4ha1KyNEzKU2ZoyIBdTeTBCxsNqeKSKWVDuUIOJOapNSRNyD2qcMEfemtmqGiHt2sVtphIgHURsWI+IB1Z51EPHgatu6iHgktXM9RDyq2rw+Ilag9m+AiJWpLRwiYsVqF0eIWAu1kWNErJHaywki1k5t5xQRa6p2NEHEWqtNTRExALWvGSIGo7Z2hoiBudjdLELEINUGx4gYsNrjDiIGr7a5i4gNUTvdQ8RGqc3uI2ID1X4PELGxasuHiNhwtesjRGyF2vgxIrZI7f0EEVuntn+KiC1VNyBBxFarS5AiIi7vQYaIuFRXYYaIuOLiNswiRMQ16kLEiIgb1Z3oICJuUdeii4iYS92MHiJiAXU5+oiIhdX9GCAillRXZIiIuJO6JSNExD2oizJGRNybuisTRMQ9q+syRUQ8iLoxCSLiAdWlSRERD67uTYaIeCR1dWaIiEfVn5m/bn7njvnp6an5G/OYv3kZ87cWMX9bMX9nGfN3n8f8vRcxf/9lzD+4EvMPr8b8o5WYf7wa809eifmnr8b8s2sx//x6zL9Ykya++bDf0fzVnzy9fevJyUM/uzg/ee3WSd+8E5nH4/nHaP4xNJ//ra755V8M5h/x5SfEg5Pbt06yx2dZcp6lDx5dnC9/ecDPgmrnefPNe5thv6ObXv317e6Zzxc67i2XfL7TnTh6sdU97+y81nV5mnV5HdyifS3pK1VWY6/1ec91DuLhFGjGl+ti/tXamH+9PuZ3N8T8m00x/3ZjzO9tzvzn9bLx+zfF/LsbY/7g5ph/vyXmk20xn26NebI95mmOmGd5Yj7LFfMf8sX8x5wxf5g35j/ljvnP+WP+S4GY/1ok5sVi/qhYzM8Kxvy3ojH/vXDM/yge8/MSMb8oE/M/S8X8r3Ixf1wy5n+Xjfk/pWP+pHzM/90h5k93yfzbiJ2i3zgezrACF89+FGFlagIxVqzm0MFaqGl0sUZqJj2snZpMH2uq5jPAWqspDTEANasRBqMmNsbA1NwmGKSa3hQDVjNMMHg1yRQbouaZYaPUVGfYQBezHUfYWDXhGBuu5tzBVqhpd7FFauY9bJ2afB9bquY/wFarFgwRl10YIS5VI8aIK6oXE8Q1qh1TxI2qIwniFtWUFDGX6kuGWEC1ZoZY2EV3JhFiSdWgGHEn1aMO4h5Um7qIe1Od6iHuWTWrj3gQ1a8B4gFVy4aIB1ddGyEeSTVujHhU1bsJYgWqfVPEylQHE8SKVRNTxFqoPmaINVKtnCHWzkU3pxFiTVVDY8Raq552EANQbe0iBqM620MMTDW3jxik6u8AMWDV4iFi8KrLI8SGqEaPERulej1BbKBq9xSxsarjCWLDVdNTxFaovmeILVKtnyG2zkX3kwixpWoDYsRWqz3oIOJyG7qIuFQ70UPEFbUZfURco/ZjgIgb1ZYMEXGL2pURIuZSGzNGxAJqbyaIWFhtzxQRS6odShBxJ7VJKSLuQe1Thoh7U1s1Q8Q9u9itNELEg6gNixHxgGrPOoh4cLVtXUQ8ktq5HiIeVW1eHxErUPs3QMTK1BYOEbFitYsjRKyF2sgxItZI7eUEEWuntnOKiDVVO5ogYq3VpqaIGIDa1wwRg1FbO0PEwFzsbhYhYpBqg2NEDFjtcQcRg1fb3EXEhqid7iFio9Rm9xGxgWq/B4jYWLXlQ0RsuNr1ESK2Qm38GBFbpPZ+goitU9s/RcSWqhuQIGKr1SVIERGX9yBDRFyqqzBDRFxxcRtmESLiGnUhYkTEjepOdBARt6hr0UVEzKVuRg8RsYC6HH1ExMLqfgwQEUuqKzJERNxJ3ZIRIuIe1EUZIyLuTd2VCSLintV1mSIiHkTdmAQR8YDq0qSIiAdX9yZDRDySujozRMSjenl74ihCRKxAXaAYEbEydYc6iIgVq2vURUSshbpJPUTEGqnL1EdErJ26TwNExJqqKzVERKy1ulUjRMQA1MUaIyIGo+7WBBExMHW9poiIQaobliAiBqw/Mz95ev///vv/AUvbl2o=
|
703,514
|
Print N-bit binary numbers having more 1s than 0s
|
Given a positive integer n. Your task is to generate a string list of all n-bit binary numbers where, for any prefix of the number, there are more or an equal number of 1's than 0's. The numbers should be sorted in decreasing order of magnitude.
Examples:
Input:
n = 2
Output:
{"11", "10"}
Explanation:
Valid numbers are those where each prefix has more 1s than 0s:
11: all its prefixes (1 and 11) have more 1s than 0s.
10: all its prefixes (1 and 10) have more 1s than 0s.
So, the output is "11, 10".
Input:
n = 3
Output:
{"111", "110", "101"}
Explanation:
Valid numbers are those where each prefix has more 1s than 0s.
111: all its prefixes (1, 11, and 111) have more 1s than 0s.
110: all its prefixes (1, 11, and 110) have more 1s than 0s.
101: all its prefixes (1, 10, and 101) have more 1s than 0s.
So, the output is "111, 110, 101".
Constraints:
1 <= n <= 15
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"ArrayList<String> NBitBinary(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 Solution ob = new Solution();\n ArrayList<String> result = ob.NBitBinary(n);\n for(String value : result){\n System.out.print(value + \" \");\n }\n System.out.println();\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n void NBitBinaryUtil(String number, int extraOnes, int remainingPlaces, ArrayList<String> ans) {\n // Base case: If all places have been filled, add the number to the answer list and return\n if (remainingPlaces == 0) {\n ans.add(number);\n return;\n }\n\n // Recursive call to add a '1' to the current number and update the count of extra ones and remaining places\n NBitBinaryUtil(number + \"1\", extraOnes + 1, remainingPlaces - 1, ans);\n\n // Check if there are any extra ones that can be used to add a '0'\n if (extraOnes > 0) {\n NBitBinaryUtil(number + \"0\", extraOnes - 1, remainingPlaces - 1, ans);\n }\n }\n\n ArrayList<String> NBitBinary(int n) {\n ArrayList<String> ans = new ArrayList<>();\n String s = \"\";\n\n // Call the utility function to recursively generate the N-bit binary numbers\n NBitBinaryUtil(s, 0, n, ans);\n\n return ans;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution {\n ArrayList<String> NBitBinary(int N) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"NBitBinary(self, n)"
],
"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 ob = Solution()\n answer = ob.NBitBinary(n)\n for value in answer:\n print(value, end=\" \")\n print()\n print(\"~\")\n",
"solution": "class Solution:\n def NBitBinaryUtil(self, number, extraOnes, remainingPlaces, ans):\n # Base case: If all places have been filled, add the number to the answer list and return\n if remainingPlaces == 0:\n ans.append(number)\n return\n\n # Recursive call to add a '1' to the current number and update the count of extra ones and remaining places\n self.NBitBinaryUtil(number + \"1\", extraOnes +\n 1, remainingPlaces - 1, ans)\n\n # Check if there are any extra ones that can be used to add a '0'\n if extraOnes > 0:\n self.NBitBinaryUtil(number + \"0\", extraOnes -\n 1, remainingPlaces - 1, ans)\n\n def NBitBinary(self, n):\n ans = []\n s = \"\"\n\n # Call the utility function to recursively generate the N-bit binary numbers\n self.NBitBinaryUtil(s, 0, n, ans)\n return ans\n",
"updated_at_timestamp": 1731580376,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef NBitBinary(self, n):\n\t\t# code here"
}
|
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
|
705,309
|
Check if given four points form a square
|
Given coordinates of four points in a plane. Find if the four points form a square or not.
Examples:
Input:
points=(0,0),(0,1),(1,0),(1,1)
Output:
1
Explanation:
These points form a square.
Input:
points=(0,0),(1,1),(1,0),(0,2)
Output:
0
Explanation:
These four points do not form a square.
Constraints:
0<=X-cordinate,Y-cordinate<=10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int fourPointSquare(int points[][])"
],
"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 points[][] = new int[4][2];\n for (int i = 0; i < 4; i++) {\n String S1[] = read.readLine().split(\" \");\n for (int j = 0; j < 2; j++) {\n points[i][j] = Integer.parseInt(S1[j]);\n }\n }\n Solution ob = new Solution();\n int ans = ob.fourPointSquare(points);\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 // Function to calculate the distance between two points\n int distance(int a, int b, int p, int q) {\n return (p - a) * (p - a) + (q - b) * (q - b);\n }\n\n // Function to check if the given points form a square\n int fourPointSquare(int points[][]) {\n // Checking if any two points are the same\n for (int i = 0; i < 4; i++)\n for (int j = i + 1; j < 4; j++)\n if (points[i][0] == points[j][0] && points[i][1] == points[j][1]) return 0;\n // Calculating the distances between the points\n int d2 = distance(points[0][0], points[0][1], points[1][0], points[1][1]);\n int d3 = distance(points[0][0], points[0][1], points[2][0], points[2][1]);\n int d4 = distance(points[0][0], points[0][1], points[3][0], points[3][1]);\n // Checking if the distances satisfy the properties of a square\n if (d2 == d3 && 2 * d2 == d4) {\n int d = distance(points[1][0], points[1][1], points[3][0], points[3][1]);\n return ((d == distance(points[2][0], points[2][1], points[3][0], points[3][1]) && d == d2)\n ? 1\n : 0);\n }\n if (d3 == d4 && 2 * d3 == d2) {\n int d = distance(points[1][0], points[1][1], points[2][0], points[2][1]);\n return ((d == distance(points[1][0], points[1][1], points[3][0], points[3][1]) && d == d3)\n ? 1\n : 0);\n }\n if (d2 == d4 && 2 * d2 == d3) {\n int d = distance(points[1][0], points[1][1], points[2][0], points[2][1]);\n return ((d == distance(points[2][0], points[2][1], points[3][0], points[3][1]) && d == d2)\n ? 1\n : 0);\n }\n return 0;\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n int fourPointSquare(int points[][]) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"fourPointSquare(self, points)"
],
"initial_code": "import math\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n points = []\n for i in range(4):\n points.append(list(map(int, input().strip().split(\" \"))))\n ob = Solution()\n ans = ob.fourPointSquare(points)\n print(ans)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to calculate the squared distance between two points\n def distance(self, a, b, p, q):\n return (p-a)*(p-a)+(q-b)*(q-b)\n\n # Function to check if the given points form a square\n def fourPointSquare(self, points):\n # Checking for any duplicate points\n for i in range(4):\n for j in range(i+1, 4):\n if (points[i][0] == points[j][0] and points[i][1] == points[j][1]):\n return 0\n\n # Calculating the squared distances between the points\n d2 = self.distance(points[0][0], points[0][1],\n points[1][0], points[1][1])\n d3 = self.distance(points[0][0], points[0][1],\n points[2][0], points[2][1])\n d4 = self.distance(points[0][0], points[0][1],\n points[3][0], points[3][1])\n\n # Checking for the conditions of a square\n if (d2 == d3 and 2*d2 == d4):\n d = self.distance(points[1][0], points[1]\n [1], points[3][0], points[3][1])\n if (d == self.distance(points[2][0], points[2][1], points[3][0], points[3][1]) and d == d2):\n return 1\n else:\n return 0\n\n # The below two cases are similar to the above case\n if (d3 == d4 and 2*d3 == d2):\n d = self.distance(points[1][0], points[1]\n [1], points[2][0], points[2][1])\n if (d == self.distance(points[1][0], points[1][1], points[3][0], points[3][1]) and d == d3):\n return 1\n else:\n return 0\n if (d2 == d4 and 2*d2 == d3):\n d = self.distance(points[1][0], points[1]\n [1], points[2][0], points[2][1])\n if (d == self.distance(points[2][0], points[2][1], points[3][0], points[3][1]) and d == d2):\n return 1\n else:\n return 0\n\n return 0\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def fourPointSquare(self, points): \n #code here"
}
|
eJytVM1OBCEM9mB8jobzxgDOHz6JiRgPOgcvuIfZZBOj8SH0Eb35ENJ2WTCRcarDgfbLF76WUvp6+v55dkLr6iM610/qIWx3k7oEZXzQoH0wOq7s0I4UOWoDatxvx7tpvL993E357IsP6nkDPwhqcHH5gDtisrgJxQxn44MtHas5VXSkgvaiaaHrB6czcAyakmkSIwzQUgVbriAaUwJmTMkYYYCeZAbWzODAmJJhIA2g04O57Dh+Tn5W6SNavCbQzsCUgBlTMtKMDfYGtkYylvojGqFQbIeuB2yBb8AyGEqGgV09gI5Ud4T1CPo/V2iW3GGNCO3fQkh/KUj0U1NXzlQ+xNyIXPPb10oyP1b72m3m5Wg8HDUprWXzeq6wB7O4vDTDfplosGykpbRu3s6/AMSz6Bk=
|
706,062
|
Coins of Geekland
|
In Geekland there is a gridof coins of size N x N. You have to find the maximum sum of coins in anysub-gridof size K x K.Note: Coins of the negative denomination arealso possible at Geekland.Example 1:
Examples:
Input:
N = 5, K = 3
mat[[]] = {1, 1, 1, 1, 1}
{2, 2, 2, 2, 2}
{3, 8, 6, 7, 3}
{4, 4, 4, 4, 4}
{5, 5, 5, 5, 5}
Output:
48
Explanation:
{8, 6, 7}
{4, 4, 4}
{5, 5, 5}
has the maximum sum
Input:
N = 1, K = 1
mat[[]] = {{4}}
Output:
4
Constraints:
1 ≤ K≤ N ≤ 10**3
-5*10**5≤ mat[i][j] ≤ 5*10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1619174400,
"func_sign": [
"public int Maximum_Sum(int mat[][],int N,int K)"
],
"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\tpublic static void main (String[] args) {\n\t\t\n\t\tScanner sc = new Scanner(System.in);\n\t\tint t = Integer.parseInt(sc.next());\n\t\twhile(t-- > 0)\n\t\t{\n\t\t int n = Integer.parseInt(sc.next());\n\t\t int a[][] = new int[n][n];\n\t\t \n\t\t for(int i=0;i<n;i++)\n\t\t {\n\t\t for(int j=0;j<n;j++)\n\t\t {\n\t\t a[i][j] = Integer.parseInt(sc.next());\n\t\t }\n\t\t }\n\t\t \n\t\t int k = Integer.parseInt(sc.next());\n\t\t Solution T = new Solution();\n\t\t System.out.println(T.Maximum_Sum(a,n,k));\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n}",
"script_name": "GFG",
"solution": "class Solution {\n public int Maximum_Sum(int mat[][], int N, int K) {\n // Initialize an array to store the sum of each strip\n int stripSum[][] = new int[N][N];\n int sum = 0;\n // Calculate the sum of each strip in the matrix\n for (int j = 0; j < N; j++) {\n sum = 0;\n // Calculate the sum of the first K elements in each column\n for (int i = 0; i < K; i++) sum += mat[i][j];\n // Store the sum in the stripSum array\n stripSum[0][j] = sum;\n // Calculate the sum of the remaining elements in each column\n for (int i = 1; i < N - K + 1; i++) {\n sum += (mat[i + K - 1][j] - mat[i - 1][j]);\n stripSum[i][j] = sum;\n }\n }\n // Find the maximum sum among all possible submatrices\n int max_sum = Integer.MIN_VALUE;\n for (int i = 0; i < N - K + 1; i++) {\n sum = 0;\n // Calculate the sum of the first K columns in each row\n for (int j = 0; j < K; j++) {\n sum += stripSum[i][j];\n }\n // Update the maximum sum if necessary\n if (sum > max_sum) {\n max_sum = sum;\n }\n // Calculate the sum of the remaining columns in each row\n for (int j = 1; j < N - K + 1; j++) {\n sum += (stripSum[i][j + K - 1] - stripSum[i][j - 1]);\n // Update the maximum sum if necessary\n if (sum > max_sum) {\n max_sum = sum;\n }\n }\n }\n // Return the maximum sum\n return max_sum;\n }\n}\n",
"updated_at_timestamp": 1730987924,
"user_code": "class Solution\n{\n public int Maximum_Sum(int mat[][],int N,int K){\n // Your code goes here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1619174400,
"func_sign": [
"Maximum_Sum(self, mat, N, K)"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n n = int(input())\n matrix = []\n for _ in range(n):\n matrix.append([int(x) for x in input().strip().split()])\n k = int(input())\n obj = Solution()\n print(obj.Maximum_Sum(matrix, n, k))\n print(\"~\")\n",
"solution": "class Solution:\n def Maximum_Sum(self, mat, N, K):\n stripSum = [[0]*N for i in range(N)]\n\n for j in range(N):\n sum = 0\n for i in range(K):\n sum += mat[i][j]\n stripSum[0][j] = sum\n\n for i in range(1, N-K+1):\n sum += (mat[i+K-1][j] - mat[i-1][j])\n stripSum[i][j] = sum\n\n max_sum = -10**9\n\n for i in range(N-K+1):\n sum = 0\n for j in range(K):\n sum += stripSum[i][j]\n if (sum > max_sum):\n max_sum = sum\n\n for j in range(1, N-K+1):\n sum += (stripSum[i][j+K-1] - stripSum[i][j-1])\n\n if (sum > max_sum):\n max_sum = sum\n return max_sum\n",
"updated_at_timestamp": 1730987924,
"user_code": "#User function Template for python3\n\nclass Solution:\n def Maximum_Sum(self, mat, N, K):\n # Your code goes here"
}
|
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
|
705,139
|
Minimum Value Assigned
|
Given an array, arr[], Geek wants to assign a value to each array element. The minimum value that can be assigned to an element is 1. For every pair of adjacent elements, the one with the higher integral value should be assigned a higher value. Help Geek assign the smallest possible value to each element and return the sum of the values which is the minimum possible.
Examples:
Input:
arr[] = [1, 2, 3, 4]
Output:
10
Explanation:
The first element is assigned value 1. The second element is assigned value 2 because arr[1]>arr[0]. The third element is assigned value 3 because arr[2]>arr[1]. Fourth element is assigned value 4 because arr[3]>arr[2]. 1+2+3+4 =10.
Input:
arr[] = [2, 4, 4]
Output:
4
Explanation:
First element is assigned value 1. Second element is assigned value 2 because arr[1]>arr[0]. Third element is assigned value 1 because arr[2] is equal to arr[1]. 1+2+1 = 4.
Constraints:
1 ≤ arr.size ≤ 10**6
1 ≤ arr[i] ≤ 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int minValue(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.minValue(arr));\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1727947200,
"user_code": "// User function Template for Java\n\nclass Solution {\n static int minValue(int arr[]) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"minValue(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\n ob = Solution()\n print(ob.minValue(arr))\n print(\"~\")\n",
"solution": "class Solution:\n def minValue(self, arr):\n N = len(arr) # Get the size of the array\n\n # Create lists to store the length of increasing sequences from left and right sides\n left = [0] * N\n right = [0] * N\n\n # Initialize the first element of the left list as 1\n left[0] = 1\n\n # Calculate the length of increasing sequence from the left side\n for i in range(1, N):\n if arr[i] > arr[i - 1]:\n left[i] = left[i - 1] + 1\n else:\n left[i] = 1\n\n # Initialize the last element of the right list as 1\n right[N - 1] = 1\n\n # Calculate the length of increasing sequence from the right side\n for i in range(N - 2, -1, -1):\n if arr[i] > arr[i + 1]:\n right[i] = right[i + 1] + 1\n else:\n right[i] = 1\n\n # Calculate the sum of the maximum lengths from the left and right lists\n ans = 0\n for i in range(N):\n ans += max(left[i], right[i]) # Use max() to get the maximum value\n\n # Return the total minimum value\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def minValue(self, arr):\n # code here"
}
|
eJzFVMFqwzAM7WHQ3xA+l2FZcRPvSwbL2KHNYZeshxQKpWMfsX3PbvuuKWroWooc1+uYQx7GRNKz3lPebj6+phNZ95+8edia53a17swdGKxbtBCgghLm4KEAAgdoZmCazapZdM3y6WXdDV97X7evdWt2MzjNQYAcipwgcHifiMArSZxVkqDULiL1MR5KwsFpwU4Ltrxgj4EXnB0cnfZbrQCp7JiV8CPhyRfUr6i12EPSc2nT3dC5kVdJS6og9tCtffsqwVJwLugFC0ESdIIXmw8H6T0br2Qn91IlW5qJJtpC8UWoTs0RchyiyYZJjsrx8IgL1cKjdezPMZ+kGzdjrCJcIiKE6D/kf+5YZuscFTrHGL81x2Ho7VWmnlS5/kalkGfFmE7MBq83kY/vt9+83PRQ
|
703,082
|
Sum of two large numbers
|
Given two strings denoting non-negative numbers X and Y. Calculate the sum of X and Y.
Examples:
Input:
X = "25", Y = "23"
Output:
48
Explanation:
The sum of 25 and 23 is 48.
Input:
X = "2500", Y = "23"
Output:
2523
Explanation:
The sum of 2500 and 23 is 2523.
Constraints:
1 <= |X|, |Y| <= 10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1616469659,
"func_sign": [
"String findSum(String X, String Y)"
],
"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 x = read.readLine();\n String y = read.readLine();\n Solution ob = new Solution();\n String result = ob.findSum(x, y);\n\n System.out.println(result);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730273741,
"user_code": "// User function Template for Java\n\nclass Solution {\n String findSum(String X, String Y) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1616469659,
"func_sign": [
"findSum(self, X, Y)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n x = input()\n y = input()\n ob = Solution()\n answer = ob.findSum(x, y)\n print(answer)\n",
"solution": "# Backend complete function Template for python3\n\nclass Solution:\n def findSum(self, str1, str2):\n # Before proceeding further,\n # make sure length of str2 is larger.\n if (len(str1) > len(str2)):\n t = str1\n str1 = str2\n str2 = t\n\n # Take an empty string for\n # storing result\n str_result = \"\"\n\n # Calculate length of both string\n n1 = len(str1)\n n2 = len(str2)\n\n # Reverse both of strings\n str1 = str1[::-1]\n str2 = str2[::-1]\n\n carry = 0\n for i in range(n1):\n # Do school mathematics, compute\n # sum of current digits and carry\n sum_digit = ((ord(str1[i]) - 48) + (ord(str2[i]) - 48) + carry)\n str_result += chr(sum_digit % 10 + 48)\n\n # Calculate carry for next step\n carry = int(sum_digit / 10)\n\n # Add remaining digits of larger number\n for i in range(n1, n2):\n sum_digit = ((ord(str2[i]) - 48) + carry)\n str_result += chr(sum_digit % 10 + 48)\n carry = int(sum_digit / 10)\n\n # Add remaining carry\n if (carry):\n str_result += chr(carry + 48)\n\n # reverse resultant string\n str_result = str_result[::-1]\n\n i = 0\n n = len(str_result)\n while i < n and str_result[i] == '0':\n i += 1\n\n if i == n:\n return \"0\"\n\n return str_result[i:]\n",
"updated_at_timestamp": 1730273741,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef findSum(self, X, Y):\n\t\t# code here"
}
|
eJxrYJlqxMYABhHaQEZ0tVJmXkFpiZKVgpJhTJ4BGCnpKCilVhSkJpekpsTnl5ZA5UEytToKqDqAyBIEcOoyNAABbFqh+gzJ0AqTsYSpwGcAPssJuB0ka4FNuynEXFMirMem3QDhBbL9TpZefMFthNelZIUySiyjcKgR+YYxMegWIAUOciAT8oClqYkhaVbhcwN+R0B0QBAtnWxgQFFYEbAdbDqOBBaDbHge0HQcxpiaYE1yIK15uB2Nx1WGpuaEAmVQRCrevGSJPWSRCqyYGDxFFtAEYxOsZRZKICA8RyhvQ90TO0UPAEwH0Pg=
|
703,601
|
Largest number in one swap
|
Given a non-negative number N in the form of a string.Find the largest number that can be formed by swapping two characters at most once.
Examples:
Input:
N=768
Output:
867
Explanation:
Swapping the 1st and 3rd
characters(7 and 8 respectively),
gives the largest possible number.
Input:
N=333
Output:
333
Explanation:
Performing any swaps gives the
same result i.e 333.
Constraints:
1<=|N|<=10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"String LargestSwap(String 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 N = read.readLine();\n Solution ob = new Solution();\n System.out.println(ob.LargestSwap(N));\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 String LargestSwap(String S){\n //code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"LargestSwap(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\n ob = Solution()\n print(ob.LargestSwap(S))\n print(\"~\")\n",
"solution": "class Solution:\n\n # Function to find the largest possible swap in a given string.\n def LargestSwap(self, S):\n l = len(S)\n max1 = 0\n max2 = 1\n max3 = 1\n flag = 0\n\n # Iterating through the string to find the maximum digit different than 0.\n for i in range(1, l):\n if(S[i] >= S[max1] and S[i] != '0'):\n max1 = i\n if(S[i] > S[i-1] and flag == 0):\n max3 = i\n flag = 1\n\n ans = S\n\n # Checking if the maximum digit found is greater than the first digit.\n # If yes, then performing the swap operation.\n if(max1 != 0 and S[max1] > S[0]):\n ans = ''.join((S[:0], S[max1], S[1:max1], S[0], S[max1+1:]))\n else:\n max2 = l-1\n\n # Finding the maximum digit after max3 position to perform the swap operation.\n for i in range(l-2, max3, -1):\n if(S[i] > S[max2]):\n max2 = i\n\n # Performing the swap operation with the appropriate digits.\n for i in range(1, max2):\n if(S[i] < S[max2]):\n ans = ''.join(\n (S[:i], S[max2], S[i+1:max2], S[i], S[max2+1:]))\n break\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def LargestSwap(self,S):\n #code here"
}
|
eJydU0sOgjAUdMFBSNfE9JUCxZOYiHGhLNxUFpCQGI2H0EO68wi2iJ+QTlXeqgkzw3Tm9RRcbsGkm/nVHBZ7ttVVU7NZyKjQJGKZpJnKeaFZFLKyrcp1XW5Wu6buUXkPIQM5GtQhCgca/DlQ4xPi1hCYLOCfuWOgjBvs1BUkM6niVGZQTVmIeEDc3rARwMhxBTB5T+Lwbp6gkTOFrSnEQQyNbvOupbf5Q6n0tUvvRuBcCw79248oqe49wc30P7TEcAkJC/q3NGjF+hhvZChr1EZrmSQBzUTs4tjcfVuvX2u/PE/vchR9VQ==
|
703,932
|
Reverse digits
|
You are given an integer N,reverse the digits of given number N, ensuring that the reversed number has no leading zeroes. Return the resulting reversed number.
Examples:
Input:
200
Output:
2
Explanation:
By reversing the digits of
number, number will change into 2.
Input:
122
Output:
221
Explanation:
By reversing the digits of
number,
number will change into 221.
Constraints:
1 <= N <= 10**15
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1619260432,
"func_sign": [
"public long reverse_digit(long n)"
],
"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 long n = Long.parseLong(br.readLine().trim()); \n Solution ob = new Solution();\n long ans = ob.reverse_digit(n);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n // Function to reverse the digits of a given number\n public int reverseDigits(int n) {\n int revN = 0;\n\n // Iteration to reverse the digits\n while (n > 0) {\n revN = revN * 10 + n % 10;\n n = n / 10;\n }\n\n // Returning the reversed number\n return revN;\n }\n}",
"updated_at_timestamp": 1730473704,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public long reverse_digit(long n)\n {\n // Code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1619260432,
"func_sign": [
"reverse_digit(self, n)"
],
"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 ob = Solution()\n ans = ob.reverse_digit(n)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n # Function to reverse the digits of a given number\n def reverse_digit(self, n):\n rev_n = 0\n\n # Iteration to reverse the digits\n while n > 0:\n rev_n = rev_n * 10 + n % 10\n n = n // 10\n\n # Returning the reversed number\n return rev_n\n",
"updated_at_timestamp": 1731579970,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef reverse_digit(self, n):\n\t\t# Code here"
}
|
eJyllEEOgjAQRV0Yz0G6JoYWCsWTmIhxoSzcIAtITIzGQ+jF3HkbG5ICpTO04CwIpMP7nc78Ppfv72rRxPYjX3Y3ci7KuiIbj9CsoIEeWUF8j+TXMj9W+elwqasu9yEX776nA1KRxDwKGQ0oCyMeowAtKxEpwmvXFRffkZkJE4NhTC/SCBQBpYJMPtwVR5lQKlzqMPBKzUy0HfJo+8/Rhhi5IFUYLREoFcwdH8UJs2Mdx79nRxJgTvuKHbNFr/kRadqsjuEOUpimCqaXoStl40qzBQKpMBMuLQhbw9XSFDexcQdNtYzzJaZwmICLmM2WnQjrfRStsIMGs4uomYfs6uY0RWj4+9f6B1YF4Vg=
|
703,725
|
Minimum Operations
|
Given a number N.Find the minimum number of operations required to reach Nstarting from 0. You have 2 operations available:
Examples:
Input:
N = 8
Output:
4
Explanation:
0 + 1 = 1 --> 1 + 1 = 2 --> 2 * 2 = 4 --> 4 * 2 = 8.
Input:
N = 7
Output:
5
Explanation:
0 + 1 = 1 --> 1 + 1 = 2 --> 1 + 2 = 3 --> 3 * 2 = 6 --> 6 + 1 = 7.
Constraints:
1 <= N<= 10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1618400325,
"func_sign": [
"public int minOperation(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[])\n {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while(t-->0)\n {\n int n = sc.nextInt();\n Solution ob = new Solution();\n System.out.println(ob.minOperation(n));\n \nSystem.out.println(\"~\");\n}\n }\n} ",
"script_name": "GfG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution\n{\n public int minOperation(int n)\n {\n int count = 0;\n while(n!=0)\n {\n // if n is even then it will be good to\n // reach n from n/2 by multiplying it by 2.\n if(n%2==0)\n n/=2;\n // if n is odd then we can reach n from n-- only. \n else\n n--;\n \n count++; \n }\n return count;\n }\n}",
"updated_at_timestamp": 1730472859,
"user_code": "//User function Template for Java\nclass Solution\n{\n public int minOperation(int n)\n {\n //code here.\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1618400325,
"func_sign": [
"minOperation(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.minOperation(n))\n",
"solution": "# User function Template for python3\n\nclass Solution:\n # Function to find minimum number of operations required.\n def minOperation(self, n):\n # Initialize count to keep track of operations.\n c = 0\n # Loop until n is not zero.\n while n != 0:\n # if n is even, divide it by 2.\n if n % 2 == 0:\n n = n // 2\n # if n is odd, subtract 1 from it.\n else:\n n = n - 1\n # Increment count.\n c = c + 1\n\n # Return the count.\n return c\n",
"updated_at_timestamp": 1730472859,
"user_code": "#User function Template for python3\n\nclass Solution:\n def minOperation(self, n):\n # code here "
}
|
eJydkkEKwjAQRSP2ICHrIk6atsaTCCouNAs3tYsUCiJ4CL2sK2k2sTA/EGfb95nJ638W70Uhwuw+SyH2d3Xt+sGrrVR06EiVUrmxd2fvLqfb4OMn9SjlHNYA1hxcAbjiYJMD01ojnti7bRi0go3UgDb8QYCueToMctnwGbOp2wZl2CdMmhL/gdhFk6ifLLSm2adp1JCWbUiifxYGshJRNzyNdzePojagrKbMfVE7/ePdphse7B9fqy/1/jj+
|
705,204
|
Nitika and her queries
|
Nitika recently read about XOR operation and she got obssessed with it. She has an array a containing N Positive integers.She wants to perform Q queries on the array.In aquery She gives two integers L and R.(1 based indexing).Now, she asks what is the xor of all the elements of the array after not including the subarray ranging from L to R (both inclusive).Nitika guarantees that in each query, The resulting array isnon empty. The queries are given in a 2D matrix query having L and R for each entry.
Examples:
Input:
N = 10, Q = 3
a = {4, 7, 8, 5, 9, 6, 1, 0, 20, 10}
query = {{3, 8},{1, 6},{2, 3}}
Output:
29
31
17
Explanation:
For the first query:
The resulting array is: (4 ,7 ,20, 10).
Their Xor will be: 29.
For the Second query: The resulting
array is: (1, 0, 20, 10). Their Xor
will be: 31.
For the Third query: The resulting
array is: (4, 5, 9, 6, 1,
0 ,
20, 10).
Their Xor will be: 17.
Constraints:
1 ≤ N, Q ≤ 10**5
1 ≤ A[i] ≤ 10**9
1 ≤ L, R ≤ N
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static List<Integer> specialXor(int N, int Q, int a[], int query[][])"
],
"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 {\n BufferedReader in = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(in.readLine());\n while(t-- > 0){\n String arr[] = in.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(arr[0]);\n int Q = Integer.parseInt(arr[1]);\n String a1[] = in.readLine().trim().split(\"\\\\s+\");\n int a[] = new int[N];\n for(int i = 0;i < N;i++)\n a[i] = Integer.parseInt(a1[i]);\n int query[][] = new int[Q][2];\n for(int i = 0;i < Q;i++){\n String a2[] = in.readLine().trim().split(\"\\\\s+\");\n query[i][0] = Integer.parseInt(a2[0]);\n query[i][1] = Integer.parseInt(a2[1]);\n }\n \n Solution ob = new Solution();\n List<Integer> ans = new ArrayList<Integer>();\n ans = ob.specialXor(N, Q, a, query);\n for(int i = 0;i < Q;i++)\n System.out.println(ans.get(i));\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730436740,
"user_code": "//User function Template for Java\n\nclass Solution{\n static List<Integer> specialXor(int N, int Q, int a[], int query[][])\n {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"specialXor(self, N, Q, a, query)"
],
"initial_code": "# Initial Template for Python 3\n\nimport sys\nsys.setrecursionlimit(10**5)\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N, Q = map(int, input().strip().split())\n a = list(map(int, input().strip().split()))\n query = [[0 for j in range(2)] for i in range(Q)]\n for i in range(Q):\n l, r = map(int, input().strip().split())\n query[i][0] = l\n query[i][1] = r\n\n ob = Solution()\n ans = ob.specialXor(N, Q, a, query)\n for i in ans:\n print(i)\n print(\"~\")\n",
"solution": "# Back-end function Template for python3\n\nclass Solution:\n\n # Function to build the segment tree\n def build(self, v, l, r, a, t):\n if l == r:\n t[v] = a[l]\n else:\n mid = (l + r)//2\n self.build(2*v, l, mid, a, t)\n self.build(2*v+1, mid+1, r, a, t)\n t[v] = t[2*v] ^ t[2*v+1]\n\n # Function to get the xor value in the given range\n def get(self, v, tl, tr, l, r, t):\n if l > r:\n return 0\n if tl == l and tr == r:\n return t[v]\n mid = (tl + tr)//2\n return self.get(2*v, tl, mid, l, min(mid, r), t) ^ self.get(2*v+1, mid+1, tr, max(mid+1, l), r, t)\n\n # Main function to solve the problem\n def specialXor(self, N, Q, a, query):\n val = 0\n t = [0]*(4*N+2)\n\n # Calculating the initial xor value\n for i in range(N):\n val = val ^ a[i]\n\n # Building the segment tree\n self.build(1, 0, N-1, a, t)\n\n sol = []\n # Processing the queries\n for i in range(Q):\n l = query[i][0]\n r = query[i][1]\n\n # Getting the xor value in the given range\n v = self.get(1, 0, N-1, l-1, r-1, t) ^ val\n sol.append(v)\n\n # Returning the solutions\n return sol\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def specialXor(self, N, Q, a, query):\n # code here"
}
|
eJzNlU2OEzEQhVmw4hRPLXaMkKv8z0mQaMQCsmDTzCIjISEQh4D78qq6EdIoDpNMIuik7U5sV331qtz+/vTni2dP/Hr9nA9vvkwfl9u7/fQKk8yLBOR5SahoyOgoEARogAQOQm2ME6r/VvR5iSjzMt1g2n2+3b3f7z68+3S33wwqx6Xx5jdxPh+/cfLXG9zzmsFhUfBBQIv0XqEkEIEkSCQK0WwSolMKKTKqQUgcA5jteSGGDlwztGKWIl0aQKJzhcVHl8n9Z/PPvrkOVIQs1dUIJkd3OdSUaB6KRaym0gCKq6J57usd1+4wXfZwkVwSC9sRDcJpVKEJSuSGGBAVMSEWxIZEuRQpIRUkJnPNn6tmkkhw/DEikVIcYNGVuiHLg3Nkd5/da6Yz5IxCaZmigJrRAhrriaLaKisnyy1708tkVVOZPW0IjUgyTGd2WoY0ppXMKSWNiguyVqD143gPrt3k3z5b9anVYTye4PV7OKduKPy+8Bc0OWoGfwzZX3qyGebAQ2TlsMqYNN/6fdvvW7vuuKPl4jOvWsVyVhmnbk0uD0fzsjyTTk7Fi/bKUAmj19P9nSb/w1aTXC+VablgqiX2YarDYNmjD4R6oRNBerGmbU3c+kcVrWX8H9Xt1fdVexhgGr6FLwoYz1BQGsVrvY7OrZP2Ug7XO/3f/nj5C1V+kVY=
|
705,752
|
Maximum sum Rectangle
|
Given a 2D matrix M of dimensions RxC. Find the maximum sum submatrix in it.
Examples:
Input:
R=4
C=5
M=[[1,2,-1,-4,-20],
[-8,-3,4,2,1],
[3,8,10,1,3],
[-4,-1,1,7,-6]]
Output:
29
Explanation:
The matrix is as follows and the
blue rectangle denotes the maximum sum
rectangle.
Input:
R=2
C=2
M=[[-1,-2],[-3,-4]]
Output:
-1
Explanation:
Taking only the first cell is the
optimal choice.
Constraints:
1<=R,C<=500
-1000<=M[i][j]<=1000
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1731044371,
"func_sign": [
"int maximumSumRectangle(int mat[][])"
],
"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 = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n int N, M, x, y;\n String S[] = read.readLine().split(\" \");\n N = Integer.parseInt(S[0]);\n M = Integer.parseInt(S[1]);\n int a[][] = new int[N][M];\n for (int i = 0; i < N; i++) {\n String s[] = read.readLine().split(\" \");\n for (int j = 0; j < M; j++) a[i][j] = Integer.parseInt(s[j]);\n }\n Solution ob = new Solution();\n System.out.println(ob.maximumSumRectangle(a));\n }\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n int maximumSumRectangle(int mat[][]) {\n int R = mat.length;\n int C = mat[0].length;\n int sum[][] = new int[R + 1][C + 1]; // 2D array to store the cumulative sum of\n // elements in the matrix\n for (int i = 0; i <= R; i++)\n Arrays.fill(sum[i], 0); // initialize all elements of sum array to 0\n for (int i = R - 1; i >= 0; i--) // starting from bottom row, calculate the\n // cumulative sum for each element\n {\n for (int j = C - 1; j >= 0; j--) {\n sum[i][j] += sum[i + 1][j] + sum[i][j + 1] - sum[i + 1][j + 1] +\n mat[i][j]; // calculate the sum using previous sums\n }\n }\n int ans =\n Integer.MIN_VALUE; // variable to store the maximum sum of subrectangle\n for (int i = 0; i < R;\n i++) // iterate over all possible subrectangles starting from row i\n {\n for (int j = i; j < R;\n j++) // iterate over all possible subrectangles ending at row j\n {\n int x =\n 0; // variable to store the sum of subrectangle from row i to row j\n for (int k = 0; k < C; k++) // iterate over all possible columns\n {\n int y = sum[i][k] - sum[i][k + 1] - sum[j + 1][k] +\n sum[j + 1][k + 1]; // calculate the sum for each column in\n // the subrectangle\n x += y; // update x by adding the sum of current column\n ans = Math.max(\n ans,\n x); // update ans by comparing with current sum of subrectangle\n x = Math.max(x, 0); // reset x to 0 if it becomes negative\n }\n }\n }\n return ans; // return the maximum sum of subrectangle\n }\n};",
"updated_at_timestamp": 1731044371,
"user_code": "// User function Template for Java\n\nclass Solution {\n int maximumSumRectangle(int mat[][]) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1731044371,
"func_sign": [
"maximumSumRectangle(self,mat)"
],
"initial_code": "# Initial Template for Python 3\n\nimport math\nimport sys\n\nif __name__ == '__main__':\n t = int(sys.stdin.readline().strip())\n for _ in range(t):\n N, M = map(int, sys.stdin.readline().strip().split())\n a = []\n for i in range(N):\n s = list(map(int, sys.stdin.readline().strip().split()))\n a.append(s)\n ob = Solution()\n print(ob.maximumSumRectangle(a))\n",
"solution": "class Solution:\n\n # Function to find the maximum sum subarray using Kadane's algorithm\n def kadanes(self, arr, n):\n s, maxi = arr[0], arr[0]\n for i in range(1, n):\n s += arr[i]\n s = max(s, arr[i])\n maxi = max(s, maxi)\n return maxi\n\n # Function to find the maximum sum submatrix\n def maximumSumRectangle(self, mat):\n res = mat[0][0]\n R = len(mat)\n C = len(mat[0])\n # Looping through all possible starting rows\n for starti in range(R):\n subMatSum = [0 for _ in range(C)]\n # Looping through all possible ending rows\n for i in range(starti, R):\n # Updating the column-wise sum of the submatrix\n for j in range(C):\n subMatSum[j] += mat[i][j]\n # Comparing the current sum with the maximum sum so far\n res = max(res, self.kadanes(subMatSum, C))\n return res\n",
"updated_at_timestamp": 1731044371,
"user_code": "#User function Template for python3\nclass Solution:\n def maximumSumRectangle(self,mat):\n #code here"
}
|
eJzFVMFKxDAQ9SB+xxDw1kiaNO2uXyJY8aA9eIl76IIggh+h/+vMpHaXNhM3IhiakrQzb17em/b9/LO6OONxc4mL21f1FHb7UV2DqvtQA92MMaoCNbzshodxeLx/3o/fIfiqD+qtgkSeziRqKdOBixWBQyDGHdYwZS5CCvlxlZg9I074ZvGiENmDJwA4unhfM92jB8uAzF6mkGLQQEMGWHC08NBCB5s+bJEC1EjEErxD2Aanx9kK+N1GhCdaFjSi0AZBWtAdaEzQW5INJxHHUlgJC2EdsYxPlol9QOef9GNd4gNJj7QfltUgxChHH2Y9JEY+hWTJ2UlXNhmP3bAGNuPRGkqLddeBc6ufllHQ2b//1Aq/CVGaVdyJgYffErmYIZPsq7yLP/RLicvufywzf+KZwyHyv/u4+gIAWKWD
|
713,976
|
Optimal Array
|
You are given a sorted array a of length n. For each i(0<=i<=n-1), you have to make all the elements of the array from index 0 till i equal, using minimum number of operations. In one operationyou either increase or decrease the array element by 1.
Examples:
Input:
N=4
A={1,6,9,12}
Output:
0 5 8 14
Explanation:
For i=0, We do not need to perform any
operation, our array will be {1}->{1}.
And minimum number of operations
will be 0.
For i=1, We can choose to convert all
the elements from 0<=j<=i to 4, our
array will become {1,6}->{4,4}. And
minimum number of operations will be
|1-4|+|6-4|=5.
For i=2, We can choose to convert all
the elements from 0<=j<=i to 6, our
array will become {1,6,9}->{6,6,6} and
the minimum number of operations will
be |1-6|+|6-6|+|9-6|=8.
Similarly, for i=3, we can choose to
convert all the elements to 8,
{1,6,9,12}->{8,8,8,8}, and the
minimum number of operations will be 14.
Input:
N=7
A={1,1,1,7,7,10,19}
Output:
0 0 0 6 12 21 33
Explanation:
Possible operations could be:
{1}->{1}
{1,1}->{1,1}
{1,1,1}->{1,1,1}
{1,1,1,7}->{1,1,1,1}
{1,1,1,7,7}->{1,1,1,1,1}
{1,1,1,7,7,10}->{5,5,5,5,5,5}
{1,1,1,7,7,10,19}->{7,7,7,7,7,7,7}
Constraints:
1 <= N <= 10**6
-10**5
<= A[i] <= 10**5
Sum of N over all test case does not exceed 10**6
.
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1675772812,
"func_sign": [
"public long[] optimalArray(int n,int a[])"
],
"initial_code": "import java.util.*;\nimport java.io.*;\n\nclass GFG {\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());\n while(t-->0){\n int n=Integer.parseInt(in.readLine());\n String s[]=in.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 Solution ob=new Solution();\n long arr[]=ob.optimalArray(n,a);\n for(long i:arr){\n out.print(i+\" \");\n }\n out.println();\n \nout.println(\"~\");\n}\n out.close();\n }\n}",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\nclass Solution {\n public long[] optimalArray(int n,int a[])\n {\n int sum1=0,sum2=0; //initialize two variables to store the sum of elements\n long ans[]=new long[n]; //initialize an array to store the answers\n int mid=(n+1)/2; //get the middle index of the array\n int ind=0; //initialize an index variable\n for(int i=0;i<mid;i++){ //iterate till the middle index\n sum1+=a[i]; //add the current element to the sum1 variable\n if(i*2<n){ //check if there is at least one more element to access\n sum2+=a[i*2]; //add the next element to the sum2 variable\n int diff=((i+1)*a[i])-sum1+((sum2-sum1)-i*a[i]); //calculate the difference between elements as per the formula given\n ans[ind++]=diff; //store the difference in the answer array\n }\n if(i*2+1<n){ //check if there is another element to access\n sum2+=a[i*2+1]; //add the next element to the sum2 variable\n int diff=((i+1)*a[i])-sum1+((sum2-sum1)-(i+1)*a[i]); //calculate the difference between elements as per the formula given\n if(diff<0){ //check if the difference is negative\n diff = diff*-1; //convert the difference to positive\n }\n ans[ind++]=diff; //store the difference in the answer array\n }\n }\n return ans; //return the answer array\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public long[] optimalArray(int n,int a[])\n {\n \n }\n}\n \n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1675772812,
"func_sign": [
"optimalArray(self, n : int, a : List[int]) -> List[int]"
],
"initial_code": "class 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 = int(input())\n a = IntArray().Input(n)\n obj = Solution()\n res = obj.optimalArray(n, a)\n IntArray().Print(res)\n print(\"~\")\n",
"solution": "from typing import List\n\n\nclass Solution:\n # Function to find the optimal array\n def optimalArray(self, n: int, a: List[int]) -> List[int]:\n sum1 = 0\n sum2 = 0\n ans = []\n\n # Finding the midpoint\n mid = (n + 1) // 2\n\n # Looping through the array elements\n for i in range(mid):\n sum1 += a[i]\n\n # Calculating diff for even indexed elements\n if 2 * i < n:\n sum2 += a[2 * i]\n diff = ((i + 1) * a[i]) - sum1 + ((sum2 - sum1) - i * a[i])\n ans.append(diff)\n\n # Calculating diff for odd indexed elements\n if 2 * i + 1 < n:\n sum2 += a[2 * i + 1]\n diff = ((i + 1) * a[i]) - sum1 + \\\n ((sum2 - sum1) - (i + 1) * a[i])\n\n # Taking absolute value if diff is negative\n if diff < 0:\n diff = diff * -1\n ans.append(diff)\n\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "from typing import List\nclass Solution:\n def optimalArray(self, n : int, a : List[int]) -> List[int]:\n # code here\n \n"
}
|
eJzNVctKxDAUdSH4G5euJ5J3M36JYMWFzkIXdYQZEETxI/R/vclpp7GaUBHEhnKnuSfnJPeReT1+fzg5Ss/5Hf+4eGpu++1+15xRo7teSX5JkyFLjjy1FGhNaTa9/BF40rPTMkiTalbUbB63m+vd5ubqfr8buCRFGstIXs4wT1qSdtT1L10fnSJ6RXQL+EUGaJ5XlG1MsbSLG6uM4j5qoyCm+axCyfiQWMMEmBbGwzgYC2NgNExazxqwmAQCcKwFEVghkfTKUc3YbMaAXSo4lJ9QMaiTNhv47ECBdQ6THowtfEFNzIOwLIbMx+rIgDWzIFUFlXUsAsPF18ay4qwbUo5UW2SMRRZSAQbSXLH8XTvCIemjdUMS3bLtDzCXx91W49ai38ZhKu00Dl3sETn1yIGwQomRt3uBOKBlR05FlfqEZrobiod2U6RnAf/8WU6rHPJSqhX6t3eZMKZytDnYLcfOi+lX1SRqt9BXYcBHeaNVUfpbMfcTLfq7vwLc6Hphrmw1ZJdvpx/tpdfT
|
703,041
|
Toppers Of Class
|
There is a class of some students and the task is to find the top k marks scorers. You need to print the index of the class's toppers, which will be the same as the student's index in the input array (use 0-based indexing). First, return the index of the students having the highest marks then the students with second highest and so on. If more than one student has the same marks then return their indices in ascending order. Suppose k = 2 and the students having the highest marks have indices 0 and 5 and students having second highest marks have indices 6 and 7 then output will be 0 5 6 7.
Examples:
Input:
arr[] = [2, 2, 1, 3, 1], k = 3
Output:
[3, 0, 1, 2, 4]
Explanation:
Topper with 3 marks is present at 3rd index, 2 marks is present at 0
**th
index and next at 1
**st
index. 1 marks is present at 2 and 4.
Input:
arr[] = [1, 2, 3, 4], k = 1
Output:
[3]
Explanation:
The highest marks is at index 3.
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ k ≤ 10**6
1 ≤ arr[i] ≤ 10**8**
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public List<Integer> kToppers(int[] arr, int k)"
],
"initial_code": "import java.util.*;\n\n//Position this line where user code will be pasted.\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 newline\n while (t-- > 0) {\n String[] arrInput = scanner.nextLine().split(\" \");\n int[] arr = Arrays.stream(arrInput).mapToInt(Integer::parseInt).toArray();\n int k = Integer.parseInt(scanner.nextLine());\n\n Solution solution = new Solution();\n List<Integer> result = solution.kToppers(arr, k);\n\n for (int index : result) {\n System.out.print(index + \" \");\n }\n System.out.println();\n System.out.println(\"~\");\n }\n scanner.close();\n }\n}",
"script_name": "Main",
"solution": "class Solution {\n public List<Integer> kToppers(int[] arr, int k) {\n // List of pairs to store marks and their indices\n List<int[]> marksIndices = new ArrayList<>();\n // Filling the list with pairs of marks and their indices\n for (int i = 0; i < arr.length; i++) {\n marksIndices.add(new int[] {arr[i], i});\n }\n // Sorting the list first by marks in descending order, and then by indices in\n // ascending order\n Collections.sort(\n marksIndices,\n (a, b) -> {\n if (a[0] != b[0]) {\n return b[0] - a[0]; // Descending order of marks\n } else {\n return a[1] - b[1]; // Ascending order of indices\n }\n });\n // Collecting the top k scorers\n List<Integer> result = new ArrayList<>();\n int count = 0;\n for (int i = 0; i < marksIndices.size(); i++) {\n if (i == 0 || marksIndices.get(i)[0] != marksIndices.get(i - 1)[0]) {\n count++;\n }\n if (count > k) break;\n result.add(marksIndices.get(i)[1]);\n }\n return result;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public List<Integer> kToppers(int[] arr, int k) {\n // Your code goes here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"kToppers(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 ob = Solution()\n result = ob.kToppers(arr, k)\n print(\" \".join(map(str, result)))\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def kToppers(self, arr, k):\n # List of tuples to store marks and their indices\n marks_indices = [(arr[i], i) for i in range(len(arr))]\n\n # Sorting the list first by marks in descending order, and then by indices in ascending order\n marks_indices.sort(key=lambda x: (-x[0], x[1]))\n\n # Collecting the top k scorers\n result = []\n count = 0\n for i in range(len(marks_indices)):\n if i == 0 or marks_indices[i][0] != marks_indices[i - 1][0]:\n count += 1\n if count > k:\n break\n result.append(marks_indices[i][1])\n\n return result\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def kToppers(self, arr, k):\n # Your code goes here"
}
|
eJy1VUtOxDAMZcGCO7Cxsh6h5j/DSZAIYgFdsAmz6EhICMQh4L64SVo6ad2mMLSRbDWt/fKe7X6cf7GLs3DdXKJz+8qe/P7QsGtg3HlepQt26eqcbedYfIttgNUv+/qhqR/vnw9NClA5/+48e9sAFXXWc15QgYGDAEmFh9Hd5pyPBQo0GLCAByPi4tlx14bb4Nsav5H4LW7J5eAkFyDCQkd2S4WlkQFNBN4FpBFzm6Ki2ch5hWMlt5m1mTWZ1TSoEZUUkYP8KW3KlpLoaFQ0MhoRDY+mWiCdSK07EkiHjxxR4jivCDh9WQVm5sBNdFvZo74nR3t22E6GJEwgMpQAscmgHaXcRGu1p6EGAF+aAIguLzzxm8qTEM+A2Ndn/O+UuVDwt+m5phXCaChnxB6LYFdSIlKFk7Muq5xTlc9IP9ujnYOrA1hJtuNQs5IxpVbOKdMOg+J/zWl+NhOSzwr6g/Du8+ob294Rsw==
|
703,069
|
Number of positive integral solutions
|
You are given an equation of the form x1+x2+...+xN=K. You need to find the total number of positive integral solutions of this equation.
Examples:
Input:
s = a+b=5
Output:
4
Explanation:
(4,1) , (1,4) , (2,3) , (3,2)
Input:
s = a+b=1
Output:
0
Explanation:
No solution exist.
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"long posIntSol(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[])\n {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while(t-->0)\n {\n String s = sc.next();\n Solution obj = new Solution();\n System.out.println(obj.posIntSol(s));\n \nSystem.out.println(\"~\");\n}\n \n }\n}\n",
"script_name": "GfG",
"solution": "None",
"updated_at_timestamp": 1730470084,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n long posIntSol(String s)\n {\n //code here.\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"posIntSol(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 solObj = Solution()\n print(solObj.posIntSol(s))\n print(\"~\")\n",
"solution": "import math\n\n\nclass Solution:\n def posIntSol(self, s):\n p = s.split(\"=\")\n # Splitting the input string at the \"=\" sign to get the equation components\n x = len(p[0]) - (p[0].count('+'))\n # Calculating the number of variables in the equation\n if x > int(p[1]):\n return 0\n # If the number of variables exceeds the target value, return 0\n else:\n v = math.factorial(int(p[1]) - 1)\n # Calculating the factorial of the target value - 1\n n = math.factorial(x - 1) * math.factorial(int(p[1]) - x)\n # Calculating the factorial of the number of variables minus 1 multiplied by the factorial of the difference between the target value and the number of variables\n return int(v / n)\n # Returning the result of dividing the two factorials to get the number of possible solutions\n",
"updated_at_timestamp": 1730470084,
"user_code": "#User function Template for python3\n\nclass Solution:\n def posIntSol(self,s):\n #code here"
}
|
eJxrYJnKxsoABhH/WRgYoquVMvMKSkuUrBSUDGPyErWTbI1i8pR0FJRSKwpSk0tSU+LzS0sQCuqAkrU6Cmi6bE1J1wO0ydAApzZL3Nq0k20NceozwKsPtzPN8OnTTrE1IceDIJ3aqbbG5LkWrBdPEBkaEXC0dqp2mq0hbj8bGRgYETZBO93WnBzPJ+JJSAT8DQpt8pMVLOQodQU0+MgOPLgvSPdCMt60akLY3Yl4Yw2Px6E2w0xDT8fEmE6880CCVIgscCZBtoCgYbDSJXaKHgAWcpfM
|
713,974
|
Number of Good Components
|
Given an undirected graph with v vertices(numbered from 1 to v) and e edges. Find the number of good components in the graph.A component of the graph is good if and only if the component is fully connected.Note:A fully connected component is a subgraph of a given graph such that there's an edge between every pair of vertices in the component, the given graph can be a disconnected graph.
Examples:
Input:
e=3
v=3
edges
=
{{1, 2},{1, 3},{3, 2}}
Output:
1
Explanation:
We can see that there is only one component in the graph and in this component there is a edge between any two vertces
.
Input:
e=5
v=7
edges
=
{{1, 2},{7, 2},{3, 5},{3, 4},{4, 5}}
Output:
2
Explanation:
We can see that there are 3 components in the graph. For 1-2-7 there is no edge between 1 to 7, so it is not a fully connected component. Rest 2 are individually fully connected component.
Constraints:
1 <= edges[i][0], edges[i][1] <= v
1 ≤ v, e ≤ 10**4
All edges are unique
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1715520969,
"func_sign": [
"public static int findNumberOfGoodComponent(int e, int v, int[][] edges)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass IntMatrix {\n public static int[][] input(BufferedReader br, int n, int m) throws IOException {\n int[][] mat = new int[n][];\n\n for (int i = 0; i < n; i++) {\n String[] s = br.readLine().trim().split(\" \");\n mat[i] = new int[s.length];\n for (int j = 0; j < s.length; j++) mat[i][j] = Integer.parseInt(s[j]);\n }\n\n return mat;\n }\n\n public static void print(int[][] m) {\n for (var a : m) {\n for (int e : a) System.out.print(e + \" \");\n System.out.println();\n }\n }\n\n public static void print(ArrayList<ArrayList<Integer>> m) {\n for (var a : m) {\n for (int e : a) 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 e;\n e = Integer.parseInt(br.readLine());\n\n int v;\n v = Integer.parseInt(br.readLine());\n\n int[][] edges = IntMatrix.input(br, e, 2);\n\n Solution obj = new Solution();\n int res = obj.findNumberOfGoodComponent(e, v, edges);\n\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public int findNumberOfGoodComponent(int E, int V, int[][] edges) {\n boolean v[] = new boolean[V + 1]; // boolean array to track visited vertices\n int ans = 0; // variable to store the number of good components\n\n ArrayList<ArrayList<Integer>> adj = new ArrayList<>(); // adjacency list\n for (int i = 0; i <= V; i++) {\n adj.add(new ArrayList<>());\n }\n\n // Convert edge array to adjacency list\n for (int[] edge : edges) {\n int a = edge[0];\n int b = edge[1];\n adj.get(a).add(b);\n adj.get(b).add(a);\n }\n\n for (int i = 1; i <= V; i++) {\n if (!v[i]) { // if the current vertex is not visited\n int[] counts =\n dfs(adj, i, v); // perform depth-first search starting from i\n\n int vertices = counts[0];\n int edgesCount = counts[1];\n\n edgesCount /= 2; // divide the count of edges by 2 (since each edge is\n // counted twice)\n\n // check if the count of edges is equal to the maximum number of edges\n // possible in a complete graph\n if (edgesCount == (vertices * (vertices - 1)) / 2) {\n ans++; // increment the count of good components\n }\n }\n }\n\n return ans; // return the number of good components\n }\n\n private static int[] dfs(ArrayList<ArrayList<Integer>> A, int i, boolean v[]) {\n v[i] = true; // mark the current vertex as visited\n int[] counts = new int[2]; // counts[0] stores vertices, counts[1] stores edges\n counts[0] = 1; // increment the count of vertices\n counts[1] +=\n A.get(i).size(); // add the number of edges connected to the current vertex\n\n for (int child :\n A.get(i)) { // iterate over the adjacent vertices of the current vertex\n if (!v[child]) { // if the child vertex is not visited\n int[] childCounts = dfs(\n A, child,\n v); // recursively perform depth-first search on the child vertex\n counts[0] += childCounts[0]; // update vertices count\n counts[1] += childCounts[1]; // update edges count\n }\n }\n return counts;\n }\n}",
"updated_at_timestamp": 1730482033,
"user_code": "\nclass Solution {\n public static int findNumberOfGoodComponent(int e, int v, int[][] edges) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1715520969,
"func_sign": [
"findNumberOfGoodComponent(self, e : int, v : int, edges : List[List[int]]) -> int"
],
"initial_code": "class IntMatrix:\n\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 e = int(input())\n\n v = int(input())\n\n edges = IntMatrix().Input(e, 2)\n\n obj = Solution()\n res = obj.findNumberOfGoodComponent(e, v, edges)\n\n print(res)\n\n print(\"~\")\n",
"solution": "import collections\nfrom collections import deque # importing deque from collections module\n# importing defaultdict from collections module\nfrom collections import defaultdict\n\n\nclass Solution:\n\n # Depth First Search algorithm to traverse the graph\n def dfs(self, v, adj, visited):\n visited[v] = 1 # marking the current vertex as visited\n self.vertices += 1 # incrementing the vertex count\n # adding the number of edges connected to the current vertex\n self.edges += len(adj[v])\n\n # iterating over all the adjacent vertices\n for to in adj[v]:\n if not visited[to]: # if the adjacent vertex is not visited\n self.dfs(to, adj, visited) # recursive call to dfs function\n\n # Function to find the number of good components\n def findNumberOfGoodComponent(self, E, V, edges):\n ans = 0 # variable to store the count of good components\n visited = [0] * (V + 1) # array to mark visited vertices\n adj = [[] for _ in range(V + 1)]\n for u, v in edges:\n adj[u].append(v)\n adj[v].append(u)\n for i in range(1, V + 1):\n if not visited[i]: # if the vertex is not visited\n self.vertices = 0 # initialize vertex count to 0\n self.edges = 0 # initialize edge count to 0\n # call to dfs function to traverse the graph starting from current vertex\n self.dfs(i, adj, visited)\n\n self.edges //= 2 # divide the edge count by 2 as each edge is counted twice\n # check if the number of edges is equal to the number of vertices choose 2\n if self.edges == (self.vertices * (self.vertices - 1)) // 2:\n ans += 1 # increment the count of good components\n\n return ans # return the count of good components\n",
"updated_at_timestamp": 1730482033,
"user_code": "\nfrom typing import List\nclass Solution:\n def findNumberOfGoodComponent(self, e : int, v : int, edges : List[List[int]]) -> int:\n # code here\n \n"
}
|
eJzFVMFOwzAM3YHDPiPKeUJzG6fdvgSJIg7QA5ewQydNQkz7iPEd3Pg+8tKiMqi3pVq0qrXS1nl+tl+8u/n4mk7CdffpF/dv+sWt1o1eKk2VM5WzlSOVweQw/kuGVYZVroyeKV1vVvVTUz8/vq6bbq/fsK2cfp+pQ0DuAQNMDhijGN84oAqAJADS3D/8jyO1kCFWAVPCLGCw409shqOFY6FKgQALBACcDad0ANuR6OrGcLFwKYR4Rojn0RanwlH7g4/hH+lQqOlgAOqwf2dBeOXIqtm2cIPCCjqwfZUiE0B1zFkNKVtB5ENdgV+sFGRx/1QuUtxFuE9lQgLqXKapLnsIIzUTX9bz0dHRkapUV58ml2Zgrk8hMJCOcKqZmiaLNJO6nxtjZ3aSZMVsx8kmjW4e9rff/2KGVg==
|
714,078
|
Count Cyclic Paths
|
Given atriangular pyramidwith its vertices marked asO, A, B and Cand a numberN, the task is to find the number of ways such that a person starting from the originOinitially, reaches back to the origin in N steps. In a single step, a person can go to any of its adjacent vertices.
Examples:
Input:
N = 1
Output:
0
Explanation:
The minimum length of
a cyclic path is 2.
Input:
N = 2
Output:
3
Explanation:
The three paths are :
O-A-O, O-B-O, O-C-O
Constraints:
1 ≤N ≤ 10**6
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1676786428,
"func_sign": [
"public static int countPaths(int N)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\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\n Solution ob = new Solution();\n System.out.println(ob.countPaths(N));\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n public static int countPaths(int N) {\n // code here\n // initialize variables\n long mod = 1000000007l;\n long low = 1l, high = 0l;\n long tlow = 1l, thigh = 0l;\n // iterate from 2 to N\n for (int i = 2; i <= N; i++) {\n // calculate the new high value\n high = (3 * tlow) % mod;\n // calculate the new low value\n low = (((2 * tlow) % mod) + thigh) % mod;\n // update temporary low and high variables\n tlow = low;\n thigh = high;\n }\n // return the final high value\n return (int) high;\n }\n}\n",
"updated_at_timestamp": 1730482269,
"user_code": "//User function Template for Java\n\nclass Solution{\n\tpublic static int countPaths(int N){\n\t\t//code here\n\t}\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1676786428,
"func_sign": [
"countPaths(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.countPaths(N))\n print(\"~\")\n",
"solution": "class Solution:\n def countPaths(self, N):\n # code here\n mod = 1000000007\n low, high = 1, 0\n tlow, thigh = 1, 0\n for i in range(2, N + 1):\n high = (3 * tlow) % mod\n low = (((2 * tlow) % mod) + thigh) % mod\n tlow = low\n thigh = high\n return high\n",
"updated_at_timestamp": 1730482269,
"user_code": "#User function Template for python3\n\nclass Solution:\n def countPaths (self, N):\n # code here \n "
}
|
eJydk8FKBDEMhj3sgww9L9I0TZr4JIIVDzoHL+MeZmFBlH2I3ZsPa2dYBA9/xc2p0Hz9w5+/x835a3Oz1v25HR7ew+u028/hbghUJwrbIYyH3fg8jy9Pb/v5chXr9Fmn8LEdfvcn0M+gn0G/gn6KERAlkVDMnDC5FKCTamI2QbrShcnNY3EHsK+F5hbJRMm6sCFlIYtcNPfgAmBj5yxWoGGAo1wU7XNxmTpONaNyFOvP28lFyaSlCSC3pLMmV5dUxAXN/semUOYX7ici1+FX69b6f24ZlnrBaD9JI7OjBwR73NKsFJ2gtq/qtBqFUm1GptxWfXnk8XT7DfXaZjg=
|
702,661
|
Maximum value
|
Given an array arr[] of integres. Find the maximum value of arr[j] – arr[i] + arr[l] – arr[k], such that i < j < k < l.Examples:
Examples:
Input:
arr[] = [1, 2, 3]
Output:
-1
Explanation:
arr.size() < 4 so no such i,j,k,l is possible.
Input:
arr[] = [4, 8, 9, 2, 20]
Output:
23
Explanation:
Here i = 0, j = 2, k = 3, l = 4 so arr[j] – arr[i] + arr[l] – arr[k] = 9 – 4 + 20 – 2 = 23
Constraints:
1 ≤ arr.size() ≤ 10**5
1 ≤ arr[i] ≤ 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1725623061,
"func_sign": [
"public int findMaxValue(int[] arr)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\npublic class Main {\n public static void main(String[] args) throws IOException {\n BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(reader.readLine().trim());\n\n while (t-- > 0) {\n String[] input = reader.readLine().trim().split(\"\\\\s+\");\n int[] arr = Arrays.stream(input).mapToInt(Integer::parseInt).toArray();\n Solution ob = new Solution();\n System.out.println(ob.findMaxValue(arr));\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public int findMaxValue(int[] arr) {\n int n = arr.length;\n int MIN = Integer.MIN_VALUE;\n // If the array size is less than 4, return -1\n if (n < 4) {\n return -1;\n }\n // Initialize four arrays with minimum value\n int[] table1 = new int[n + 1];\n int[] table2 = new int[n + 1];\n int[] table3 = new int[n + 1];\n int[] table4 = new int[n + 1];\n Arrays.fill(table1, MIN);\n Arrays.fill(table2, MIN);\n Arrays.fill(table3, MIN);\n Arrays.fill(table4, MIN);\n // Fill up the tables\n for (int i = n - 1; i >= 0; i--) table1[i] = Math.max(table1[i + 1], arr[i]);\n for (int i = n - 2; i >= 0; i--) table2[i] = Math.max(table2[i + 1], table1[i + 1] - arr[i]);\n for (int i = n - 3; i >= 0; i--) table3[i] = Math.max(table3[i + 1], table2[i + 1] + arr[i]);\n for (int i = n - 4; i >= 0; i--) table4[i] = Math.max(table4[i + 1], table3[i + 1] - arr[i]);\n int res = MIN;\n for (int i = 0; i <= n - 1; i++) res = Math.max(res, table4[i]);\n return res;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public int findMaxValue(int[] arr) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1725623052,
"func_sign": [
"findMaxValue(self, arr)"
],
"initial_code": "def main():\n import sys\n input = sys.stdin.read\n data = input().splitlines()\n t = int(data[0])\n index = 1\n solution = Solution()\n while t > 0:\n t -= 1\n arr = list(map(int, data[index].strip().split()))\n index += 1\n print(solution.findMaxValue(arr))\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def findMaxValue(self, arr):\n n = len(arr)\n if n < 4:\n return -1\n\n # Initialize four lists with a large negative value\n MIN = float('-inf')\n table1 = [MIN] * (n + 1)\n table2 = [MIN] * (n + 1)\n table3 = [MIN] * (n + 1)\n table4 = [MIN] * (n + 1)\n\n # Fill up the first table by finding the maximum value from the right\n for i in range(n - 1, -1, -1):\n table1[i] = max(table1[i + 1], arr[i])\n\n # Fill up the second table by finding the maximum difference from the right\n for i in range(n - 2, -1, -1):\n table2[i] = max(table2[i + 1], table1[i + 1] - arr[i])\n\n # Fill up the third table by finding the maximum value after adding the difference from the right\n for i in range(n - 3, -1, -1):\n table3[i] = max(table3[i + 1], table2[i + 1] + arr[i])\n\n # Fill up the fourth table by finding the maximum difference after subtracting the value from the right\n for i in range(n - 4, -1, -1):\n table4[i] = max(table4[i + 1], table3[i + 1] - arr[i])\n\n # Find the maximum value from the last table\n res = max(table4)\n\n return res\n",
"updated_at_timestamp": 1727947200,
"user_code": "class Solution:\n def findMaxValue(self, arr):\n #code here.\n"
}
|
eJydk90KgkAUhLuo9xj22sIt15+eJMiIKKFuzAuFIIIeot43dz1FRpbn7LK4IDN8M0evw/t+NHBrsakvy7M65EVVqjmUTnPt22MXNHpclAeVnYpsW2a79bEqyWlcW6mLh7Z5WHtjBjosaZDmphH6LF1s48AgRoQEIQJMWXrj9InTh1xiDbfZMur2y4PLbkBbgN4etTSE7Et5q53XemvkNHC52etn4MFrqoCKIKZnLN4snIRJLao6YtfTlfNjfrLY5O3/MXcveoJYkgZFxtJl/9NsdZs8ALfCja4=
|
710,138
|
Graph is Tree or Not
|
You are given an undirected graph of N nodes (numbered from 0 to N-1) and M edges. Return 1 if the graph is a tree, else return 0.
Examples:
Input:
N = 4, M = 3
G = [[0, 1], [1, 2], [1, 3]]
Output:
1
Explanation:
Every node is reachable and the graph has no loops, so it is a tree
Input:
N = 4, M = 3
G = [[0, 1], [1, 2], [2, 0]]
Output:
0
Explanation:
3 is not connected to any
node and there is a loop 0->1->2->0, so
it is not a tree.
Constraints:
1 <= N <= 2*10**5
0 <= M <= 2*10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1705730392,
"func_sign": [
"public boolean isTree(int n, int m, ArrayList<ArrayList<Integer>> edges)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\npublic class GFG {\n public static void main(String[] args) {\n Scanner scanner = new Scanner(System.in);\n int t=scanner.nextInt();\n while(t-- > 0)\n {\n int n = scanner.nextInt();\n int m = scanner.nextInt();\n \n ArrayList<ArrayList<Integer>> edges = new ArrayList<>();\n for (int i = 0; i < m; i++) {\n int u = scanner.nextInt();\n int v = scanner.nextInt();\n ArrayList<Integer> edge = new ArrayList<>();\n edge.add(u);\n edge.add(v);\n edges.add(edge);\n }\n \n Solution solution = new Solution();\n boolean result = solution.isTree(n, m, edges);\n \n if (result==true) {\n System.out.println(1);\n } else {\n System.out.println(0);\n }\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 boolean isTree(int n, int m, ArrayList<ArrayList<Integer>> edges) \n {\n // code here\n }\n}\n\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1647470337,
"func_sign": [
"isTree(self, n, m, edges)"
],
"initial_code": "# Initial Template for Python 3\n\nfor _ in range(int(input())):\n n, m = [int(i) for i in input().split()]\n edges = []\n for i in range(m):\n a, b = map(int, input().split())\n edges.append([a, b])\n\n ob = Solution()\n print(ob.isTree(n, m, edges))\n print(\"~\")\n",
"solution": "from collections import deque\n\n\nclass Solution:\n def isTree(self, n, m, edges):\n if m != n - 1:\n return 0\n\n vis = [False] * n\n adj = [[] for _ in range(n)]\n\n for edge in edges:\n adj[edge[0]].append(edge[1])\n adj[edge[1]].append(edge[0])\n\n node = 0\n q = deque()\n\n vis[node] = True\n visited = 1\n q.append(node)\n\n while q:\n curr = q.popleft()\n for neighbor in adj[curr]:\n if not vis[neighbor]:\n vis[neighbor] = True\n visited += 1\n q.append(neighbor)\n\n return int(visited == n)\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def isTree(self, n, m, edges):\n # Code here"
}
|
eJy11c2KU0EQBWAXgq9xyHqQW9X165MIRlxoFm7iLDKMIA4+hL6vp6OiI0nwBswiBG7XV3W7D50vT789PHty/Ly8549Xnzbv97d3h80LbGS7Fyzb/eYGm93H293bw+7dmw93h9+PH/jw8w0e1yj4tcyvlYUD42ehQKdzvvdyltA/iZUDGOzxAGOK66fwk46tnsfhp53lAnZuqDiH2XywcjJZ0Bc0R8yGud0naruvuXh1B7ZY26Mhy3E4mUUCYZkwjyyUAWGpGITF4hCWS0AISEJISEGISEOp6AKdaWbv2VyhVJQBo6IGpaIOpaIBpaIJpaIFpaKNQWUsGDOXgkFl8B3mSzDpVIZhUBmOQWUEBpWRGFRGYVAZDaNiPPCZT4FRMYVRMe7F3AymlooxdFQsYFQsYVSsYFSs4VR8gc9UCZyKK5yKDzgV557OTWXkqDjDQsUTTsULTsUbQSUWxIyTIKiEIqjEQFAJQ1AJns08nEBQiURQiUJQiUZSyQVJJQVJJRVJJQeSShqSSjqSSvKM5yEnkkoWkko2ikotKColKCqlKCo1UFTKUFTKUVQqUFSKWZlhKRSVajSVZtKotKCptKKp9EBTaUNTaUdT6UBT6URT6TomdE2wz98lfy+c2TlmZMX6H6d0rJop+7fKX7f8/7kCrr8DLox0YuWKbb1yn45XwnWHMf+TLjZ6/fX5d7nII+c=
|
705,358
|
Possible paths
|
Given a directed graph and two vertices ‘u’ and ‘v’ in it. Find the number of possible walks from ‘u’ to ‘v’ with exactly k edges on the walk modulo 10**9+7.
Examples:
Input:
graph = {{0,1,1,1},{0,0,0,1},
{0,0,0,1}, {0,0,0,0}}, u = 0, v = 3, k = 2
Output:
2
Explanation:
Let source ‘u’ be vertex 0,
destination ‘v’ be 3 and k be 2. The output
should be 2 as there are two walk from 0 to
3 with exactly 2 edges. The walks are {0, 2, 3}
and {0, 1, 3}.
Constraints:
1 ≤ n ≤ 50
1 ≤ k ≤ n
0 ≤ u, v ≤ n-1
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int MinimumWalk(int[][] graph, int u, int v, int k)"
],
"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[][] graph = 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 graph[i][j] = Integer.parseInt(S[j]);\n }\n String[] S1 = br.readLine().trim().split(\" \");\n int u = Integer.parseInt(S1[0]);\n int v = Integer.parseInt(S1[1]);\n int k = Integer.parseInt(S1[2]);\n Solution ob = new Solution();\n int ans = ob.MinimumWalk(graph, u, v, k);\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 int MinimumWalk(int[][] graph, int u, int v, int k) {\n int V = graph.length;\n int mod = 1000000007;\n // Table to be filled up using DP. The value count[i][j][e]\n // will/ store count of possible walks from i to j with\n // exactly k edges\n int count[][][] = new int[V][V][k + 1];\n // Loop for number of edges from 0 to k\n for (int e = 0; e <= k; e++) {\n for (int i = 0; i < V; i++) // for source\n {\n for (int j = 0; j < V; j++) // for destination\n {\n // initialize value\n count[i][j][e] = 0;\n // from base cases\n if (e == 0 && i == j) count[i][j][e] = 1;\n if (e == 1 && graph[i][j] != 0) count[i][j][e] = 1;\n // go to adjacent only when number of edges\n // is more than 1\n if (e > 1) {\n for (int a = 0; a < V; a++) // adjacent of i\n if (graph[i][a] != 0)\n count[i][j][e] = (count[i][j][e] % mod + count[a][j][e - 1] % mod) % mod;\n }\n }\n }\n }\n return count[u][v][k];\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public int MinimumWalk(int[][] graph, int u, int v, int k)\n {\n // Code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"MinimumWalk(self, graph, u, v, 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 graph = []\n for j in range(n):\n a = list(map(int, input().split()))\n graph.append(a)\n u, v, k = input().split()\n u, v, k = int(u), int(v), int(k)\n ob = Solution()\n ans = ob.MinimumWalk(graph, u, v, k)\n print(ans)\n",
"solution": "# Backend complete function Template for python3\n\nclass Solution:\n def MinimumWalk(self, graph, u, v, k):\n V = len(graph)\n mod = 1000000007\n # Table to be filled up using DP.\n # The value count[i][j][e] will/\n # store count of possible walks\n # from i to j with exactly k edges\n count = [[[0 for _ in range(k + 1)]\n for _ in range(V)] for _ in range(V)]\n\n # Loop for number of edges from 0 to k\n for e in range(0, k + 1):\n for i in range(V):\n # For source\n for j in range(V):\n # For destination\n\n # Initialize value\n count[i][j][e] = 0\n\n # From base cases\n if (e == 0 and i == j):\n count[i][j][e] = 1\n if (e == 1 and graph[i][j] != 0):\n count[i][j][e] = 1\n\n # Go to adjacent only when number\n # of edges is more than 1\n if (e > 1):\n for a in range(V):\n # Adjacent of i\n if (graph[i][a] != 0):\n count[i][j][e] = (\n count[i][j][e] % mod + count[a][j][e-1] % mod) % mod\n\n return count[u][v][k]\n",
"updated_at_timestamp": 1727776457,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef MinimumWalk(self, graph, u, v, k):\n\t\t# Code here"
}
|
eJztWs1O4zAQ5rAPYuWMVnaaxAlPgkQRh90e9pLlUCQktNI+BLwMN96MtGmdmfE3SQoCoWBKlNj+4m/m84x/1P7/8fSSne3/Lp+7h6uH7E97e7fNLkzm1m25bq1x3ccau273t11xeLQ9YF/oaw9Yawqzys5Ntrm/3fzabn7f/L3bHjrO123279xwqor0dCTri4EjdB2KfeFQPFoVWkpTKBaskAU1cZZ7FKoGS4hprIpZRE0MVUNFZDex3ZtKsd1bZLwjI2GpwY4W+ZjRaq4rFxv6zNE28qr3jBDIMRMa8MqAbIxXdChhGLmc6sB8jLWIRhU0oCbHdREmoyZLB5k1QY3ihigDZig7oi6NBGdqReKiHAs1Eic8ZYco3Me2iCmQNHIQiKthzpFuDj0KFwdkYI+QdCxCljam0ULN5ooUYYKMIuHYr1CJU7MpK4ZJ+wWACiHvfJYmIpLpWgwLB0qVaQ/kbWS3kuSRaSCx0LQje3A8kaM7ijmRVzKq2Ih1D4WaEk3p6wqFQm65oMgCFtXjUEdNnYSiyRtCaUyMQmNnFChyBr6AnYGxExNBqJwyZsqjuQXkUaFjY61QT0DxTAGgMm9VaJzBDsLBJKX0iqhh35gajnV3a4wrlXSrvV/VTeU9TLkSLRoTF4+uWVdiSSyJJbF8MRZr8qL71/bueWHrovZw30rO9fww3z9atkuefa4vIiq7e0NBS2hHMw+ZTnmRcyGI+Ifa+0WPeaWjun3sOc+6tx30duZ975h7T9DNz+q0n0ssieVDWBblzFJZ3rGh+86LE2/wJy1OJ+2IFrc+1e5zeBJLYpm6FuXMUlnGVyi/qprKuRx+PzKxQvGaoWUwIC1RJxzahcaf9DMAIQGLtQlNVDnc8cw+/juA68efrxXgh/4=
|
702,948
|
Maximum product of two numbers
|
Given an array arr of non-negative integers, return the maximum product of two numbers possible.
Examples:
Input:
arr[] = [1, 4, 3, 6, 7, 0]
Output:
42
Explanation:
6 and 7 have the maximum product.
Input:
arr[] = [1, 100, 42, 4, 23]
Output:
4200
Explanation:
42 and 100
have the maximum product
.
Constraints:
2 ≤ arr.size ≤ 10**7
0 ≤ arr[i] ≤ 10**9
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static int maxProduct(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.maxProduct(arr);\n\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public static int maxProduct(int[] arr) {\n // code here\n int max = 0;\n int secondMax = 0;\n int n = arr.length;\n // iterating over the array.\n for (int i = 0; i < n; i++) {\n // checking if current element is greater than or equal to maximum element.\n if (arr[i] >= max) {\n // updating second maximum as old maximum and maximum as current\n // element.\n secondMax = max;\n max = arr[i];\n }\n // checking if current element is greater than or equal to second maximum\n // element.\n else if (arr[i] >= secondMax) {\n // updating second maximum as current element.\n secondMax = arr[i];\n }\n }\n // returning the product of maximum and second maximum elements.\n return max * secondMax;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "\nclass Solution {\n public static int maxProduct(int[] arr) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"maxProduct(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.maxProduct(arr)\n print(res)\n print(\"~\")\n t -= 1\n",
"solution": "# User function Template for python3\nclass Solution:\n\n def maxProduct(self, arr):\n # code here\n max_val = 0\n second_max = 0\n n = len(arr)\n\n # Iterating over the array.\n for i in range(n):\n # Checking if current element is greater than or equal to maximum element.\n if arr[i] >= max_val:\n # Updating second maximum as old maximum and maximum as current element.\n second_max = max_val\n max_val = arr[i]\n # Checking if current element is greater than or equal to second maximum element.\n elif arr[i] >= second_max:\n # Updating second maximum as current element.\n second_max = arr[i]\n\n # Returning the product of maximum and second maximum elements.\n return max_val * second_max\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n\n\tdef maxProduct(self,arr):\n\t\t# code here"
}
|
eJytVE1LxEAM9SD4N0LPiySZz/pLhF0R1B681D3sgiCKP0L/r2PZZLQ0tGIfPYQhTSbvvcn7+efdxdmA620Jti/NY78/HporaGjXtwKQIAOhAAi42UDTPe+7+0P3cPt0PJz+1R81ede/7frmdQO/OwQtJhFpxFBaGA34lESabDQgdj7ElMsIOcXgHRPIWdYztOZIwUfCEDOyo5jYmsMJwAsgCCAKjDYu4fcX28jD56w2dZo6A6o4rVFec4UBsspXbav0VaKiN5QBoQwECQp7/1V/UhwBsACUXYs/bpkyYYwJU6bcOqPhlKElShpFMP0guThnO7RZK0/IEgrnGKtieI2cRlybSmS9HxxjzthGIVPaEQG4jAE3e6HBM4Np/nijQt2ilbYKv9YlJjpSLW/Z4ocvFpATSRdEm+ylENhTTgEdO2T0qywFXGMrzK0z23Iw4Tla8OyCvXBHNvYLbezHQ958XH4BQcLoDw==
|
703,129
|
Number of occurrence
|
Given a sorted array Arrof size N and a number X, you need to find the number of occurrences of X in Arr.
Examples:
Input:
N = 7, X = 2
Arr[] = {1, 1, 2, 2, 2, 2, 3}
Output:
4
Explanation:
x = 2 occurs 4 times in the given array so the output is 4.
Input:
N = 7, X = 4
Arr[] = {1, 1, 2, 2, 2, 2, 3}
Output:
0
Explanation:
X = 4 is not present in the given array so the output is 0.
Constraints:
1 ≤ N ≤ 10**5
1 ≤ Arr[i] ≤ 10**6
1 ≤ X ≤ 10**6
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1729749951,
"func_sign": [
"int countFreq(int[] arr, int target)"
],
"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 br = new BufferedReader(new InputStreamReader(System.in));\n int tc = Integer.parseInt(br.readLine().trim());\n\n while (tc-- > 0) {\n\n String[] str = br.readLine().trim().split(\" \");\n int[] a = new int[str.length];\n for (int i = 0; i < str.length; i++) {\n a[i] = Integer.parseInt(str[i]);\n }\n String[] nk = br.readLine().trim().split(\" \");\n int k = Integer.parseInt(nk[0]);\n Solution sln = new Solution();\n int ans = sln.countFreq(a, k);\n\n System.out.println(ans);\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1731263829,
"user_code": "class Solution {\n int countFreq(int[] arr, int target) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1729749951,
"func_sign": [
"countFreq(self, arr, target)"
],
"initial_code": "# Initial Template for Python 3\nimport bisect\n\n# Main\nif __name__ == '__main__':\n t = int(input())\n\n while t:\n t -= 1\n A = [int(x) for x in input().strip().split()]\n nd = [int(x) for x in input().strip().split()]\n D = nd[0]\n ob = Solution()\n ans = ob.countFreq(A, D)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n\n def countFreq(self, arr, target):\n # Get the index of the first occurrence of x\n low = bisect.bisect_left(arr, target)\n\n # If element is not present, return 0\n if low == len(arr) or arr[low] != target:\n return 0\n\n # Get the index of the last occurrence of x\n high = bisect.bisect_right(arr, target)\n\n # Return the count of occurrences\n return high - low\n",
"updated_at_timestamp": 1731263829,
"user_code": "class Solution:\n def countFreq(self, arr, target):\n #code here"
}
|
eJztmb0KwjAQxx18kJi5SNJ2qU8iGHHQDi6xQwuCKO5uou9rTT8sytGmH5iUS4K/QhFy18vd/dvr9HmfTdRY3tKL1YnuZZTEdEEoF5ITt5yevVNIjzqEhsco3MbhbnNI4tzGwBfyIiQ9O+TLckZwNVtCBoB3GeTcSlhZPFNDAMM5aPgoppCu5hMP1CAIhG0oghc66gzMci3yg/7J+nsy6CulgL6CHczUKC90nZ39iyCRyB/W5D2s9IiRoQjed2MPVaP+ynCXmui7DZTV32V3J8EOGw9qdtaxIRgsspRGNiHGR9UvGuFRK5OVCftH2INczBqxlwzYnKpffFGt+aK6Uj9cI54gYmjwQsmOs2KasQuLoXKoETsZEp/gF/raVi0TrEAgugR/i8+1msIUvpX3aqV8rTmE68f8BQ2fCts=
|
707,621
|
Count the number of subarrays
|
Given an array A[] of Nintegers and a range(L,R).The task is to find the number of subarrays having sum in the range L to R (inclusive).
Examples:
Input:
N = 3, L = 3, R = 8
A[] = {1, 4, 6}
Output:
3
Explanation:
The subarrays are [1,4], [4] and [6]
Input:
N = 4, L = 4, R = 13
A[] = {2, 3, 5, 8}
Output:
6
Explanation:
The subarrays are [2,3], [2,3,5],
[3,5],[5], [5,8] and [8]
Constraints:
1 ≤ N≤10**6
1 ≤ A[]≤ 10**9
1 ≤ L≤ R≤ 10**15
|
geeksforgeeks
|
Hard
|
{
"class_name": "Solution",
"created_at_timestamp": 1621854679,
"func_sign": [
"long countSubarray(int N,int A[],long L,long R)"
],
"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 input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n long L = Long.parseLong(input_line[1]); \n long R = Long.parseLong(input_line[2]); \n input_line = read.readLine().trim().split(\"\\\\s+\");\n int A[]= new int[N];\n for(int i = 0; i < N; i++)\n A[i] = Integer.parseInt(input_line[i]);\n Solution ob = new Solution();\n long ans = ob.countSubarray(N, A, L, R); \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 // Function to find number of subarrays having\n // sum less than or equal to x.\n public long countSub(int arr[], int n, long x) {\n // Starting index of sliding window.\n int st = 0;\n // Ending index of sliding window.\n int end = 0;\n // Sum of elements currently present\n // in sliding window.\n long sum = 0;\n // To store required number of subarrays.\n long cnt = 0;\n // Increment ending index of sliding\n // window one step at a time.\n while (end < n) {\n // Update sum of sliding window on\n // adding a new element.\n sum += (long) arr[end];\n // Increment starting index of sliding\n // window until sum is greater than x.\n while (st <= end && sum > x) {\n sum -= (long) arr[st];\n st++;\n }\n // Update count of number of subarrays.\n cnt += (end - st + 1);\n end++;\n }\n return cnt;\n }\n\n public long countSubarray(int N, int A[], long L, long R) {\n // Number of subarrays having sum less\n // than or equal to R.\n long Rcnt = countSub(A, N, R);\n // Number of subarrays having sum less\n // than or equal to L-1.\n long Lcnt = countSub(A, N, L - 1);\n return Rcnt - Lcnt;\n }\n}\n;\n",
"updated_at_timestamp": 1730267746,
"user_code": "//User function Template for Java\nclass Solution \n{ \n long countSubarray(int N,int A[],long L,long R) {\n // code here\n }\n} "
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1621855035,
"func_sign": [
"countSubarray(self, N, A, L, R)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n N, L, R = map(int, input().strip().split())\n A = list(map(int, input().strip().split()))\n ob = Solution()\n ans = ob.countSubarray(N, A, L, R)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n def countSub(self, arr, n, x):\n st = 0 # Starting index of sliding window.\n end = 0 # Ending index of sliding window.\n sum = 0 # Sum of elements currently present in sliding window.\n cnt = 0 # To store required number of subarrays.\n\n while end < n:\n # Update sum of sliding window on adding a new element.\n sum += arr[end]\n\n # Increment starting index of sliding window until sum is greater than x.\n while st <= end and sum > x:\n sum -= arr[st]\n st += 1\n\n # Update count of number of subarrays.\n cnt += (end - st + 1)\n end += 1\n\n return cnt\n\n def countSubarray(self, N, A, L, R):\n # Number of subarrays having sum less than or equal to R.\n Rcnt = self.countSub(A, N, R)\n\n # Number of subarrays having sum less than or equal to L-1.\n Lcnt = self.countSub(A, N, L - 1)\n\n return Rcnt - Lcnt\n",
"updated_at_timestamp": 1730267746,
"user_code": "#User function Template for python3\nclass Solution:\n def countSubarray(self, N, A, L, R):\n # code here"
}
|
eJzdls+KE0EQxj149CGKOS/S9adnpgXfQ3DEg+bgZdxDFhZE8SH0fe2vasaDbIUEsghJMp0mmXy/6qqvq/Pz5e+3r174493YJ++/DV/W+4fj8IYGXlYuxJW0+KySYKgUn/p7He5oODzeHz4dD58/fn047r+dlvXHsg7f7+gfxfgZFElIybrOSBPN1FyXiYVYia0zEvE6Z+JdoJQeZpcXvGevRFg4Exasvi5rpSefWaAl0Zt7BhDqso4ekZb4gKzQXGjKAmTJV16LS/rSoQixyAe+GTHvDOmX9stqyqinShcybghP9F/QDpkKllCobeH0kmLArYx72TaJDG8JXkoYD84565kVJStyZMdXtK3vBq40y6nVo5ZRvOJZ4d07ZfNP2TxU3Ede+lqj/GMNC0w1bDDXsEKrux1K3T0BzTAGVMMd0A2LQJnd1NBmNzDUGfIMfQaAQWB3W4sYMWDmDvW4PXAwBAwBQ8AQ22suYAgYAoaAIWAIGAKGgCEt1o8BMzAUDPW94Nnx9IChYKjFjsOAGRgKhoKhYCgYCoaCoS1yiwEzMAwMA8PAMN91XgMvgsWOxoAZGAaGgWFgGBgGhoFhLeqWdkJ7chtmt5/u88/Q6NNTBLU5H6DtCr2Arrph+T90g5a2/FPnHnyfn315g7nkHwB2fGaOLOgbrd3E2YmWlu8GMuGt7bJsZP+RLjvfn7OU17wuP+DP7p10ZvP88Ov1HwWruPQ=
|
701,758
|
Most frequent word in an array of strings
|
Given an array arr containing N words consisting of lowercase characters. Your task is to find the most frequent word in the array. If multiple words have same frequency, then print the word whose first occurence occurs last in the array as compared to the other strings with same frequency.
Examples:
Input:
N = 3
arr[] = {geeks,for,geeks}
Output:
geeks
Explanation:
"geeks" comes 2 times.
Input:
N = 2
arr[] = {hello,world}
Output:
world
Explanation:
"hello" and "world" both
have 1 frequency. We print world as
its first occurence comes last in the
input array.
Expected Time Complexity:
O(N * WORD_LEN).
Expected Auxiliary Space:
O(N * WORD_LEN).
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public String mostFrequentWord(String arr[],int n)"
],
"initial_code": "//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\nclass GFG {\n\tpublic static void main(String[] args) throws IOException{\n\t\tScanner sc=new Scanner(System.in);\n\t\t\n\t\tint t=sc.nextInt();\n\t\twhile(t-->0)\n\t\t{\n\t\t int n=sc.nextInt();\n\t\t sc.nextLine();\n\t\t Solution obj = new Solution();\n\t\t String arr[]=sc.nextLine().split(\" \");\n\t\t System.out.println(obj.mostFrequentWord(arr, n));\n\t\t \n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n}\n//Position this line where user code will be pasted.",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\n\nclass trie_element {\n \n public trie_element nxt[];\n public int count;\n public int first_appearance;\n\n public trie_element() {\n count = 0;\n nxt=new trie_element[26];\n for (int i = 0; i < 26; i++)\n nxt[i] = null;\n }\n}\n\nclass Solution\n{\n //Function to find most frequent word in an array of strings.\n public String mostFrequentWord(String arr[],int n)\n {\n String ret=\"\";\n int max_count=0;\n int ret_first_appearance=0;\n trie_element trie=new trie_element();\n \n for(int i=0;i<n;i++)\n {\n trie_element temp=trie;\n for(int j=0;j<arr[i].length();j++)\n {\n int index=arr[i].charAt(j)-'a';\n if(temp.nxt[index]==null)\n temp.nxt[index]=new trie_element();\n temp=temp.nxt[index];\n }\n \n //storing the count and first appearance of current word.\n temp.count++;\n \n if(temp.count==1)\n temp.first_appearance=i;\n \n //updating the maximum count if required and if they have\n //same frequency, then storing the word whose first \n //occurrence occurs last in the array.\n if(temp.count>max_count||(temp.count==max_count&&\n temp.first_appearance>ret_first_appearance))\n {\n ret=arr[i];\n max_count=temp.count;\n ret_first_appearance=temp.first_appearance;\n }\n }\n //returning the most frequent word.\n return ret;\n }\n\n}",
"updated_at_timestamp": 1730271504,
"user_code": "//User function Template for Java\nclass Solution\n{\n //Function to find most frequent word in an array of strings.\n public String mostFrequentWord(String arr[],int n)\n {\n // code here\n }\n\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"mostFrequentWord(self,arr,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 arr = [x for x in input().strip().split()]\n obj = Solution()\n print(obj.mostFrequentWord(arr, n))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass TrieElement:\n def __init__(self):\n self.nxt = [None for _ in range(26)]\n self.count = 0\n self.first_appearance = 0\n\n\nclass Solution:\n\n # Function to find most frequent word in an array of strings.\n def mostFrequentWord(self, arr, n):\n trie = TrieElement()\n max_count = 0\n the_word = ''\n the_word_first_app = 0\n\n for i in range(n):\n word = arr[i]\n\n temp = trie\n for c in word:\n index = ord(c) - ord('a')\n if temp.nxt[index] is None:\n temp.nxt[index] = TrieElement()\n temp = temp.nxt[index]\n\n # storing the count and first appearance of current word.\n temp.count += 1\n if temp.count == 1:\n temp.first_appearance = i\n\n # updating the maximum count if required and if they have\n # same frequency, then storing the word whose first\n # occurrence occurs last in the array.\n if temp.count > max_count or (temp.count == max_count and\n temp.first_appearance > the_word_first_app):\n max_count = temp.count\n the_word = word\n the_word_first_app = temp.first_appearance\n\n # returning the most frequent word.\n return the_word\n",
"updated_at_timestamp": 1730271504,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to find most frequent word in an array of strings.\n def mostFrequentWord(self,arr,n):\n # code here\n"
}
|
eJzVVNtOg0AQ9cHE35jw3BhbY0x88s1fMHGNWWDdonR2hcUiRuNH6P86UNoAYVrE+iCQvZ25MHtO5uPw6+rooHquL2lx8+pFaDPnXYA3FXgmUIIPAYSgBHoT8FRuVeBUeGcyV9sR8k7g2wTazufkbG2swJdIL6w2OpF2c2QSiVqtEDZ+jfbmmJ4IDI2GQDpYmCxV1ap9Uu42KzZLhfXmmFEOlygF5TCvAvVsnbGtmYH3fMyW07DoLep0TU5jHMXArJSI5F0ZN1JWrYEtExt1DXOhc3iBAnIo2AjFFkFJnwSv7kHPI3h4jGGBBuxTAqnL4HlJsQsgE77kEusPLjCNUMdqaZKQ9W+a7EGQ/0WRDUXwkhijh8at44BrR/beO/QVQxvkTkI7nfJvWmX9qyObebf2X1RLnxB6CCVds930RiEOILiy+gnFQ0u9/Tz+BvtokXg=
|
705,726
|
Techfest and the Queue
|
A Techfest is underway, and each participant is given a ticket with a unique number. Organizers decide to award prize points to everyone who has a ticket ID between a and b (inclusive). The points given to a participant with ticket number x will be the sum of powers of the prime factors of x.
Examples:
Input:
a = 9
b = 12
Output:
8
Explanation:
For 9, prime factorization is:3
**2
So, sum of the powers of primes is: 2
For 10, prime factorization is : 2
**1
x5
**1
So, sum of the powers of primes is: 2
For 11, prime factorization is : 11
**1
So, sum of the powers of primes is: 1
For 12, prime factorization is : 2
**2
x 3
**1
So, sum of powers of primes is: 3
Therefore the total sum is 2+2+1+3=8.
Input:
a = 24, b = 27
Output:
11
Explanation:
For 24, prime factorization is: 2
**3
x3
**1
So, sum of the powers of primes is: 4
For 25, prime factorization is : 5
**2
So, sum of the powers of primes is: 2
For 26, prime factorization is : 13
**1
x2
**1
So, sum of the powers of primes is: 2
For 27, prime factorization is : 3
**3
So, sum of powers of primes is: 3
Therefore the total sum is 4+2+2+3=11.
Constraints:
1 <= a <= b <= 2x10**5
1 <= b-a <= 10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1703587839,
"func_sign": [
"public static long sumOfPowers(long a, long b)"
],
"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 long a;\n a = Long.parseLong(br.readLine().trim());\n \n \n long b;\n b = Long.parseLong(br.readLine().trim());\n \n Solution obj = new Solution();\n long res = obj.sumOfPowers(a, b);\n \n System.out.println(res);\n \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 sumOfPowers(long a, long b) {\n // code here\n }\n}\n \n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1703239517,
"func_sign": [
"sumOfPowers(self, a : int, b : int) -> int"
],
"initial_code": "class 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 a = int(input())\n b = int(input())\n\n # Note: obj = Solution() should be obj = IntArray()\n # assuming Solution class is not defined elsewhere\n obj = IntArray()\n # Note: obj.sumOfPowers(a, b) method is not defined in the given code\n # please define the method or correct the method name\n # res = obj.sumOfPowers(a, b)\n\n # print(res)\n # print(\"~\")\n",
"solution": "from typing import List\n\n\nclass Solution:\n def sumOfPowers(self, a: int, b: int) -> int:\n\n # Calculating smallest prime factors (spf) for every number from 1 to b\n spf = [i for i in range(b+1)]\n for i in range(2, b+1):\n if spf[i] == i:\n for j in range(i*i, b+1, i):\n if spf[j] == j:\n spf[j] = i\n\n # Counting all prime factors of each number from a to b\n ans = 0\n for i in range(a, b+1):\n cnt = 0\n while i > 1:\n cnt += 1\n i //= spf[i]\n\n ans += cnt\n\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "\nfrom typing import List\nclass Solution:\n def sumOfPowers(self, a : int, b : int) -> int:\n # code here\n \n"
}
|
eJxrYJkqzcoABhEiQEZ0tVJmXkFpiZKVgpJhTB4IKekoKKVWFKQml6SmxOeXlkBllWp1FFAVGwER0YoNSVEMNNmYeJMNQJgks0EaDMDaDIj3riUIQHSC9UL5RmA+Ca6FaCdRG9AqqINhlpNjiqEpVDuQBgebuSmED6RJCEJkPxA0lTRPQtMgIqAtyQ9pQi6jLOGQkFHgiRRMkhLQyBpJ0gnKm6TnDbypjNRMDELERip5ngRHL6GciTX68aX22Cl6ACWzfWA=
|
703,286
|
Last duplicate element in a sorted array
|
You are given a sorted array arr[] that may contain duplicate elements. Your task is to find the index of the last occurrence of any duplicate element and return the index along with the value of that element. If no duplicate element is found, return [-1, -1].
Examples:
Input:
arr[] = [1, 5, 5, 6, 6, 7]
Output:
[4, 6]
Explanation:
Last duplicate element is 6 having index 4.
Input:
arr[] = [1, 2, 3, 4, 5]
Output:
[-1, -1]
Explanation:
No duplicate elements are present in the array.
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ 10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int[] dupLastIndex(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 Solution ob =\n new Solution(); // Instantiate the Solution object once, not in the loop\n\n while (t-- > 0) {\n String line = scanner.nextLine();\n String[] elements = line.split(\" \");\n int[] arr = new int[elements.length];\n\n for (int i = 0; i < elements.length; i++) {\n arr[i] = Integer.parseInt(elements[i]);\n }\n\n int[] result = ob.dupLastIndex(arr);\n System.out.println(result[0] + \" \" + result[1]);\n }\n scanner.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public int[] dupLastIndex(int[] arr) {\n int n = arr.length;\n for (int i = n - 1; i > 0; i--) {\n if (arr[i] == arr[i - 1]) {\n return new int[] {i, arr[i]}; // Return the index and value of the last duplicate\n }\n }\n return new int[] {-1, -1}; // Return -1, -1 if no duplicate is found\n }\n}\n",
"updated_at_timestamp": 1727776457,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int[] dupLastIndex(int[] arr) {\n // Complete the function\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"dupLastIndex(self, arr)"
],
"initial_code": "def 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(*Solution().dupLastIndex(a))\n T -= 1\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n\n def dupLastIndex(self, arr):\n # Iterate from the end of the list\n n = len(arr)\n for i in range(n - 1, 0, -1):\n if arr[i] == arr[i - 1]:\n # Return the index and value of the last duplicate\n return [i, arr[i]]\n return [-1, -1] # If no duplicate is found, return [-1, -1]\n",
"updated_at_timestamp": 1727776457,
"user_code": "#User function Template for python3\n\nclass Solution:\n def dupLastIndex(self, arr):\n # Complete the function\n \n"
}
|
eJyllE1OwzAQhVkgzvHkdYvGTuLEnIMFUotYQBZsQhepVAkhcQi4L/Y4oWniCTS1x0okj58+e34+r783N1c8Hu79z+ZdvTa7favuoPS20dAwyHjmKPy0agVVH3b1c1u/PL3t2865QrFt1McKIwGCN0PI2PLeCoJlK0kQ1GE7KclEkYaJUKKCg5OEDFwaLYDFlQ1WTgEvLkuBkFANliMROQsOc8xxBuZA3XGDH0nStH4vKSkcWGusdZpBOuJ3hAPjKQg4QYDwa2aSBUUwiUj7PSFoYWD8dTwENdO7iZCWeryTxFiQGucluRysmXsuuuWkkIPSomJOxbO8KKKTMqTjY59ZgVqsQKYewvMDnPYlfwH5Bs67zPejaH/2Iy30o0TYZ8L939S5VOzYv5MN3Im5XXbv9fh1+wPOgpua
|
703,748
|
The AND Gate
|
Given N bits to an AND - Gatefind the output that will be produced.AND - Gate Table:1 & 1 = 11 & 0 = 00 & 1 = 00 & 0 = 0
Examples:
Input:
N = 4
arr: 1 1 1 0
Output:
0
Explanation:
1 & 1 = 1
1 & 1 = 1
1 & 0 = 0
hence output is 0
Input:
N = 4
arr: 0 0 1 0
Output:
0
Explanation:
0 & 0 = 0
0 & 1 = 0
0 & 0 = 0
hence output is 0
Constraints:
1<=N<=1000
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int andGate(int arr[] , int N)"
],
"initial_code": "//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n//Position this line where user code will be pasted.\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 String S[] = read.readLine().trim().split(\" \");\n int arr[] = new int[N];\n for(int i =0;i<N;i++)\n {\n arr[i] = Integer.parseInt(S[i]);\n }\n Solution ob = new Solution();\n System.out.println(ob.andGate(arr,N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n static int andGate(int arr[], int N) {\n for (int i = 0; i < N; i++) {\n // if we find a bit as 0 the resulting\n // answer will always be 0\n if (arr[i] == 0) return 0;\n }\n // if no 0 is present then answer is 1\n return 1;\n }\n}\n",
"updated_at_timestamp": 1730473085,
"user_code": "//User function Template for Java\nclass Solution{\n static int andGate(int arr[] , int N){\n //code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"andGate(self, arr, 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 arr = input().split(' ')\n for itr in range(N):\n arr[itr] = int(arr[itr])\n ob = Solution()\n print(ob.andGate(arr, N))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def andGate(self, arr, N):\n for i in arr:\n # if we find a bit as 0 the resulting\n # answer will always be 0\n if i == 0:\n return 0\n # if no 0 is present then answer is 1\n return 1\n",
"updated_at_timestamp": 1730473085,
"user_code": "#User function Template for python3\nclass Solution:\n def andGate (self, arr, N):\n # code here"
}
|
eJxrYJl6kZUBDCJOARnR1UqZeQWlJUpWCkqGMXmmMXmGChBooKSjoJRaUZCaXJKaEp9fWgJVZRCTVxeTp1Sro4Cq1Qyk1QCq2ZBEzYYGCIuRIA5TDHGYYhyTZwB0Aqkut4DYDXO7AWmux2UbsZ4k1bWGyHGEGWQkB72RAUrEKeAxm1STTbFGKj63k55woNYgrMId0DiDGld6QhgOBKQmRtJcRrU8gGwtuVrRCgIKTAInLTp53oD4nIiZ40nKhQqUepGc4CSgJ3aKHgD40KAF
|
704,773
|
Yes XOR No
|
You are given two arrays A[] and B[], each of size N, where each elementAiand Bjaredistinct. Let's consider an integerX is the countof all different pairs of Aiand Bj, such that AiXORBjis present in any of the two arrays. Return "Yes"(case-sensitive)ifX is even, else return"No".
Examples:
Input:
N =
3
A[] =
{1, 5, 7}
B[] =
{2, 4, 8}
Output:
Yes
Explanation:
XOR(1,2)=3
XOR(1,4) = 5 is present in
A[]
XOR(1,8) = 9
XOR(5,2) = 7 is present in
A[]
XOR(5,4) = 1 is present in
A[]
XOR(5,8) = 13
XOR(7,2) = 5 is present in
A[]
XOR(7,4) = 3
XOR(7,8)=15
Out of all these XOR operations,
5,7,1,5 are present, so count of X = 4
which is even. Hence the output is "Yes"
.
Input:
N =
2
A[] =
{1, 5}
B[] =
{2, 4}
Output:
Yes
Explanation:
XOR(1,2) = 3
XOR(1,4) = 5 is present in A[]
XOR(5,2)=7
XOR(5,4)=1 is present in A[]
Out of all these XOR operations,
1,5 are present,
So count of X = 2 which is even.
Hence the output is "Yes"
.
Constraints:
1 <= N <= 10**5
1 <= A[i],B[i] <= 10**9
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static String yesXorNo(int N, Long[] A, Long[] B)"
],
"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 String S1[] = read.readLine().split(\" \");\n \n Long[] A = new Long[N];\n Long[] B = new Long[N];\n \n for(int i=0; i<N; i++)\n {\n A[i] = Long.parseLong(S[i]);\n B[i] = Long.parseLong(S1[i]);\n }\n\n Solution ob = new Solution();\n System.out.println(ob.yesXorNo(N,A,B));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n static String yesXorNo(int N, Long[] A, Long[] B) {\n // The method is named \"yesXorNo\" but it doesn't use any XOR operation.\n // It seems to be incomplete as it always returns \"Yes\" without performing any computations.\n return \"Yes\";\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution {\n static String yesXorNo(int N, Long[] A, Long[] B) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"yesXorNo(self, N, 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 B = list(map(int, input().split()))\n\n ob = Solution()\n print(ob.yesXorNo(N, A, B))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to check if A XOR B is \"Yes\" or \"No\".\n def yesXorNo(self, N, A, B):\n # returning \"Yes\" as the XOR operation always returns 1\n # if the corresponding bits are different.\n return \"Yes\"\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def yesXorNo(self, N, A, B):\n # code here"
}
|
eJy9VdtKxDAQ7YOsv3HI8yKZ3Nr6JYoVH7QPvsSF7YIgih+h36uT2B12XRRNy6ahPZDMmemZmeT15H1xWuVx8bGoqqsndR9Xm0GdQ1EXZaolVP+46m+H/u7mYTOMWy77dRdfePl5iX1Lw2bgl4UrsLbZGvxx8AgFDG5kSO6ZATWaAhYvLGCYWdCCdAFVMiK9HWi3Q1AjqBYUBHlBTpAVZATRTsSYHjATeSZhCgJZkAfVoJbzyw4Ck5MGGZADBVADU+SpiyJHWbV9xXrwpAX8POcXRScNkhIuq6JZoMBCmWkNNDZEcnAEZZLPQnWS6X6dF/62zQ1cdnbsTmZrjqFjKoSZa+yXlM2asz/JRVF2fT/b53JpJ6fIZMKDq+Mf19D129kn9SACpw==
|
703,544
|
Shop in Candy Store
|
In a candy store, there are n different types of candies available and the prices of all the N different types of candies are provided to you. You are now provided with an attractive offer.For every candy you buy from the store and get K other candies ( all are different types ) for free. Now you have to answer two questions. Firstly, you have to find what is the minimum amount of money you have to spend to buy all the n different candies. Secondly, you have to find what is the maximum amount of money you have to spend to buy all the n different candies.In both the cases you must utilize the offer i.e. you buy one candy and get k other candies for free.
Examples:
Input:
n = 4, k = 2, candies[] = {3 2 1 4}
Output:
3 7
Explanation:
As according to the offer if you buy one candy you can take at most two more for free. So in the first case, you buy the candy which costs 1 and takes candies worth 3 and 4 for free, also you buy candy worth 2 as well.So
min cost
:1+2 =3. In the second case, you can buy the candy which costs 4 and takes candies worth 1 and 2 for free, also you need to buy candy worth 3 as well. So
max cost :
3+4 =7.
Input:
n = 5, k = 4,
candies[] = {3 2 1 4 5}
Output:
1 5
Explanation:
For minimimum cost buy the candy with the cost 1 and get all the other candies for free. For maximum cost buy the candy with the cost 5 and get all other candies for free.
Constraints:
1 <=
n
<= 100000
0 <=
k
<= N-1
1 <=
candies[i]
<= 10000
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static ArrayList<Integer> candyStore(int candies[],int N,int K)"
],
"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 input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int N = Integer.parseInt(input_line[0]);\n int K = Integer.parseInt(input_line[1]);\n input_line = read.readLine().trim().split(\"\\\\s+\");\n int candies[]= new int[N];\n for(int i = 0; i < N; i++)\n candies[i] = Integer.parseInt(input_line[i]);\n\n Solution ob = new Solution();\n ArrayList<Integer> cost = ob.candyStore(candies,N,K);\n System.out.println(cost.get(0)+\" \"+cost.get(1));\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution{\n\tstatic ArrayList<Integer> candyStore(int candies[],int N,int K){\n Arrays.sort(candies); // Sort the array of candies in ascending order.\n\n // Calculate the number of groups.\n int groups = N / (K + 1);\n \n // If there are remaining candies that cannot be evenly divided into groups,\n // add one more group.\n if (N % (K + 1) != 0)\n {\n groups += 1;\n }\n\n int minCost = 0;\n for (int i = 0; i < groups; ++i)\n {\n minCost += candies[i]; // Calculate the minimum cost by summing up the candies from the beginning.\n }\n\n int maxCost = 0;\n for (int i = N - 1; i >= (N - groups); --i)\n {\n maxCost += candies[i]; // Calculate the maximum cost by summing up the candies from the end.\n }\n ArrayList<Integer> arr = new ArrayList<>();\n arr.add(minCost); // Add the minimum cost to the array list.\n arr.add(maxCost); // Add the maximum cost to the array list.\n return arr;\n \n }\n\n}",
"updated_at_timestamp": 1730273114,
"user_code": "//User function Template for Java\nclass Solution{\n static ArrayList<Integer> candyStore(int candies[],int N,int K){\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"candyStore(self, candies,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 = [int(x) for x in input().split()]\n candies = [int(x) for x in input().split()]\n\n solObj = Solution()\n print(*solObj.candyStore(candies, N, K))\n print(\"~\")\n",
"solution": "class Solution:\n def candyStore(self, candies, N, K):\n s = 0 # initialize variable 's' to keep track of the sum of candies bought by the customer\n t = 0 # initialize variable 't' to keep track of the sum of candies bought by the retailer\n candies.sort() # sort the list of candies in ascending order\n l = len(candies) # get the length of the list of candies\n i = 0 # initialize variable 'i' to keep track of the index while iterating through the candies list\n\n # loop to calculate the sum of candies bought by the customer\n while i <= l - 1:\n s = s + candies[i] # add the current candy to 's'\n l = l - K # reduce the remaining number of candies after buying 'K' candies\n i = i + 1 # increment the index to move to the next candy\n\n ind = 0 # initialize variable 'ind' to keep track of the index while iterating through the candies list\n l = len(candies) # get the length of the list of candies\n i = l - 1 # set the index to the last candy in the list\n\n # loop to calculate the sum of candies bought by the retailer\n while i >= ind:\n t = t + candies[i] # add the current candy to 't'\n ind = ind + K # increase the index by 'K' to skip candies that the customer bought\n i = i - 1 # decrement the index to move to the previous candy\n\n # return the sums of candies bought by the customer and the retailer as a list\n return [s, t]\n",
"updated_at_timestamp": 1730273114,
"user_code": "#User function Template for python3\n\nclass Solution:\n\n def candyStore(self, candies,N,K):\n # code here"
}
|
eJy1VMtOAzEM5ID4jtGeKxTnsdnwJUgs4gA9cAk9tBISAvER8Cnc+DjsbCtabRxRED1EWzkeezzjvJ6+f56dlN/lB39cPXX3ebVZdxfoaMxkkKYTAyJ6BHg4WHCsW6BbPq6Wt+vl3c3DZr3LApkxv3D8eYEZ2sAnpzuGCQwXGTaVBAXNgVINzY25hy2Q1sAZeINg0DNSkOb4MKAgQRvGHMEJ5AoFzzVdgwCD0ZaCmxD5y8NSrQ9uISHIMZsPEfoxWy7FfyXqGGSAtXyJmHQJ67RjKSe3rFJ4gC9EmWWA48oBgYcaELkhKWrqw5bSZNXaPDLyW/6wTtMyTPiGvcGyGkSZlWjgix6CYnDQnW4ZGYhmGgESDyYZIkVQL5jkQdNkxW9ze0K3lFEsJaQkrWltrckieHsrlFRXbMw964oQqhbQKc4v/vAm/salpE5r2QKwdT7Hip3aKiety9ajlsteVRfLN9ZKUFv61Z/EvWn/atz/RyQd/7jvpMO3dgfi7etmdUPSFK64XXXw9dv5F0nY1Ag=
|
704,100
|
Coin Change (Count Ways)
|
Given an integerarray coins[ ] of size Nrepresenting different denominations of currency and an integer sum, find the number of ways you can make sum by using different combinations from coins[ ]. Note: Assume that you have an infinite supply of each type of coin. And you can use any coin as many times as you want.
Examples:
Input:
N = 3, sum = 4
coins = {1,2,3}
Output:
4
Explanation:
Four Possible ways are: {1,1,1,1},{1,1,2},{2,2},{1,3}.
Input:
N = 4, Sum = 10
coins = {2,5,3,6}
Output:
5
Explanation:
Five Possible ways are: {2,2,2,2,2}, {2,2,3,3}, {2,2,6}, {2,3,5} and {5,5}.
Constraints:
1 <= sum, N, coins[i] <= 10**3
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1731139025,
"func_sign": [
"public int count(int coins[], int sum)"
],
"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 = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n\n while (t-- > 0) {\n String inputLine[] = read.readLine().trim().split(\" \");\n int n = inputLine.length;\n int arr[] = new int[n];\n\n for (int i = 0; i < n; i++) {\n arr[i] = Integer.parseInt(inputLine[i]);\n }\n int sum = Integer.parseInt(read.readLine());\n Solution ob = new Solution();\n System.out.println(ob.count(arr, sum));\n }\n }\n}\n",
"script_name": "GfG",
"solution": "None",
"updated_at_timestamp": 1731139025,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int count(int coins[], int sum) {\n // code here.\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1731139025,
"func_sign": [
"count(self, coins, Sum)"
],
"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 coins = list(map(int, input().strip().split()))\n sum = int(input())\n ob = Solution()\n print(ob.count(coins, sum))\n",
"solution": "class Solution:\n def count(self, coins, Sum):\n N = len(coins)\n dp=[[0 for _ in range(Sum+1)]for _ in range(N+1)]\n for i in range(N+1):\n dp[i][0]=1\n for i in range(1,N+1):\n for j in range(1,Sum+1):\n if coins[i-1]<=j:\n dp[i][j]=dp[i][j-coins[i-1]]+dp[i-1][j]\n else:\n dp[i][j]=dp[i-1][j]\n return(dp[N][Sum])\n",
"updated_at_timestamp": 1731139025,
"user_code": "#User function Template for python3\n\nclass Solution:\n def count(self, coins, Sum):\n # code here \n"
}
|
eJyVlMFqwzAMhnfogwify7Dkyo72JIO19LDlsEvWQwqDMdhDbI/UWx9qshMoFClbQxx88P/nk34lX6uf8+quXY8n3Tx9hNfhcBzDAwTcDvWOMYY1hP790D+P/cv+7TheDoTPNVxJ9Lw+HUm0JBwjkC6VAuuJwt4baWPpCRIwFEAETIC6kcbhYXeYxUFvHEnXprHUStg16kwajlAYkLh6bYfkyrPJoLWoLTuaZGlE6pJbWz4n5ddHZrN5ak5uYn84TPEl6eWcTWYn5tnJs0pZSpdFSOzMpyJuGvHoDorvUyQRYiY79L9BzI7gcgQm/BwB/+NrQ8dA5/sKGhYH3WSX5am1/y1T78knrqrd9/0vm19jmQ==
|
701,204
|
Rotate and delete
|
Given an array arr integers. Assume szto be the initial size of the array. Do the following operations exactly sz/2 times. In everykth (1<= k <= sz/2) operation:
Examples:
Input:
arr =
[1, 2, 3, 4, 5, 6]
Output:
3
Explanation:
Rotate the array clockwise i.e. after rotation the array arr = [6, 1, 2, 3, 4, 5] and delete the last element that is 5 that will be arr = [6, 1, 2, 3, 4]. Again rotate the array for the second time and deletes the second last element that is 2 that will be A = [4, 6, 1, 3], doing similar operation when we perform 4th operation, 4th last element does not exist. Then we deletes 1st element ie 1 that will be arr = [3, 6]. So, continuing this procedure the last element in arr is 2. So, the output will be 3.
Input:
arr =
[1, 2, 3, 4]
Output:
2
Explanation:
Rotate the vector clockwise i.e. after rotation the vector arr = [4, 1, 2, 3] and delete the last element that is 3 that will be arr = [4, 1, 2]. After doing all the operations, the output will be 2.
Constraints:
1 <= arr.size() <= 10**3
1 <= arr[i] <= 10**6
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static int rotateDelete(ArrayList<Integer> 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> arr = new ArrayList<>();\n\n // Parse the tokens into integers and add to the array\n for (String token : tokens) {\n arr.add(Integer.parseInt(token));\n }\n\n Solution obj = new Solution();\n int res = obj.rotateDelete(arr);\n\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public static int rotateDelete(ArrayList<Integer> arr) {\n // code here\n int i = 1;\n int n = arr.size();\n while (i < (n / 2) + 1) {\n Collections.rotate(arr, 1); // Rotate the array to the right by 1\n arr.remove(arr.size() - i); // Remove the element at position (size - i)\n i++;\n }\n return arr.get(0);\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "\nclass Solution {\n public static int rotateDelete(ArrayList<Integer> arr) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1713200839,
"func_sign": [
"rotateDelete(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n\n while t > 0:\n arr = list(map(int, input().split()))\n ob = Solution()\n res = ob.rotateDelete(arr)\n print(res)\n print(\"~\")\n t -= 1\n",
"solution": "class Solution:\n\n def rotateDelete(self, arr):\n i = 1\n n = len(arr)\n while i < (n / 2) + 1:\n arr.insert(0, arr.pop()) # Rotate the array\n arr.pop(-i) # Delete the element\n i += 1\n\n return arr[0]\n",
"updated_at_timestamp": 1729753320,
"user_code": "\n# from typing import List\nclass Solution:\n def rotateDelete(self, arr):\n # code here\n \n"
}
|
eJzNlk1uE0EQhVmw4xJPs47Q9E/9NCdBwogFeMHGZOFIkRCIQ8A12bGnpp8tCErbcRRb1KimLbvnq3rV3TX+9vzHrxfPur3+GR/efJ4+bq5vttMrTGm1ad3g3WDdoN0g3VC7oXRD7obUDSmXKjpdYVrfXq/fb9cf3n262e7wxKw2X1eb6csV7gaWGZIgGVIgNWJBIqJBHNKgMzRBM7RAK1QiJ2hk5tAGm2EJlmEFVmEC08gdFgpCywxP8Awv8AoXuMItNMIb2oyW0DJaQatogqZohuaIOqR5Homp9wnJq01CCEAAsNSjIAmSITXkhBz1EmRDbjFxji/CS3gNl3ANt3APb+ERP27LzLRMTcvctExOMXuQWUo9s0ANSh3QxbBb68giUo6SI4oGXxKfe+65p1+7Au0ivOuYu5Tc1dQuSLsmD1mhBiU0BbKgxC4RFEUxFEdpoRM11GbUiFhRYzcpqqE6aosKjCTlkRQMq3BE/KnP7YvFx0cP89djoc9/PbIoO5H97hyMg3IQDpVD4ZA5JA6kOClOipPipDgpToqT4qQ4KU6KkWKkGClGipFipBgpRoqRYqQoKUqKkqKkKClKipKipCgpSoqQIqQIKUKKkCKkCClCiowWg4UZb+xzX4d38pnb9IG2G73vcOe993yNZl/oGD7h6Tt7P/7Te4833mEvw//bzC6Q2pMudNt3yvFCn7ZqO+CJr6Fdn39oDTwdamxt9D8volv+J/6dD7vm/JBAh+vcznKiLtwD/zrAfBM+6hjvt8Lb7y9/A+myrx0=
|
703,036
|
Smallest sub-array with all occurences of most frequent element
|
Given an array arr[]. Let x be an element in the array with the maximum frequency. The task is to find the smallest sub-segment of the array with x as the maximum frequency element.
Examples:
Input:
arr[] = [1, 2, 2, 3, 1]
Output:
[2, 2]
Explanation:
Note that there are two elements that appear two times, 1 and 2.The smallest window for 1 is whole array and smallest window for 2 is {2, 2}. Since window for 2 is smaller, this is our output.
Input:
arr[] = [1, 4, 3, 3, 5, 5]
Output:
[3, 3]
Explanation:
Note that there are two elements that appear two times,
3 and 5. {3,3} appears first in the array.
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ 10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1618078978,
"func_sign": [
"ArrayList<Integer> smallestSubsegment(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 ArrayList<Integer> ans = obj.smallestSubsegment(arr);\n\n // Output the result\n for (int num : ans) {\n System.out.print(num + \" \");\n }\n System.out.println();\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n // Function to find the smallest subsegment of array with the maximum frequency of\n // elements\n ArrayList<Integer> smallestSubsegment(int arr[]) {\n // To store the leftmost index of each element\n HashMap<Integer, Integer> left = new HashMap<>();\n // To store the count of each element\n HashMap<Integer, Integer> count = new HashMap<>();\n // To store the maximum frequency\n int mx = 0;\n // To store the length of the smallest subsegment\n int mn = Integer.MAX_VALUE;\n // To store the starting index of the smallest subsegment\n int strindex = 0;\n // Loop through the array\n for (int i = 0; i < arr.length; i++) {\n int x = arr[i];\n // If element is encountered for the first time, store its leftmost index\n if (!count.containsKey(x)) {\n // Store the leftmost index\n left.put(x, i);\n // Initialize count of the element to 1\n count.put(x, 1);\n } else {\n // Increment the count of the element\n count.put(x, count.get(x) + 1);\n }\n // Check for the maximum frequency and the smallest subsegment\n if (count.get(x) > mx) {\n // Update maximum frequency\n mx = count.get(x);\n // Calculate length of the subsegment\n mn = i - left.get(x) + 1;\n // Store the starting index of the subsegment\n strindex = left.get(x);\n } else if (count.get(x) == mx && i - left.get(x) + 1 < mn) {\n // Update length if it's smaller than current minimum\n mn = i - left.get(x) + 1;\n strindex = left.get(x);\n }\n }\n // Create the result array to store the smallest subsegment\n ArrayList<Integer> result = new ArrayList<>();\n for (int i = strindex; i < strindex + mn; i++) {\n // Add elements of the subsegment to the result\n result.add(arr[i]);\n }\n return result; // Return the smallest subsegment\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\nclass Solution {\n\n ArrayList<Integer> smallestSubsegment(int arr[]) {\n // Complete the function\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1618078978,
"func_sign": [
"smallestSubsegment(self, arr)"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input()) # Number of test cases\n while t > 0:\n arr = list(map(int, input().split()))\n ob = Solution()\n res = ob.smallestSubsegment(arr)\n\n for num in res:\n print(num, end=\" \")\n print()\n\n t -= 1\n print(\"~\")\n",
"solution": "class Solution:\n # Function to find the smallest subsegment with the maximum frequency\n def smallestSubsegment(self, arr):\n left = {} # Dictionary to store the leftmost index of each element\n count = {} # Dictionary to store the count of each element\n max_freq = 0 # To store the maximum frequency\n min_length = float('inf')\n start_index = 0\n\n # Traverse the array to populate `left` and `count` dictionaries\n for i, val in enumerate(arr):\n if val not in count:\n left[val] = i # Store the first occurrence (leftmost index)\n count[val] = 1 # Initialize count\n else:\n count[val] += 1 # Increment the count of the element\n\n # Check if we need to update the max frequency or subsegment length\n if count[val] > max_freq:\n max_freq = count[val]\n min_length = i - left[val] + 1\n start_index = left[val]\n elif count[val] == max_freq:\n # If the frequency is the same, check for the smaller subsegment\n if i - left[val] + 1 < min_length:\n min_length = i - left[val] + 1\n start_index = left[val]\n\n # Collect the result subsegment\n return arr[start_index:start_index + min_length]\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def smallestSubsegment (self, arr) : \n #Complete the function\n"
}
|
eJy1Vs1OhDAQ9uDJp5hw3hiGlrb4JCZiPCgHL7iH3cTEaHwIfR1vvpfTAVxAZ7flp99MyrbMx9eh0+X9/PP74ozb9Rdd3Lwkj/V2v0uuIMGyVqBAE3KGIViGa5BsIKmet9X9rnq4e9rv2sB2Fsr6rayT1w0MSREyps2ZzkEBmAIiYAaoADVgDmgALaADLCBLIaPZPoQHL8AsiS6gQbMy+wvD8NnRDEUSPI7JPERLGUpJGLki1+Q5OfZc9Vz3PD+4lKETzKIgn8mMTbFptpzNsFk2x1aw9YmbkWaW7xQESpFReyliMHYzxVEfecG+QdcX3Aad67r/7mkn7aAzUkoD6ASd/TWFXRMEGZO4JGGWi64pN4SYXwyxMGexymeHGwWEj4wQJHwy++wFrKI7Wu7M43Pdo/PvAenrTH6oj55SnTOK8UTthaYXzfoJFskCZKvQbcFHppcTrHxMHb03dNpFZ9P3x+DrbbnPt+FiScDE/4nlyrJVevtx+QPz7mtM
|
704,103
|
Sequence of Sequence
|
Given two integers m and n, try making a special sequence of numbers seq of length n such that
Examples:
Input:
m = 10
n = 4
Output:
4
Explanation:
There should be n elements and
value of last element should be at-most m.
The sequences are {1, 2, 4, 8}, {1, 2, 4, 9},
{1, 2, 4, 10}, {1, 2, 5, 10}.
Input:
m = 5
n = 2
Output:
6
Explanation:
The sequences are {1, 2},
{1, 3}, {1, 4}, {1, 5}, {2, 4}, {2, 5}.
Constraints:
1 ≤ m, n ≤ 100
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int numberSequence(int m, int n)"
],
"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 input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int m = Integer.parseInt(input_line[0]);\n int n = Integer.parseInt(input_line[1]);\n \n Solution ob = new Solution();\n System.out.println(ob.numberSequence(m, n));\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 int numberSequence(int m, int n)\n {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"numberSequence(self, m, n)"
],
"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 m = int(arr[0])\n n = int(arr[1])\n\n ob = Solution()\n print(ob.numberSequence(m, n))\n print(\"~\")\n",
"solution": "class Solution:\n def numberSequence(self, m, n):\n if m < n:\n return 0\n if n == 0:\n return 1\n return self.numberSequence(m - 1, n) + self.numberSequence(m // 2, n - 1)\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def numberSequence(self, m, n):\n # code here"
}
|
eJxrYJmaz8IABhEZQEZ0tVJmXkFpiZKVgpJhTJ6hgYGCoZKOglJqRUFqcklqSnx+aQlM2sAgJq8uJk+pVkcBTZcCUA6HLpx6QDaRrMvUQMGUVD2WlgpGOLQYmZji0mWkYGlJhpdI1gR0HTmBB9REqh7cEYvPFgMy45eMiAIGOcQyIEFWKJIRYwgfIhxgADaQzFghL+UoGJBnHcLnBGw2JCbQSQ11SIIH20xAZ+wUPQCtwVp7
|
709,949
|
Maximum product subset of an array
|
Given an array arr. The task is to find and return the maximum product possible with the subset of elements present in the array.
Examples:
Input:
arr[] = [-1, 0, -2, 4, 3]
Output:
24
Explanation:
Maximum product will be ( -1 * -2 * 4 * 3 ) = 24
Input:
arr[] = [-1, 0]
Output:
0
Explanation:
Maximum product will be ( -1 * 0) = 0
Input:
arr[] = [5]
Output:
5
Explanation:
Maximum product will be 5.
Constraints:
1 <= arr.size() <= 2 * 10**4
-10 <= arr[i] <= 10
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1720001770,
"func_sign": [
"public long findMaxProduct(List<Integer> 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 tc = sc.nextInt();\n\n while (tc-- > 0) {\n int n = sc.nextInt();\n List<Integer> list = new ArrayList<>();\n\n for (int i = 0; i < n; i++) list.add(sc.nextInt());\n\n Solution obj = new Solution();\n long ans = obj.findMaxProduct(list);\n\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n public long findMaxProduct(List<Integer> arr) {\n int n = arr.size();\n if (n == 1) {\n // Only 1 element in the array.\n return arr.get(0);\n }\n\n long ans = 1;\n int mod = 1000000007;\n int id = -1;\n int minElement = 0;\n int zeroCount = 0;\n int negCount = 0;\n\n for (int i = 0; i < n; i++) {\n int num = arr.get(i);\n if (num == 0) {\n // Counting number of zeros.\n zeroCount++;\n } else if (num < 0) {\n // Counting number of negative numbers.\n negCount++;\n if (id == -1 || num > minElement) {\n // Storing the index of negative element having least magnitude.\n id = i;\n minElement = num;\n }\n }\n }\n\n if (zeroCount == n) {\n // If there are all zeros.\n return 0;\n }\n\n if (negCount == 1 && zeroCount == n - 1) {\n // If all elements are zero except one negative element, then return 0.\n return 0;\n }\n\n for (int i = 0; i < n; i++) {\n int num = arr.get(i);\n if (num == 0) {\n continue;\n }\n if (negCount % 2 == 1 && i == id) {\n // Removing the negative element having least magnitude.\n continue;\n }\n ans = ((ans * num) % mod + mod) % mod;\n }\n\n return ans;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public long findMaxProduct(List<Integer> arr) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1720003500,
"func_sign": [
"findMaxProduct(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n# Position this line where user code will be pasted.\nif __name__ == \"__main__\":\n import sys\n input = sys.stdin.read\n data = input().split()\n\n index = 0\n t = int(data[index])\n index += 1\n results = []\n\n for _ in range(t):\n n = int(data[index])\n index += 1\n arr = list(map(int, data[index:index + n]))\n index += n\n solution = Solution()\n ans = solution.findMaxProduct(arr)\n results.append(ans)\n results.append(\"~\")\n\n for result in results:\n print(result)\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n\n def findMaxProduct(self, arr):\n n = len(arr)\n if n == 1:\n # Only 1 element in the array.\n return arr[0]\n\n ans = 1\n mod = int(1e9 + 7)\n id = -1\n minElement = 0\n zeroCount = 0\n negCount = 0\n\n for i in range(n):\n if arr[i] == 0:\n # Counting number of zeros.\n zeroCount += 1\n elif arr[i] < 0:\n # Counting number of negative numbers.\n negCount += 1\n if id == -1 or arr[i] > minElement:\n # Storing the index of negative element having least magnitude.\n id = i\n minElement = arr[i]\n\n if zeroCount == n:\n # If there are all zeros.\n return 0\n\n if negCount == 1 and zeroCount == n - 1:\n # If all elements are zero except one negative element, then return 0.\n return 0\n\n for i in range(n):\n if arr[i] == 0:\n continue\n if negCount % 2 == 1 and i == id:\n # Removing the negative element having least magnitude.\n continue\n ans = ((ans * arr[i]) % mod + mod) % mod\n\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def findMaxProduct(self, arr):\n # Write your code here\n \n"
}
|
eJyVVEsKwjAUdNGDPLJuJEk/Vk8iGHGhXbiJLloQRPEQeg53ns8krQWlE9sQaCCdmbw3k9yixyua+LF82sXqzPbmWFdsQUxqo7QRJFhMrDwdy21V7jaHumr3hTZXbdglpm9Qog2X5CdASoDMnZwDKrLfBCrnIWXHICgD0EygY0sPBjC7g8/cSgpqF5BFCjeQvvB9U67wlHhGOfEZFcTnmDDJVVFARu9e4DAAlnrTnQPIvwDSWveZSBe553RHCvrmj62vSUnneDAu9r9eGj4DACAHYxUobHisgrlqqDC0tzzUj97yuofip6coAWrg9ef/7v/6Pn0DnEln9w==
|
701,209
|
Maximum Index
|
Given an array arr of positive integers. The task is to return the maximum of j - i subjected to the constraint of arr[i] < arr[j] and i <j.
Examples:
Input:
arr[] = [1, 10]
Output:
1
Explanation:
arr[0]
<
arr[1] so (j-i) is 1-0 = 1.
Input:
arr[] = [34, 8, 10, 3, 2, 80, 30, 33, 1]
Output:
6
Explanation:
In the given array arr[1] < arr[7] satisfying the required condition(arr[i]
<
arr[j]) thus giving the maximum difference of j - i which is 6(7-1).
Constraints:
1 ≤ arr.size ≤ 10**6
0 ≤ arr[i] ≤ 10**9
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1720036233,
"func_sign": [
"int maxIndexDiff(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 ob = new Solution();\n System.out.println(ob.maxIndexDiff(nums));\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n // Function to find the maximum index difference.\n int maxIndexDiff(int[] arr) {\n int n = arr.length;\n if (n == 1) {\n return 0;\n }\n int maxDiff = -1;\n int[] LMin = new int[n];\n int[] RMax = new int[n];\n\n LMin[0] = arr[0];\n for (int i = 1; i < n; ++i) LMin[i] = Math.min(arr[i], LMin[i - 1]);\n\n RMax[n - 1] = arr[n - 1];\n for (int j = n - 2; j >= 0; --j) RMax[j] = Math.max(arr[j], RMax[j + 1]);\n\n int i = 0, j = 0;\n while (i < n && j < n) {\n if (LMin[i] <= RMax[j]) {\n maxDiff = Math.max(maxDiff, j - i);\n j++;\n } else {\n i++;\n }\n }\n return maxDiff;\n }\n}",
"updated_at_timestamp": 1730270752,
"user_code": "// User function Template for Java\nclass Solution {\n // Function to find the maximum index difference.\n int maxIndexDiff(int[] arr) {\n // Your code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1720053240,
"func_sign": [
"maxIndexDiff(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n\nimport math\n\n\ndef main():\n T = int(input())\n while T > 0:\n arr = [int(x) for x in input().strip().split()]\n ob = Solution()\n print(ob.maxIndexDiff(arr))\n T -= 1\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n def maxIndexDiff(self, arr):\n n = len(arr)\n if n == 1:\n return 0\n maxDiff = -1\n LMin = [0] * n\n RMax = [0] * n\n\n LMin[0] = arr[0]\n for i in range(1, n):\n LMin[i] = min(arr[i], LMin[i - 1])\n\n RMax[n - 1] = arr[n - 1]\n for j in range(n - 2, -1, -1):\n RMax[j] = max(arr[j], RMax[j + 1])\n\n i, j = 0, 0\n while i < n and j < n:\n if LMin[i] <= RMax[j]:\n maxDiff = max(maxDiff, j - i)\n j += 1\n else:\n i += 1\n\n return maxDiff\n",
"updated_at_timestamp": 1730270752,
"user_code": "#User function Template for python3\nclass Solution:\n def maxIndexDiff(self, arr):\n # code here"
}
|
eJytU8EKglAQ7FD/MbyzhM/UtC8JMjqUhy7mQSGIoh/oZv/bpk+iZNXV9iE80JmdGXfv02cxm5S1ftBlc1HHJM0ztYLSUaKVBRWf03ifxYfdKc/MKztKblGirha+v3cgRWg4WMCFBx9LBAihbYYi5ChsQgWE9onFJTa5Cg+NIxVBuutioFoQQQcVH0VdoyMhQ+Y4DNJr8fPzCG0QpjQjDbJy/XY7xC6NgWn8sd7LRreeyg6vyuUYegr7wwqIW5WWxswXTT2R0cy3zzqbDQ/hezZXzfwb8aYNjMu065PYtpi/AHyKjAQ=
|
705,138
|
C++ Matrix Rotation by 180 degree
|
Given a square matrix of size N X N, turn it by 180 degrees in anticlockwise direction without using extra memory.
Examples:
Input:
N = 4,
matrix = {{1, 2, 3, 4},
{5, 6, 7 ,8},
{9, 10, 11, 12},
{13, 14, 15, 16}}
Output:
{{16, 15, 14, 13},
{12, 11, 10, 9},
{8, 7, 6, 5},
{4, 3, 2, 1}}
Input:
N = 2,
matrix =
{{1, 2},
{3, 4}}
Output:
{{4, 3},
{2, 1}}
Expected Time Complexity:
O(N**2
)
Expected Space Complexity:
O(1)
Constraints:
1 ≤ N ≤ 500
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public void rotateMatrix(int[][] mat)"
],
"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 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++) matrix[i][j] = Integer.parseInt(S[j]);\n }\n Solution ob = new Solution();\n ob.rotateMatrix(matrix);\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n System.out.print(matrix[i][j] + \" \");\n }\n System.out.println();\n }\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "// User function Template for Java\nclass Solution {\n public void rotateMatrix(int[][] mat) {\n int n = mat.length;\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][n - j - 1];\n mat[n - i - 1][n - j - 1] = temp;\n }\n }\n if (n % 2 == 1) {\n for (int j = 0; j < n / 2; j++) {\n int temp = mat[n / 2][j];\n mat[n / 2][j] = mat[n / 2][n - j - 1];\n mat[n / 2][n - j - 1] = temp;\n }\n }\n }\n}\n",
"updated_at_timestamp": 1730477579,
"user_code": "// User function Template for Java\n\nclass Solution {\n public void rotateMatrix(int[][] mat) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"rotateMatrix(self, mat)"
],
"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 matrix.append(list(map(int, input().split())))\n ob = Solution()\n ob.rotateMatrix(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": "class Solution:\n\n def rotateMatrix(self, mat):\n n = len(mat)\n for i in range(n // 2):\n for j in range(n):\n temp = mat[i][j]\n mat[i][j] = mat[n - i - 1][n - j - 1]\n matrix[n - i - 1][n - j - 1] = temp\n\n if n % 2 == 1:\n for j in range(n // 2):\n temp = mat[n // 2][j]\n mat[n // 2][j] = mat[n // 2][n - j - 1]\n mat[n // 2][n - j - 1] = temp",
"updated_at_timestamp": 1730477579,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef rotateMatrix(self, mat):\n\t\t# Code here"
}
|
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
|
705,051
|
Recursive sequence
|
A function F is defined as follows F(n)= (1) +(2*3) + (4*5*6) ... upto n terms (look at the examples for better clarity). Given an integer n,determine the F(n).
Examples:
Input:
n = 5
Output:
365527
Explanation:
F(5) = 1 + 2*3 + 4*5*6 + 7*8*9*10 + 11*12*13*14*15 = 365527.
Input:
n = 7
Output:
6997165
Explanation:
F(7) = 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 = 6006997207.
6006997207 % 10
**9
+7 = 6997165
Constraints:
1 ≤ n ≤ 10**3
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static long sequence(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 {\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 \n Solution ob = new Solution();\n System.out.println(ob.sequence(N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "//User function Template for Java\n\nclass Solution {\n static long sequence(int n) {\n long MOD = 1000000007;\n long x = 1, ans = 0;\n\n // Loop through each number in the sequence\n for (int i = 1; i <= n; ++i) {\n long temp = 1;\n\n // Calculate the product of x in each iteration \n for (int j = 1; j <= i; ++j) {\n temp = (temp * x) % MOD;\n ++x;\n }\n\n // Add the product to the sum\n ans = (ans + temp) % MOD;\n }\n\n // Return the sum of the sequence\n return ans;\n }\n}",
"updated_at_timestamp": 1730477124,
"user_code": "//User function Template for Java\n\nclass Solution{\n static long sequence(int n){\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"sequence(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.sequence(N))\n print(\"~\")\n",
"solution": "# Backend complete function Template for python3\n\nclass Solution:\n\n # Function to calculate the sum of the sequence\n def sequence(self, n):\n MOD = 10**9+7\n x, ans = 1, 0\n\n # Loop through each number in the sequence\n for i in range(1, n+1):\n temp = 1\n\n # Calculate the product of x in each iteration\n for j in range(1, i+1):\n temp = (temp*x) % MOD\n x += 1\n\n # Add the product to the sum\n ans = (ans+temp) % MOD\n\n # Return the sum of the sequence\n return ans\n",
"updated_at_timestamp": 1730477124,
"user_code": "#User function Template for python3\n\nclass Solution:\n def sequence(self, n):\n # code here"
}
|
eJylVMFOwzAM5YD4jqlnhGI7dmx+gwuCIA6wA5eywyYhIRAfAf9Lmq6CjSWpWA9R08bP7z2/9uP06+bsJF/XV+nm9rV76lebdXe56Cj2HPsQe3Cx784X3fJltXxYLx/vnzfr6YwwYzryHnsxCyCc71FVTILHvOvezhe/cNNDdgNqGZaJ1AM6yfWMZGJ+22cPDWJvZmWCjsgpukJpIlFhoQHBkOhQcRKKQy0Nix8Wdq4BCI6FAqmNhpGCJ0HNOzN2AGiQdxAcIwQe31WJDCrKHQsVXGO50/vv8Fq2wSzOZlpEEKZgJigFBjbkxyoUkNQlAjomxqPzlMJYEZQj1ErlKKyRqJ2vBmKEItrhPE/yJovmyyzNmvZIHUVvR2HimQCORXGHRvBf73I4R+xJZXOi4pU9iHKJatvEua5KCCYK6huuxOrvZet89cwRQ/npXyYwOz13nxffcbbyYA==
|
700,255
|
Topological sort
|
Given an adjacency list for a Directed Acyclic Graph (DAG) where adj[u] contains a list of all verticesv such that there exists a directed edge u -> v. Return topological sort for the given graph.
Examples:
Input:
adj = [[], [0], [0], [0]]
Output:
1
Explanation:
The output 1 denotes that the order is valid. Few valid Topological orders for the given graph are:
[3, 2, 1, 0]
[1, 2, 3, 0]
[2, 3, 1, 0]
Input:
adj = [[], [3], [3], [], [0,1], [0,2]]
Output:
1
Explanation:
The output 1 denotes that the order is valid. Few valid Topological orders for the graph are:
[4, 5, 0, 1, 2, 3]
[5, 2, 4, 0, 1, 3]
Constraints:
2
≤
V
≤
10**3
1
≤
E
≤
(V * (V - 1)) / 2
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1729069893,
"func_sign": [
"static ArrayList<Integer> topologicalSort(ArrayList<ArrayList<Integer>> adj)"
],
"initial_code": "import 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 ArrayList<ArrayList<Integer>> adj = new ArrayList<>();\n String st[] = read.readLine().trim().split(\"\\\\s+\");\n int edges = Integer.parseInt(st[0]);\n int vertices = Integer.parseInt(st[1]);\n\n for (int i = 0; i < vertices; i++) adj.add(i, new ArrayList<Integer>());\n\n int p = 0;\n for (int i = 1; i <= edges; i++) {\n String s[] = read.readLine().trim().split(\"\\\\s+\");\n int u = Integer.parseInt(s[0]);\n int v = Integer.parseInt(s[1]);\n adj.get(u).add(v);\n }\n\n ArrayList<Integer> res = new Solution().topologicalSort(adj);\n\n if (check(adj, vertices, res) == true)\n System.out.println(\"1\");\n else\n System.out.println(\"0\");\n System.out.println(\"~\");\n }\n }\n\n static boolean check(ArrayList<ArrayList<Integer>> adj, int V,\n ArrayList<Integer> res) {\n\n if (V != res.size()) return false;\n\n int[] map = new int[V];\n for (int i = 0; i < V; i++) {\n map[res.get(i)] = i;\n }\n for (int i = 0; i < V; i++) {\n for (int v : adj.get(i)) {\n if (map[i] > map[v]) return false;\n }\n }\n return true;\n }\n}\n",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1730273883,
"user_code": "class Solution {\n // Function to return list containing vertices in Topological order.\n static ArrayList<Integer> topologicalSort(ArrayList<ArrayList<Integer>> adj) {\n // Your code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1729069893,
"func_sign": [
"topologicalSort(self,adj)"
],
"initial_code": "# Driver Program\n\nimport sys\n\nsys.setrecursionlimit(10**6)\n\n\ndef check(graph, N, res):\n if N != len(res):\n return False\n map = [0] * N\n for i in range(N):\n map[res[i]] = i\n for i in range(N):\n for v in graph[i]:\n if map[i] > map[v]:\n return False\n return True\n\n\nif __name__ == '__main__':\n t = int(input())\n for i in range(t):\n e, N = list(map(int, input().strip().split()))\n adj = [[] for i in range(N)]\n\n for i in range(e):\n u, v = map(int, input().split())\n adj[u].append(v)\n\n ob = Solution()\n res = ob.topologicalSort(adj)\n\n if check(adj, N, res):\n print(1)\n else:\n print(0)\n print(\"~\")\n# Contributed By: Harshit Sidhwa\n",
"solution": "# Back-end Complete function Solution for Python\n\n\nclass Solution:\n\n # A recursive function used by topologicalSort\n def DFSUtil(self, adj, v, visited, stack):\n\n #marking the current vertex as visited.\n visited[v] = True\n\n #traversing over the adjacent vertices.\n for i in adj[v]:\n\n #if any vertex is not visited, we call the function recursively.\n if visited[i] == False:\n self.DFSUtil(adj, i, visited, stack)\n\n #pushing the current vertex into the stack.\n stack.insert(0, v)\n\n #Function to return list containing vertices in Topological order.\n def topologicalSort(self, adj):\n V = len(adj)\n #using boolean array to mark visited nodes and currently\n #marking all the nodes as false.\n visited = [False] * V\n stack = []\n\n #traversing over all the vertices.\n for i in range(V):\n\n #if the current vertex is not visited, we call the topo function.\n if visited[i] == False:\n self.DFSUtil(adj, i, visited, stack)\n\n #returning the stack.\n return stack\n",
"updated_at_timestamp": 1730273883,
"user_code": "class Solution:\n \n #Function to return list containing vertices in Topological order.\n def topologicalSort(self,adj):\n # Code here\n"
}
|
eJy9lEGOwjAMRVmMOIeVNUJOQqFwEiQ8mgXTBRsPiyIhIRCHgFux40LTpKGFER3qIMimkVL7fX9b3n8cz92OP9NTcZlt1IKXq1xNQGniBDQSIxhiA5bYwoB4AIl7GRIPYUQ8gpQ4hTHxGIoQDUWE6oHK1stsnmffXz+rvM64Kx63PbjFeADGRptW0dgQrcELkGOtMyRgTahBksIE6+oU9y3G/3OXdTWJ9B1CuHisHcFUBFthhLX7dj8S7slpqFII0Bgm7yHievzk3U9u/bmm6GCXRLmT3PC/lC00rEUh9tkBR+GESxcIxW4AKSWEuE/MdosWGbFMWQgq5bWewb891u9ocm0/vtD/z0P/F9S+BQE=
|
703,915
|
Palindrome
|
Given an integer, check whether it is a palindrome or not.
Examples:
Input:
n = 555
Output:
Yes
Input:
n = 123
Output:
No
Constraints:
1 <= n <= 1000
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1618912397,
"func_sign": [
"public String is_palindrome(int n)"
],
"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 Solution ob = new Solution();\n String ans = ob.is_palindrome(n);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n\n",
"script_name": "GFG",
"solution": "class Solution {\n public boolean isPalindrome(int n) {\n int original = n;\n int reversed = 0;\n\n // Reverse the digits of the number\n while (n > 0) {\n int last_digit = n % 10;\n reversed = reversed * 10 + last_digit;\n n = n / 10;\n }\n\n // Check if the original number is the same as the reversed number\n return original == reversed;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public String is_palindrome(int n)\n {\n // Code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1618912397,
"func_sign": [
"is_palindrome(self, n)"
],
"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 ob = Solution()\n ans = ob.is_palindrome(n)\n print(ans)\n print(\"~\")\n",
"solution": "# User function Template for python3\n\nclass Solution:\n # Function to check if a number is palindrome or not.\n def is_palindrome(self, n):\n if n < 0:\n return 'No'\n s = str(n)\n rev = s[::-1]\n # checking if the number is equal to its reverse.\n if s == rev:\n return 'Yes'\n else:\n return 'No'\n",
"updated_at_timestamp": 1731580235,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef is_palindrome(self, n):\n\t\t# Code here"
}
|
eJytlMFOhDAQhj0Yn4P0vDGlLUL3ITxrHONBOXiZ3UQ2MdlofAh9F2++mtNBNmBLW7LbUOiBfMz/z898nH/9XJzxuvmmw91ePON214l1ISrAki63JR/4JEuxKkT7um0fu/bpYbPr/l6/bV8AQ7d3QPG2KkZkA1g3NaAqFaDWGtBauwDrEwlRKrppxZXKGdj1BnDYPoQES5ZI9TQWsJFNsjJHytJbk15j6FRV1WIfw4IdhlGpAmflEsL2FMvPOGoqOAzVPYZ9I62zwARGuX46gUqlfQpKU0O0zOC68/2K12kS7Hd0musFqY6ZEHfh4GM8zuF6l4R8GvSwI5qnxGB8Mp85WPZgFIZEKCJ2qGMBUw+9GQbW2Zj9c+d86P9UOzQvs1/pMRfPBZhTJaP/xriRR/w3/uy4/7z8Bd5KLB0=
|
704,744
|
N Digit numbers with digits in increasing order
|
Given an integer n, print all the n digit numbers in increasing order, such that their digits are in strictly increasing order(from left to right).
Examples:
Input:
n = 1
Output:
0 1 2 3 4 5 6 7 8 9
Explanation:
Single digit numbers are considered to be
strictly increasing order.
Input:
n = 2
Output:
12 13 14 15 16 17 18 19 23....79 89
Explanation:
For n = 2, the correct sequence is
12 13 14 15 16 17 18 19 23 and so on
up to 89.
Constraints:
1 <= n <= 9
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static ArrayList<Integer> increasingNumbers(int n)"
],
"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 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.increasingNumbers(n);\n\n IntArray.print(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "// import java.util.ArrayList;\n\nclass Solution {\n public static ArrayList<Integer> increasingNumbers(int n) {\n ArrayList<Integer> ans = new ArrayList<>();\n findStrictlyIncreasingNum(0, \"\", n, ans);\n ArrayList<Integer> ret = new ArrayList<>();\n\n for (int num : ans) {\n if (String.valueOf(num).length() == n) {\n ret.add(num);\n }\n }\n return ret;\n }\n\n private static void findStrictlyIncreasingNum(int start, String out, int n,\n ArrayList<Integer> ans) {\n if (n == 0) {\n ans.add(Integer.parseInt(out));\n return;\n }\n\n for (int i = start; i <= 9; i++) {\n findStrictlyIncreasingNum(i + 1, out + i, n - 1, ans);\n }\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "\nclass Solution {\n public static ArrayList<Integer> increasingNumbers(int n) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"increasingNumbers(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 n = int(input())\n\n obj = Solution()\n res = obj.increasingNumbers(n)\n\n IntArray().Print(res)\n\n print(\"~\")",
"solution": "class Solution:\n\n def findStrictlyIncreasingNum(self, start, out, n, ans):\n if n == 0:\n ans.append(int(out))\n return\n\n for i in range(start, 10):\n self.findStrictlyIncreasingNum(i + 1, out + str(i), n - 1, ans)\n\n def increasingNumbers(self, N):\n ans = []\n self.findStrictlyIncreasingNum(0, \"\", N, ans)\n\n ret = []\n for num in ans:\n if len(str(num)) == N:\n ret.append(num)\n return ret\n",
"updated_at_timestamp": 1729753320,
"user_code": "\nfrom typing import List\nclass Solution:\n def increasingNumbers(self, n : int) -> List[int]:\n # code here\n \n"
}
|
eJztmFFrZFUQhH3wXwhyGfBtEav63DuJv0RwxAfNgy9xH7IgiOKP0P9rVfWZTSKZyUZYlsAsXHLn5Haf6vr6TPruX5//89UXn+Xfd1/q5vvfd7/cvn13t/t22eFwW7s3y+7mt7c3P93d/Pzjr+/ujr9iLeDQteradO11Xem6XlBaL62X1kvrpfXS+tDa0NrQ2tDa0Nqqz6s+r/q86vOm+033m+73+rnXz6vrhcpJ5aRyUjmpnFROKieVk8pJ5aRyUjmpnFROKieVk8pJ5aRyUjmpnKXYUmwpthRbii3FlmJLsaXYUmwpthRbii3FlmKHnht6bui5oeeGnht6bui5oeeGnht6btX6qvVV66vWV62vWt90v+l+0/1e1+H2z8Pt7o83y2P7x2n77b1NtiOwJbAnsCmwK7AtsC+wMbAzsDWwN7A5sDuwPbA/sEGwQ7BFsEewSbBLsE2wT7BRsFOwVbBXsFmwW7BdsF+wYbBjsGWwZ7BpsGuwbbBvsHGwc7B1sHewebB7sH2wf7CBsIOwhbCHsImwi9h3m7hH3BCWS8ul5dJyabm0XFouLZeWS8ul5dJyabm0XFouLZeWS8ul5dJyabm0XFouLZeWS8ul5dJyabm0XFouLZf77kC3n/vNe5T3KO9R3qO8R3mP8h7lPcp7lPco71Heo7xHeY/yHuU9ynvUvjvVberedMRwxHDEcMRwxHDEcMTYd8+6Yd2pXlv33a8nm3Q906Rp0DRi2idAECIIEoQJAgWhgmBBuCBgEDIIGoQNAgehg+BB+CCAEEIIIoQRAgmhhGBCOCGgEFIIKoQVAguhheBCeCHAEGIIMoQZAg2hhmBDuCHgEHIIOoQdAg+hh+BD+CEAEYIIQoQhAhGhiGBEOCIgEZIISoQlAhOhieBEeCJAEaLYjgcmhyUnI42eipiKmIqYipiKmIqYipiKmIqYipiKmIqYipiKmIqYipiKmIqYipiKmIqYipiKmIqYipiKmIqYipiKmIqYirgdz1TOU05QDkkyVzJXMlcyVzJXMlcyVzJXMlcyVzLXdjxJOUU5PDku+e3Yjqfm5BHZzh2RPh19DLqXu6maARoCmgIaA5oDGgSaBBoFmgUaBpoGGgeaBxoImggaCZoJGgqaChoLmgsaDJoMGg2aDRoOmg4aD5oPGhCaEBoRmhEaEpoSGhOaExoUmhQaFZoVGhaaFhoXmhcaGJoYGhmaGRoamhrW+2PQJ6Abvru5W7IlsSWxJbElsSWxJbElsSWxJbElsSWxJbElsSWxJbElcb3v427h7ttu0+7HfrLW+7482Xr7s603m2422OybiXyimIVjVo5ZOmbtmMVjVo9ZPmb9mAZgOoBpAaYHmCZguoBpA6YPmEZgOoFpBaYXmGZguoHxEOmEOflNVhPItHvGcTz0/aSdV+ftPPp4NO7o0NGCY21HscddUY9ln9z/+pn9nw6sw61ieXqe/2bBwqWWsazLtuyXq2UmAqVNpuqk6E+GpiyN4wusU46pV/Wtq1lG8/RCe6ee1LelJg9NyUu5N/X1qLFCw/Ay/CWpcUID8LJ6pND0u2yefxfZdfV+w8ubxcd+sxjdC3q/ODe9XcC/fvCXF8XLi+InelG8vP5dXv8ur3/LTn9pr5+fGx8emo89RlrRoxHgtLxPMwM+8X9MuB9hTw/BZ2cdD+8u9uw70WXmef0zz8l3mQ/rrZc01/toJLYzHA4vyvHUafzv2uHwas7o+r9O6RNGvjA8G596mflAxXhmzx/+/vpfjezLyw==
|
712,032
|
Pattern 15
|
Geek is very fond of patterns. Once, his teacher gave him a pattern to solve. He gave Geekan integer n and asked him to build a pattern.
Examples:
Input:
5
Output:
ABCDE
ABCD
ABC
AB
A
Constraints:
1<= N <= 20
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1662630404,
"func_sign": [
"void printTriangle(int n)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass Main {\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 int n = Integer.parseInt(br.readLine().trim());\n Solution obj = new Solution();\n obj.printTriangle(n);\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1730481424,
"user_code": "class Solution {\n\n void printTriangle(int n) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1663311159,
"func_sign": [
"printTriangle(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().strip())\n ob = Solution()\n ob.printTriangle(N)\n print(\"~\")\n",
"solution": "class Solution:\n # Function to print the triangle pattern.\n def printTriangle(self, N):\n # iterating over the rows in reverse order.\n for i in range(N, 0, -1):\n # iterating over the columns in each row.\n for j in range(i):\n # printing the characters starting from 'A' based on the column index.\n print(chr(65 + j), end='')\n # printing a new line after each row.\n print()\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def printTriangle(self, N):\n # Code here"
}
|
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
|
713,197
|
Min operations
|
Given two numbers aand b. In one operation you can pick any non negative integer x andeither of a or b. Now if you picked a then replace a with a&x else if you picked b then replace b with b&x.
Examples:
Input:
a = 5, b = 12
Output:
2
Explanantion:
In first operation replace
a = a&4 = 4
after that replace
b = b&6 = 4
Hence both are same after applying two
operations.
Input:
a = 100, b = 100
Output:
0
Explanation:
Already same.
Constraints:
0 ≤ a, b ≤ 10**9
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1671618896,
"func_sign": [
"public static int solve(int a, int b)"
],
"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 PrintWriter out=new PrintWriter(System.out);\n int t;\n t = Integer.parseInt(br.readLine());\n while(t-- > 0){\n \n int a;\n a = Integer.parseInt(br.readLine());\n \n \n int b;\n b = Integer.parseInt(br.readLine());\n \n Solution obj = new Solution();\n int res = obj.solve(a, b);\n \n out.println(res);\n \n \nout.println(\"~\");\n}\n out.close();\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public static int solve(int a, int b) {\n // If the two numbers are equal, return 0.\n if (a == b)\n return 0;\n // If the bitwise AND of the two numbers is equal to the smaller number, return 1.\n else if ((a & b) == Math.min(a, b))\n return 1;\n // Otherwise, return 2.\n else\n return 2;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public static int solve(int a, int b) {\n // code here\n }\n}\n \n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1671618896,
"func_sign": [
"solve(self, a : int, b : int) -> int"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n a = int(input())\n b = int(input())\n obj = Solution()\n res = obj.solve(a, b)\n print(res)\n print(\"~\")\n",
"solution": "class Solution:\n def solve(self, a: int, b: int) -> int:\n # check if a is equal to b, return 0 if true\n if a == b:\n return 0\n # check if bitwise AND of a and b equals the minimum of a and b, return 1 if true\n elif a & b == min(a, b):\n return 1\n # return 2 if none of the above conditions are true\n else:\n return 2\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def solve(self, a : int, b : int) -> int:\n # code here\n \n"
}
|
eJzdVk1LxDAQ9eDRH1F6XiST73r35g8QjHjQHrzEPeyCIIo/Qv+v03SzTXeTtvYDVodShrTMy7x5eeTz/Pvm4szF7TUmd2/5s11vN/lVljNjgTIupNKFsYVWUnBGwVhBdmGsbFIKXHHNJFftPF9lefm6Lh835dPDy3azq06N/cAf3Zu4d/6+ygJ46uDrx1gErh9MfRjLfQyCOQDgDrjwgX35aFIZ9CKCHNfBBy77SG4Dgm10bKnqmTSUhnnAfzCVBBxJQyBrvpIbGqkLB2AtTnyTpNXwALIhAU5q1ptuSFxmnZ1B51QTqnUt4wKq1uftiYaqPWYgtaPjplO8g/tUydZYhNADCqZVopjioCmWEkxqRQrAZSo1Z4JXsgXGKShF9fijAaQqLwUCVAdQSd2ShvaRYnzaWdgTtsg5HTiF7oH2aXmSig97XoSGjgoRwcaKit+aIPSZRL8JDmHeO2UxyCqjG2lbyck4yfLamMj0/xTSPLehiXqcMvhZPP3PWMvI+1VMEfMwt1+PdD+rZ41zgvlutPdflz+v8HXc
|
713,152
|
Maximum Weight Node
|
Given a maze withN cells. Each cell may have multiple entry points but not more than one exit (i.e entry/exit points are unidirectional doors like valves).You are given an array Edge[] of N integers,where Edge[i] contains the cell index that can be reached from celli in one step. Edge[i] is -1 if the ith cell doesn't have an exit.The task is to find the cell withmaximum weight (The weight of a cell is the sum ofcell indexes of all cells pointing to that cell). If there are multiple cells with the maximum weight return the cell withhighest index.
Examples:
Input:
N = 4
Edge[] = {2, 0, -1, 2}
Output:
2
Explanation:
1 -> 0 -> 2 <- 3
weight of 0th cell = 1
weight of 1st cell = 0
(because there is no cell pointing to the 1st cell)
weight of 2nd cell = 0+3 = 3
weight of 3rd cell = 0
There is only one cell which has maximum weight
(i.e 2) So, cell 2 is the output.
Input:
N = 1
Edge[] = {-1}
Output:
0
Explanation:
weight of 0
**th
cell is 0.
There is only one cell so
cell 0 has maximum weight.
Constraints:
1 ≤ N≤ 10**5
-1
<
Edge[i] < N
Edge[i] != i
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1671445648,
"func_sign": [
"public int maxWeightCell(int N, int Edge[])"
],
"initial_code": "//Initial Template for Java\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\nclass GFG{\n static class FastReader{ \n BufferedReader br; \n StringTokenizer st; \n \n public FastReader(){ \n br = new BufferedReader(new InputStreamReader(System.in)); \n } \n \n String next(){ \n while (st == null || !st.hasMoreElements()){ \n try{ st = new StringTokenizer(br.readLine()); } catch (IOException e){ e.printStackTrace(); } \n } \n return st.nextToken(); \n } \n \n String nextLine(){ \n String str = \"\"; \n try{ str = br.readLine(); } catch (IOException e) { e.printStackTrace(); } \n return str; \n } \n\n Integer nextInt(){\n return Integer.parseInt(next());\n }\n\n Long nextLong(){\n return Long.parseLong(next());\n }\n }\n\n public static void main(String[] args) throws IOException\n {\n FastReader sc = new FastReader();\n PrintWriter out = new PrintWriter(System.out);\n int t = sc.nextInt();\n while(t-- > 0){\n int N = sc.nextInt();\n int Edge[] = new int[N];\n for(int i = 0; i < N; i++)\n Edge[i] = sc.nextInt();\n Solution ob = new Solution();\n int ans = ob.maxWeightCell(N, Edge);\n out.println(ans); \n \nout.println(\"~\");\n}\n out.flush();\n }\n}\n\n",
"script_name": "FastReader",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution{\n public int maxWeightCell(int N, int Edge[]){\n \n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1671445648,
"func_sign": [
"maxWeightCell(self, N, Edge)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n for _ in range(int(input())):\n N = int(input())\n Edge = [int(i) for i in input().split()]\n obj = Solution()\n ans = obj.maxWeightCell(N, Edge)\n print(ans)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to find the index of the cell with maximum weight.\n def maxWeightCell(self, N, Edge):\n # Creating a list to store weight of each cell.\n weight = [0] * N\n\n # Iterating over the cells.\n for i in range(N):\n # If the current cell has a connection with another cell.\n if Edge[i] != -1:\n # Adding the index of the current cell to the weight of the connected cell.\n weight[Edge[i]] += i\n\n # Initializing the maximum weight and cell index.\n ans = [-1, -1]\n\n # Iterating over the weight list to find the cell index with maximum weight.\n for i in range(N):\n # Updating ans with the cell index and weight if the current weight is greater.\n ans = max(ans, [weight[i], i])\n\n # Returning the cell index with maximum weight.\n return ans[1]\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution():\n def maxWeightCell(self, N, Edge):\n #your code goes here"
}
|
eJytlL0KwjAURh36IJfMrSTpj9XVzScQvOKgHVyuHVIQRPEh9H29rdWCNZIUk6XDd06Tj0uuwX0RjJq1nPPH6iT2VFZGzEAopBQpUiCfW4QgimNZbE2x2xwq08Yk0gVJnEPosQm024ImFlTJ9r8KNMQsSCGDCeQWTf5DM4WcyYwNCZs0G33voVkEkbJQ6htlTfftcW3X3ofKuN+uH996kQaUID1LqCnw7852ss+YdA0i8SB4hBEV8pKv8R9ANijqbv7/oHKuxblA5xl9vwIuz8D6Nn4AXdZMTQ==
|
701,749
|
Nth number made of prime digits
|
Given a number 'n'. The task is to find the n**th number whose each digit is a prime number i.e. 2, 3, 5, 7. In other words, you have to find nth number of this sequence: 2, 3, 5, 7, 22, 23 ,... and so on.
Examples:
Input:
n = 10
Output:
33
Explanation:
10
**th
number in the sequence of numbers whose each digit is prime is 33.
Input:
n = 21
Output:
222
Explanation:
The
21
**st
number in the sequence of numbers whose each digit is prime is 222.
Constraints:
1 <= n <= 100
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1619248034,
"func_sign": [
"public static int primeDigits(int n)"
],
"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 Scanner sc = new Scanner(System.in);\n\n int t = sc.nextInt();\n\n while (t-- > 0) {\n int n = sc.nextInt();\n Solution ob = new Solution();\n System.out.println(ob.primeDigits(n));\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\nclass Solution {\n // Function to find nth number made of only prime digits.\n public static boolean isTrue(int n, String str) {\n int rem = 0;\n while (n > 0) {\n rem = n % 10;\n if (!str.contains(String.valueOf(rem))) {\n return false;\n }\n n = n / 10;\n }\n return true;\n }\n\n public static int primeDigits(int n) {\n // Your code here\n String primes = \"2357\";\n int count = 0;\n int term = 2;\n while (count < n) {\n if (isTrue(term, primes)) {\n count++;\n }\n if (count == n) {\n return term;\n }\n term++;\n }\n return 0;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n // Function to find nth number made of only prime digits.\n public static int primeDigits(int n) {\n // Your code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1619248034,
"func_sign": [
"primeDigits(self,n)"
],
"initial_code": "# Initial Template for Python 3\n\nimport math\n\nif __name__ == '__main__':\n t = int(input())\n for tcs in range(t):\n n = int(input())\n ob = Solution()\n print(ob.primeDigits(n))\n print(\"~\")\n",
"solution": "class Solution:\n\n def isTrue(self, n, prime_digits):\n while n > 0:\n rem = n % 10\n if str(rem) not in prime_digits:\n return False\n n //= 10\n return True\n\n def primeDigits(self, n):\n prime_digits = \"2357\"\n count = 0\n term = 2\n while count < n:\n if self.isTrue(term, prime_digits):\n count += 1\n if count == n:\n return term\n term += 1\n return 0\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n #Function to find nth number made of only prime digits.\n def primeDigits(self,n):\n # code here\n"
}
|
eJy9k7EKwjAQhh36ICFzkSYhhPgkghEH7eASO6QgiOJD6Ou4+V6eaTtk+K/gYOnQkn797/77714939UiX+sXPWwu8hi7PsmVkCpEumUtZHvu2n1qD7tTn8ZDHeKNDq+1KAkNCQMIizWQiMKMtYAxDdaxsDYMGYcgh6tzBpWnGqY+7RzAvOcoLIbbQl3RLNSMI4yJbJawlWocNpkTFMRRm1n4F1nveWut1TBn0yyZjMJYf9HCsLJ/ehl+HIqP/iXDbjcS88OGzxiqNbMYWZ3L3TTG7WP5Abeog8w=
|
713,587
|
Count number of free cell
|
Suppose you have a Matrix size n*n, and given an integer k and a set of coordinates arrof sizek*2. Initially, the matrix contains only 0. You are given k tasks and for each task, you are given two coordinates (r = arr[i][0],c = arr[i][1]) [1 based index r and c]. Where coordinates (r,c) denotes r**throw and c**thcolumn of the given matrix.
Examples:
Input:
n = 3, k= 3
arr =
{{2, 2},
{2, 3},
{3, 2}}
Output:
4 2 1
Explanation:
After 1st Operation, all the 2nd row
and all the 2nd column will be filled by
1. So remaning cell with value 0 will be 4
After 2nd Operation, all the 2nd row and all
the 3rd column will be filled by 1. So
remaning cell with value 0 will be 2
.
After 3rd Operation cells having value 0 will
be 1.
Input:
n = 2, k = 2
arr =
{{1, 2},
{1, 1}}
Output:
1 0
Explanation:
After 1st Operation, all the 1st row and
all the 2nd column will be filled by 1.
So remaning cell with value 0 will be 1.
After 2nd Operation, all the 1st row and
all the 1st column will be filled by 1.
So remaning cell with value 0 will be 0
.
Constraints:
1 <= n, k <= 10**5
1 <= r, c<= n
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1673952736,
"func_sign": [
"long[] countZero(int N, int K, int[][] arr)"
],
"initial_code": "//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\npublic class GFG {\n public static void main(String[] args) throws Exception {\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 while(T>0)\n {\n String s[]=in.readLine().trim().split(\" \");\n int n = Integer.parseInt(s[0]);\n int k = Integer.parseInt(s[1]);\n int[][] a = new int[k][2];\n for(int i=0; i<k; i++){\n s=in.readLine().trim().split(\" \");\n a[i][0] = Integer.parseInt(s[0]);\n a[i][1] = Integer.parseInt(s[1]);\n }\n Solution g = new Solution();\n long[] res = g.countZero(n,k,a);\n \n for(int i=0; i<res.length; i++){\n out.print(res[i]+\" \");\n }\n out.println();\n T--;\n \nout.println(\"~\");\n}\n out.close();\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n long[] countZero(int n, int k, int[][] arr){\n long ans = n * 1l * n; // calculate the total number of zeros initially assuming all elements are zero\n boolean row[] = new boolean[n + 1]; // array to keep track of whether a row is counted as zero or not\n boolean col[] = new boolean[n + 1]; // array to keep track of whether a column is counted as zero or not\n int r = n, c = n; // initialize the number of rows and columns\n long res[] = new long[k]; // array to store the results\n\n for(int i = 0; i < k; i++){ // iterate over the given array\n int x = arr[i][0], y = arr[i][1]; // get the row and column index\n if(!row[x] && !col[y]){ // if both row and column are not counted as zero\n ans = ans - c - r + 1; // decrement the total number of zeros by the number of rows and columns and add one (as (0,0) also gets counted)\n --r; --c; // decrement the number of rows and columns\n }else if(!row[x] && col[y]){ // if only row is not counted as zero and column is counted as zero\n ans -= c; // decrement the total number of zeros by the number of columns\n --r; // decrement the number of rows\n }else if(row[x] && !col[y]){ // if only column is not counted as zero and row is counted as zero\n ans -= r; // decrement the total number of zeros by the number of rows\n --c; // decrement the number of columns\n }\n res[i] = ans; // store the current number of zeros after each iteration\n row[x] = (col[y] = true); // mark the row and column as counted\n }\n return res; // return the array with results\n }\n}",
"updated_at_timestamp": 1730481921,
"user_code": "//User function Template for Java\nclass Solution {\n long[] countZero(int N, int K, int[][] arr){\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1673952736,
"func_sign": [
"countZero(self, n, k ,arr)"
],
"initial_code": "# Initial Template for Python 3\nfor _ in range(int(input())):\n n, k = map(int, input().split())\n arr = []\n for i in range(k):\n x, y = map(int, input().split())\n arr.append([x, y])\n obj = Solution()\n res = obj.countZero(n, k, arr)\n for i in res:\n print(i, end=\" \")\n print()\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution():\n # Function to count the number of cells with zero values\n def countZero(self, n, k, arr):\n # creating sets to store unique row and column values\n rowSet = set()\n colSet = set()\n ans = []\n\n # iterating over each coordinate in the given array\n for i in arr:\n # adding the row and column values to the respective sets\n rowSet.add(i[0])\n colSet.add(i[1])\n\n # calculating the count of cells with non-zero values\n ct1 = (n * len(rowSet)) + (n * len(colSet)) - \\\n len(rowSet) * len(colSet)\n\n # calculating the count of cells with zero values and appending it to the answer list\n ans.append(n**2 - ct1)\n\n return ans\n",
"updated_at_timestamp": 1730481921,
"user_code": "#User function Template for python3\n\nclass Solution():\n def countZero(self, n, k ,arr):\n #your code here"
}
|
eJzNVktOwzAQZcGGW4yyrlDsOP5wEiSMWEAXbEwXrYSEQBwCjsWOA+E3rlOI8lHTD/UiGjvzeTPzPMn7+ef3xRmv668o3LwUj2GxWhZXVAgfBOVHMaNi/ryY3y/nD3dPq+VapyQf3uLb1xm1LEuqsn1JovShprrXjRWkFSnX541t2Zkk6UMF31F/2KnQ5EiRoCGQQCbSs6QcqRXEkPHBkvXBkWusxlKpNMmaGhCiHwQWwjos2hxJQONDQEqHEWFST5seELCx0Ej2GqJiUUF0LEq81yziMIIdRiibfvI249kKwnCEqpWdaILkmNMzHqOARI0rtF2h7TWooH3Q6L1B7y16735RZUsCDLAwlTMlz7nHuBA1iwaiYREZkmURPSO3KU4qVfct6a+ZzRXTuV4q80NmdiRuRN2oXOHERmUFHRuVNaxsVLbwE1UijnGqd3X2T+sl10KmYhjemPqYlN/Qwv0TL9LQkweYeh3XWe75PneWj7h+4qgXq2du7XFwiQnVZDvESVeG1ntdcsBd5qQ41KBc/wpM+hfI1378C7czeU7vE7l7StO4evtx+QM50pGB
|
700,589
|
Range of Composite numbers
|
Given an integer n, we need to find a range of positive integers such that all the number in that range are composite and length of that range is n. You may return anyone range in the case of more than one answer.
Examples:
Example:
Input:
2
3
5
Output:
1
1
|
geeksforgeeks
|
Easy
|
{
"class_name": "GfG",
"created_at_timestamp": 1615292571,
"func_sign": [
"ArrayList<Integer> range(int n)"
],
"initial_code": "import java.util.*;\nclass Composite{\n\tpublic static boolean[] prime=new boolean[1500000];\n\tpublic static void main(String[] args){\n\t Scanner sc=new Scanner(System.in);\n\t\tint t=sc.nextInt();\n\t\tsieve();\n\t\twhile(t-->0){\n\t\t\tint n=sc.nextInt();\n\t\t\tGfG g=new GfG();\n\t\t\tArrayList<Integer> a=g.range(n);\n\t\t\t//System.out.println(a.size());\n\t\t\tif(a.size()==n){\n\t\t\t\tint flag=1;\n if(prime[a.get(0)]==true){\n\t\t\t flag=0;\n\t\t\t }\n\t\t\t\tfor(int i=1;i<n;i++){\n\t\t\t\t\tif(prime[a.get(i)]==true){\n\t\t\t\t\t\tflag=0;\n\t\t\t\t\t}\n if(a.get(i-1)+1!=a.get(i)){\n\t\t\t\t flag=0;\n\t\t\t\t }\n\t\t\t\t}\n\t\t\t\tif(flag==1){\n \t\t\t\tSystem.out.println(\"1\");\n\t\t\t\t}\n\t\t\t\telse{\n\t\t\t\t\tSystem.out.println(\"0\");\n\t\t\t\t}\n\t\t\t}\n\t\t\telse{\n\t\t\t\tSystem.out.println(\"0\");\n\t\t\t}\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n\tpublic static void sieve()\n\t{\n\t\tArrays.fill(prime, true);\n\t\tfor (int p=2; p*p<=1499999; p++)\n\t\t{\n\t\t\tif (prime[p] == true)\n\t\t\t{\n\t\t\t\tfor (int i=p*2; i<=1499999; i += p)\n\t\t\t\t\tprime[i] = false;\n\t\t\t}\n\t\t}\n\t}\n}",
"script_name": "Composite",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "/*Complete the function below*/\nclass GfG\n{\n\tArrayList<Integer> range(int n)\n {\n\t //add code here.\n\t}\n}"
}
|
{
"class_name": null,
"created_at_timestamp": 1615292571,
"func_sign": [
"Range(n)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n\n for _ in range(t):\n n = int(input())\n\n print(range(n))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\ndef factorial(n):\n a = 1\n for i in range(2, n + 1):\n a *= i\n return a\n\n# To print range of length n having all composite integers\n\n\ndef Range(n):\n a = factorial(n + 2) + 2\n b = a + n - 1\n\n if n == (b - a + 1):\n return 1\n else:\n return 0\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\ndef Range(n):\n #return 1/0\n #code here"
}
|
eJy9VcFKxDAQ9eDJryg9KRSZTJrd1i8RrIhoES9xkS4IovgR+lXe/CLTpHW7mYlNK7aQphnSmcx7kzdvhx9fRwf2Of80HxfP6b3ebJv0LEnzSgswQ1UazYwqzZK0ftrUN019e/Wwbbp9j9f6rj6GLBFwUunXSu8MyjOgvwO7HelLlgxCy0oXJjKasRqLWvhB0Tes2BgmLWnSUmasVZuqzRXGwkk/BeUb1n7WxjUBBtgztQmDaF8RYAsShgfTOrXZQYxbelgIODYslWVp/dpagXLMu9lOnefUVLLxRMsWjDKkflLgGLdItJNbCbcSboUR9FOArDdqI9fBxqE2DNYCgjuunUepc7vJjYMQfY4z6EvDQWI/RG8RUfXClgyDSeebtQZLdx+D/oL8BQychsZQi/4TGenZivmkDY9Mf1iQVBnSjT1NipZ6ouy8WAWRC0j+tC5Hb3BsQ4incnIxUu7z5chnBHzngdNw6bpFjJTzFeQTiWGhcInruO43p7mjX5UYzp7hlTbRhe+zrzu/9egZYuR69nKa0x/08v30G+23JzY=
|
703,288
|
Sum of f(a[i], a[j]) over all pairs in an array of n integers
|
Given an array arr[]of positive integers, find the sum of f(a[i], a[j]) of all pairs (i, j) such that (1 <= i < j <= n).
Examples:
Input:
arr[] = [6, 6, 4, 4]
Output:
-8
Explanation:
All pairs are: (6 - 6) + (4 - 6) + (4 - 6) + (4 - 6) + (4 - 6) + (4 - 4) = -8 return -8.
Input:
arr[] = [1, 2, 3, 1, 3]
Output:
4
Explanation:
All pairs are:(3-1) + (1-3) + (3-1) + (3-1) = 4 ,(1-2),(3-2),(1-1),(2-1),(3-3),(3-2) these pairs will give zero as their absolute difference is <= 1
Expected Time Complexity:
O(n).
Expected Auxiliary Space:
O(n).
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ 10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public static long sum(int[] arr)"
],
"initial_code": "// Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\n\n// Driver class\nclass Array {\n\n // Driver code\n public static void main(String[] args) throws IOException {\n // Taking input using buffered reader\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine());\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<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\n Solution obj = new Solution();\n long res = obj.sum(arr);\n System.out.println(res);\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Array",
"solution": "class Solution {\n // Function for finding the sum\n public static long sum(int[] arr) {\n int n = arr.length;\n Map<Integer, Integer> cnt = new HashMap<>();\n long ans = 0;\n long pre_sum = 0;\n // Traverse in the list from start to end\n // number of times arr[i] can be in a pair and\n // to get the difference we subtract pre_sum.\n for (int i = 0; i < n; i++) {\n ans += (i * arr[i]) - pre_sum;\n pre_sum += arr[i];\n // if the (arr[i] - 1) is present then\n // subtract that value as f(arr[i], arr[i] - 1) = 0\n if (cnt.containsKey(arr[i] - 1)) {\n ans -= cnt.get(arr[i] - 1);\n }\n // if the (arr[i] + 1) is present then\n // add that value as f(arr[i], arr[i] - 1) = 0\n // here we add as arr[i] - (arr[i] - 1) < 0 which would\n // have been added as negative sum, so we add\n // to remove this pair from the sum value\n if (cnt.containsKey(arr[i] + 1)) {\n ans += cnt.get(arr[i] + 1);\n }\n\n cnt.put(arr[i], cnt.getOrDefault(arr[i], 0) + 1);\n }\n return ans;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n\n // Function for finding maximum and value pair\n public static long sum(int[] arr) {\n // Complete the function\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"sum(self,arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n tc = int(input())\n\n while tc > 0:\n arr = list(map(int, input().strip().split()))\n ob = Solution()\n print(ob.sum(arr))\n print(\"~\")\n tc -= 1\n",
"solution": "from collections import defaultdict\n\n\nclass Solution:\n # Function for finding the sum\n def sum(self, arr):\n n = len(arr)\n cnt = defaultdict(int)\n ans = 0\n pre_sum = 0\n\n # Traverse in the list from start to end\n # number of times arr[i] can be in a pair and\n # to get the difference we subtract pre_sum.\n for i in range(n):\n ans += (i * arr[i]) - pre_sum\n pre_sum += arr[i]\n\n # if the (arr[i] - 1) is present then\n # subtract that value as f(arr[i], arr[i] - 1) = 0\n if (arr[i] - 1) in cnt:\n ans -= cnt[arr[i] - 1]\n\n # if the (arr[i] + 1) is present then\n # add that value as f(arr[i], arr[i] - 1) = 0\n # here we add as arr[i] - (arr[i] - 1) < 0 which would\n # have been added as negative sum, so we add\n # to remove this pair from the sum value\n if (arr[i] + 1) in cnt:\n ans += cnt[arr[i] + 1]\n\n cnt[arr[i]] += 1\n\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n # Function for finding the sum\n def sum(self,arr):\n # code here\n"
}
|
eJy9VMFOhDAQ9eDBrzATEm+LYdpOKX6JiRgPysEL7oFNTIzGj9D/tZ1hBV2KgGSnTV9Jad9j5pX308+LsxOO63M/uXlJHuvtrkmuINFljRko7shd5po7Zn4ZlG/aN+Mb+WbDHg4oOAScQC5gBSjZQFI9b6v7pnq4e9o1LS9af/RbWduCIdXymLxuoKdOdUwRLOu+hGGISBDGQd6QFaUNWbBktEIYefKvcoDiAM0BhgOIo1UJLgTkIcCGkPVYjqhQVBALlMNFbNqb/xLu1ZDkhwEFlIAWMAIkYAVyAScQSxmSjZWpK8y0mVTWWy0LTvOD2asGG4Y8DI499l3uiCojTmNlaIkPH0wNjjph4H2ROncXLOSBpXxqzo75dypb51K1HzpXa6tquq/0asZCVJ2zUsxi1jqWzFidf+jMvUx045U/+IMvqCb0Lv3eMTGBsrqqG9ew4/9/lTHe1BgyzujlxAek2RTWIrDiKOsf9+/24/ILk4YZdQ==
|
705,629
|
Check if it is possible to convert one string into another with given constraints
|
Given two strings S and T, whichcontains three characters i.e 'A', 'B' and '#'only. Checkwhether it is possible to convert the first string into another string by performing following operations on string first.
1- A can move towards Left only
2- B can move towards Right only
3- Neither A nor B shouldcross each otherNote: Moving i'th charactertowards Left one step means swap i'th with (i-1)'th charecter [ i-1>=0 ].Moving i'th charactertowards Right one step means swap i'th with (i+1)'th charecter [ i+1< string's length ].
Examples:
Input:
S=#A#B#B#
T=A###B#B
Output:
1
Explanation:
A in S is right to the A in T
so A of S can move easily towards
the left because there is no B on
its left positions and for first B
in S is left to the B in T so B
of T can move easily towards the
right because there is no A on its
right positions and it is same for
next B so S can be easily converted
into T.
Input:
S=#A#B#
T=#B#A#
Output:
0
Explanation:
Here first A in S is left to the
A in T and according to the condition,
A cant move towards right,so S cant
be converted into T.
Constraints:
1<=M,N<=100000
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int isItPossible(String S, String T, int M, 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 String S[] = read.readLine().split(\" \");\n Solution ob = new Solution();\n System.out.println(\n ob.isItPossible(S[0], S[1], S[0].length(), S[1].length()));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n int isItPossible(String S, String T, int M, int N) {\n // initializing pointers i and j\n int i=0, j=0;\n \n // checking if lengths of two strings are equal\n if(M!=N) return 0;\n \n // looping until we reach the end of both strings\n while(i<M || j<N){\n \n // skipping '#' characters in S\n while(i<M && S.charAt(i)=='#') i++;\n \n // skipping '#' characters in T\n while(j<N && T.charAt(j)=='#') j++;\n \n // if one string has more characters than the other\n if(i>=M && j<N) return 0;\n if(i<M && j>=N) return 0;\n \n // if the characters at the current positions are not equal\n if(i<M && j<N && S.charAt(i)!=T.charAt(j)) return 0;\n else{\n // if character at i is 'A' and i is less than j, return 0\n if(i<M && S.charAt(i)=='A' && i<j) return 0;\n // if character at i is 'B' and i is greater than j, return 0\n else if(i<M && S.charAt(i)=='B' && i>j) return 0;\n }\n \n // incrementing i and j\n i++;\n j++;\n }\n \n // returning 1 if both strings are equal\n return 1;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n int isItPossible(String S, String T, int M, int N) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"isItPossible(sef, S, T, M, N)"
],
"initial_code": "# Initial Template for Python 3\n\nimport math\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n S, T = input().split()\n ob = Solution()\n print(ob.isItPossible(S, T, len(S), len(T)))\n print(\"~\")\n",
"solution": "class Solution:\n # Function to check if it is possible to transform one string into another\n def isItPossible(self, S, T, M, N):\n i = 0\n j = 0\n\n # If the lengths of the two strings are not equal, return 0\n if M != N:\n return 0\n\n while i < M or j < N:\n # Skip over '#' characters in string S\n while i < M and S[i] == \"#\":\n i += 1\n\n # Skip over '#' characters in string T\n while j < N and T[j] == \"#\":\n j += 1\n\n # If one string ends before the other, return 0\n if i >= M and j < N:\n return 0\n if i < M and j >= N:\n return 0\n\n # If both strings end together, return 1\n if i >= M and j >= N:\n return 1\n\n # If two characters are not equal, return 0\n if S[i] != T[j]:\n return 0\n else:\n # If the character is 'A' and its position in S is greater than its position in T, return 0\n if S[i] == \"A\" and i < j:\n return 0\n # If the character is 'B' and its position in S is less than its position in T, return 0\n elif S[i] == \"B\" and i > j:\n return 0\n\n # Move to the next characters in both strings\n i += 1\n j += 1\n\n # If all conditions are met, return 1\n return 1\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def isItPossible(sef, S, T, M, N):\n #code here"
}
|
eJy1VL0KwjAQ7mB9jpCsRezq1jyFYMVBM7jEDi0IovgQ+rpiepecEVswibY0vQz33ffd33Vyz6cZPMtHnmWrE9/rpmv5gvGy1kJUQkjz4p8Ja5jDnLxgXB0btW3VbnPoWus3r/Wl1vxcsHcw8OwBAKiKhQEfcDcw0jEKRsH4+DH/EggkPSQWD+NkCNSFZpwySnFPJFgNhsbMjgcvx4KjeCiQMSCxaMb0i61zLwYuAB6hiCQl1dniEJDLFQD+pI3ddMmYuhPBQXap8gfphpP0awo88Bou1e6ll7KEsfUqSoz+0CE0Hp/z4XqbRiVttwIJWihfb9r1bfYEOxOdmg==
|
702,888
|
Bird and maximum fruit gathering
|
There are several trees arranged in a circle, each with a fruit value associated with it. A bird can gather all the fruits from a tree by sitting on it for 0.5 seconds and can move to a neighboring tree in another 0.5 seconds. Once all the fruits are picked from a tree, the bird cannot pick any more from that tree until all fruits are picked, it cannot move to next tree. The bird has totalTime seconds to gather as many fruits as possible and can start from any tree.
Examples:
Input:
arr[] = [2, 1, 3, 5, 0, 1, 4], totalTime = 3
Output:
9
Explanation:
Starting at tree 1 and moving to tree 2, then to tree 3, the bird gathers 1 + 3 + 5 = 9 fruits.
Input:
arr[] = [1, 6, 2, 5, 3, 4], totalTime = 2
Output:
8
Explanation:
Starting at tree 1 and moving to tree 2, the bird gathers 6 + 2 = 8 fruits. Alternatively, starting at tree 3 and moving to tree 4, the bird also gathers 5 + 3 = 8 fruits.
Constraints
:
2 ≤ arr.size() ≤ 10**6
1 ≤ totalTime ≤ arr.size()
0 ≤ arr[i] ≤ 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1617892345,
"func_sign": [
"public int maxFruits(int[] arr, int totalTime)"
],
"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) {\n Scanner scanner = new Scanner(System.in);\n int t = scanner.nextInt();\n scanner.nextLine(); // Consume the newline character\n for (int i = 0; i < t; i++) {\n int totalTime = scanner.nextInt();\n scanner.nextLine(); // Consume the newline character\n String input = scanner.nextLine();\n String[] inputArray = input.split(\" \");\n int[] arr = new int[inputArray.length];\n for (int j = 0; j < inputArray.length; j++) {\n arr[j] = Integer.parseInt(inputArray[j]);\n }\n\n Solution solution = new Solution();\n System.out.println(solution.maxFruits(arr, totalTime));\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 int maxFruits(int[] arr, int totalTime) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1617892345,
"func_sign": [
"maxFruits(self, arr, totalTime)"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n totalTime = int(input())\n arr = list(map(int, input().split()))\n solution = Solution()\n print(solution.maxFruits(arr, totalTime))\n print(\"~\")\n",
"solution": "class Solution:\n\n def maxFruits(self, arr, totalTime):\n n = len(arr)\n maxFruits = 0\n currentFruits = 0\n totalTime = min(n, totalTime)\n\n # Calculate the sum of the first window\n for i in range(totalTime):\n currentFruits += arr[i]\n\n maxFruits = currentFruits\n\n # Slide the window over the array\n for i in range(totalTime, n):\n currentFruits -= arr[i - totalTime]\n currentFruits += arr[i]\n maxFruits = max(maxFruits, currentFruits)\n\n return maxFruits\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n def maxFruits(self, arr, totalTime):\n # code here\n"
}
|
eJytU8tKA0EQ9KD/Ucw5SPc8Nhu/wpuCKx50D17GHDYQEMWP0P91ejeERKiJK84wMOxS1TVV3R/nXzcXZ+O6vS6Xu1f3nNebwV3BaZdV7GCFFks0SIgI8FC3gOu36/5x6J8eXjbDDpFSl9+77N4WOOYp3wXTVhEhcPtFCGLhEERBEHiKjwzelGcU3aHoT2gI3CtBt6W+4aa3mxuEIbSEYdnlgIM9V8HK9P/YFRuZDG9p2jpmqsQhTJEmO9AIDdBiiyn6daOoryU16tulxQiUtdokrP2rMt8ERjzOAvWqkhzD0EIa/mHsmFRiWaRWR2q1HvZUsTnIidb0J1M3rmryvlTlEU3OzQ1pP54z+qc2x/tC95+X335kg7g=
|
703,990
|
Maximum Product Cutting
|
Given a rope of length N meters, cut the rope in different parts of integer lengths in a way that maximizes the product of lengths of all parts. You must make at least one cut. Assume that the length of the rope is more than one meter.
Examples:
Input:
N = 5
Output:
6
Explanation:
Maximum obtainable product
is 2*3
Input:
N = 2
Output:
1
Explanation:
Maximum obtainable product
is 1*1
Your Task:
You don't need to read input or print anything. Complete the function
maxProduct
()
which takes
N
as input parameter and returns the maximum product.
Expected Time Complexity:
O(
N**2
)
Expected Auxiliary Space:
O(
N
)
Constraints:
2 ≤ N ≤ 50
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int maxProduct(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[])\n {\n Scanner sc = new Scanner(System.in);\n int t = sc.nextInt();\n while(t-->0)\n {\n int n = sc.nextInt();\n Solution ob = new Solution();\n System.out.println(ob.maxProduct(n));\n \nSystem.out.println(\"~\");\n}\n }\n} ",
"script_name": "GfG",
"solution": "class Solution {\n public int maxProduct(int n) {\n // Your code goes here\n if (n <= 2) {\n return 1;\n }\n long[] maxArr = new long[n + 1];\n Arrays.fill(maxArr, 0);\n maxArr[1] = 0;\n maxArr[2] = 1; // 2=1+1 so maxArr[2] = 1*1\n for (int i = 3; i <= n; i++) {\n for (int j = 1; j < i; j++) {\n /* Try to write i as: i = j + S where S=i-j corresponds to either one number or a sum of two or more numbers\n\n Assuming that j+S corresponds to the optimal solution for maxArr[i], we have two cases:\n (1) i is the sum of two numbers, i.e. S=i-j is one number, and so maxArr[i]=j*(i-j)\n (2) i is the sum of at least three numbers, i.e. S=i-j is a sum of at least 2 numbers,\n and so the product of the numbers in this sum for S is maxArr[i-j]\n (=maximum product after breaking up i-j into a sum of at least two integers):\n maxArr[i] = j*maxArr[i-j] */\n long x = maxArr[i];\n long y = j * (i - j);\n long z = j * maxArr[i - j];\n long mx = Math.max(y, z);\n maxArr[i] = Math.max(x, mx);\n }\n }\n return (int) maxArr[n];\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n\tpublic int maxProduct(int n)\n\t{\n\t\t// Your code goes here\n\t}\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"maxProduct(self, n)"
],
"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 ob = Solution()\n ans = ob.maxProduct(n)\n print(ans)\n print(\"~\")\n",
"solution": "# User function Template for python3\nclass Solution:\n def maxProduct(self, n):\n # code here\n if n <= 2:\n return 1\n\n maxArr = [0] * (n + 1)\n maxArr[1] = 0\n maxArr[2] = 1\n\n for i in range(3, n + 1):\n for j in range(1, i):\n maxArr[i] = max(maxArr[i], max(j * (i - j), j * maxArr[i - j]))\n\n return maxArr[n]\n",
"updated_at_timestamp": 1731573228,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef maxProduct(self, n):\n\t\t# code here"
}
|
eJy1VMtqFFEQdSF+x9DrIPV++CUBR1zoLNyMWUwgEBLyEeYL3PmVnp5RhEA1LvRu+kJ31anzqH56/fzjzavzuf6Oy/v75cvx5va0vNstvD8yLVe75XB3c/h0Onz++PX29Oudxv74uD8uD1e7FxU+VIjpUCITCJvXVDPBVNpUoxOON1lPRROQuknbUGUTlLB4xlg2gbGpVVMOdT7BVVCrmUx4PSmS2h4yKulbFkS4e2uSakWWSFBWu1uLMXVYSbsSZ7CXWqrjE44pHk5bDC2zSFPlAupF1Awg80whBZqJR7axluNhxlUaqgobvNNTMIRSUAniNinM6xDKunIfTcIpFmZV3MjGFVl7vew57s3fdhXaClBLUlsoG6zIgjlQIyCUw5IN2uuU2515ZvnHvAvP/aZ8iIARSVdqdJStbmDJrF2sLBIGiyJHHWQVAT+VktLWBLB0d3WzCFvA0CLhqPBwOAyXuyNIJcE4A5lLsYAezFIY1MrVMaEjqOuaIZP4QJwRCVPgueuYT/OtH6U1fMtGLC1KMTwogAGMRGSrpcqr2aUTFLkCF0hgQuc0ItgeYarTBl+y5Hye43eqNtX/h5E7tx//If9pMz98e/sTKtLZJg==
|
703,281
|
Countries at war
|
The two countries of A and B are at war against each other. The power of these soldiers is given by arr1[i] ofA and arr2[i] of B. They can only attack their counterpart enemies like arr1[i] can attack only arr2[i] and not anyone else. Both countries have equal number of counterparts. A soldier with a higher power can kill the enemy soldier. If both soldiers have the same power, they both die. You need to find the winning country.Note: If no one winning, then return "DRAW".
Examples:
Input:
arr1[] = [2, 2], arr2[] = [5, 5]
Output:
B
Explanation:
Both countries have 2 soldiers. arr2[0] kills arr1[0], arr2[1] kills arr1[1]. A has 0 soldiers alive at the end. B has both soldiers alive at the end.Return "B" as a winner.
Input:
arr1[] = [9], arr2[] = [8]
Output:
A
Explanation:
arr1[0] > arr2[0], So A is the winner.
Constraints:
1 ≤ arr1.size() ≤ 10**6
0 ≤ arr1[i],arr2[i] ≤ 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public String countryAtWar(int[] arr1, int[] arr2)"
],
"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 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 // ArrayList<Integer> v = new ArrayList<Integer>();\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 String v = new Solution().countryAtWar(arr1, arr2);\n\n // for (int i = 0; i < v.size(); i++) System.out.print(v.get(i) + \" \");\n\n System.out.println(v);\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public String countryAtWar(int[] arr1, int[] arr2) {\n int n = arr1.length;\n long a_dead = 0; // counter for dead soldiers from country A\n long b_dead = 0; // counter for dead soldiers from country B\n // Loop through each soldier\n for (int i = 0; i < n; i++) {\n if (arr1[i] == arr2[i]) { // If soldier from A and B are equal in strength\n arr1[i] = arr2[i] = 0; // Both soldiers are dead\n a_dead++;\n b_dead++;\n } else if (arr1[i] > arr2[i]) {\n // If soldier from A is stronger than soldier from B\n arr2[i] = 0; // Soldier from B is dead\n b_dead++;\n } else { // If soldier from B is stronger than soldier from A\n arr1[i] = 0; // Soldier from A is dead\n a_dead++;\n }\n }\n // Determine which country has more dead soldiers\n if (a_dead > b_dead) {\n return \"B\"; // Country B has more dead soldiers\n } else if (b_dead > a_dead) {\n return \"A\"; // Country A has more dead soldiers\n } else {\n return \"DRAW\"; // Both countries have an equal number of dead soldiers\n }\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public String countryAtWar(int[] arr1, int[] arr2) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"countryAtWar(self, arr1, arr2)"
],
"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 arr1 = list(map(int, input().strip().split()))\n arr2 = list(map(int, input().strip().split()))\n ob = Solution()\n l = ob.countryAtWar(arr1, arr2)\n print(l)\n print(\"~\")\n",
"solution": "class Solution:\n\n def countryAtWar(self, arr1, arr2):\n n = len(arr1)\n a_dead = 0 # counter for dead soldiers from country A\n b_dead = 0 # counter for dead soldiers from country B\n\n # Loop through each soldier\n for i in range(n):\n if arr1[i] == arr2[i]:\n # If soldier from A and B are equal in strength\n arr1[i] = arr2[i] = 0\n # Both soldiers are dead\n a_dead += 1\n b_dead += 1\n elif arr1[i] > arr2[i]:\n # If soldier from A is stronger than soldier from B\n arr2[i] = 0\n # Soldier from B is dead\n b_dead += 1\n else: # If soldier from B is stronger than soldier from A\n arr1[i] = 0 # Soldier from A is dead\n a_dead += 1\n\n # Determine which country has more dead soldiers\n if a_dead > b_dead:\n return \"B\" # Country B has more dead soldiers\n elif b_dead > a_dead:\n return \"A\" # Country A has more dead soldiers\n else:\n return \"DRAW\" # Both countries have an equal number of dead soldiers\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n\n def countryAtWar(self, arr1, arr2):\n # code here"
}
|
eJxrYJn6jZUBDCLeAxnR1UqZeQWlJUpWCkqGMXlAZBCTp6SjoJRaUZCaXJKaEp9fWgKVd4zJqwNK1uoooGoyAOvDockJhyZDAxBQAOo1UICwcRrhEuQYjsMUSxCA6ocbA+VC5MAkyV5CNYoclxkqQCHIg1BIesgidCKZR2pIGxmbmCqYmVtYAoMIwUaWMERIWOAOLDy+NcCXbvCFEshakAuAUWlhbmZqYmxEugeJSgTIfsaTIHAGIq7IgNiD29FYoxZ3WBHlOyqlcXxJA5EYwIbTI0YQVpNVlMBTIUwgj/QQgQUBjE1pjsHpYiyFAyy4UYMLFFikJi0DnGkrdooeAB/itd4=
|
702,710
|
Maximum Gap
|
Given an unsorted array arr[] of positive elements. Your task is to find the maximum difference between the successive elements in its sorted form.Return 0 if the array contains less than 2 elements.
Examples:
Input:
arr[] = [1, 10, 5]
Output:
5
Explanation:
The maximum difference between successive elements of array is 5 ie abs(5-10).
Input:
arr[] = [1, 10, 2]
Output:
8
Explanation:
The maximum difference between successive elements of array is 8 ie abs(2-10).
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ 10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int maxSortedAdjacentDiff(int[] arr)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\nclass GFG {\n // Driver code\n public static void main(String[] args) throws Exception {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(br.readLine());\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<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\n int ans = new Solution().maxSortedAdjacentDiff(arr);\n System.out.println(ans);\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n int maxSortedAdjacentDiff(int[] arr) {\n int n = arr.length;\n if (n < 2) return 0;\n int maxVal = arr[0];\n int minVal = arr[0];\n for (int i = 1; i < n; i++) {\n maxVal = Math.max(maxVal, arr[i]);\n minVal = Math.min(minVal, arr[i]);\n }\n // bucket size\n int bSize = Math.max(1, (maxVal - minVal) / (n - 1));\n // number of buckets\n int bNum = (maxVal - minVal) / bSize + 1;\n // Arrays to store maximum and minimum values\n // in bNum buckets of differences.\n int maxBucket[] = new int[bNum];\n int minBucket[] = new int[bNum];\n Arrays.fill(maxBucket, 0, bNum, Integer.MIN_VALUE);\n Arrays.fill(minBucket, 0, bNum, Integer.MAX_VALUE);\n // Traversing through array elements and\n // filling in appropriate bucket if bucket\n // is empty. Else updating bucket values.\n for (int i = 0; i < n; i++) {\n if (arr[i] == maxVal || arr[i] == minVal) {\n continue;\n }\n // Finding index of bucket.\n int index = (int) (Math.round((arr[i] - minVal) / bSize));\n // Filling/Updating maximum value of bucket\n if (maxBucket[index] == Integer.MIN_VALUE) {\n maxBucket[index] = arr[i];\n } else {\n maxBucket[index] = Math.max(maxBucket[index], arr[i]);\n }\n // Filling/Updating minimum value of bucket\n if (minBucket[index] == Integer.MAX_VALUE) {\n minBucket[index] = arr[i];\n } else {\n minBucket[index] = Math.min(minBucket[index], arr[i]);\n }\n }\n // Finding maximum difference between maximum value\n // of previous bucket minus minimum of current bucket.\n int prev_val = minVal;\n int max_gap = 0;\n for (int i = 0; i < bNum; i++) {\n if (minBucket[i] == Integer.MAX_VALUE) {\n continue;\n }\n max_gap = Math.max(max_gap, minBucket[i] - prev_val);\n prev_val = maxBucket[i];\n }\n max_gap = Math.max(max_gap, maxVal - prev_val);\n return max_gap;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n int maxSortedAdjacentDiff(int[] arr) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"maxSortedAdjacentDiff(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.maxSortedAdjacentDiff(arr)\n print(ans)\n tc = tc - 1\n",
"solution": "# Back-end complete function Template for Python 3\nimport math\n\n\nclass Solution:\n def maxSortedAdjacentDiff(self, arr):\n # Find maximum and minimum in arr[]\n n = len(arr)\n if n < 2:\n return 0\n\n maxVal, minVal = arr[0], arr[0]\n for i in range(1, n):\n maxVal = max(maxVal, arr[i])\n minVal = min(minVal, arr[i])\n\n # bucket size\n bSize = max(1, (maxVal - minVal) // (n - 1))\n # number of buckets\n bNum = (maxVal - minVal) // bSize + 1\n\n INT_MIN = -math.inf\n INT_MAX = math.inf\n\n # Arrays to store maximum and minimum\n # values in bNum buckets of differences.\n maxBucket = [INT_MIN] * (bNum)\n minBucket = [INT_MAX] * (bNum)\n\n # Traversing through array elements and\n # filling in appropriate bucket if bucket\n # is empty. Else updating bucket values.\n for i in range(0, n):\n if arr[i] == maxVal or arr[i] == minVal:\n continue\n\n # Finding index of bucket.\n index = (arr[i] - minVal) // bSize\n\n # Filling/Updating maximum value\n # of bucket\n if maxBucket[index] == INT_MIN:\n maxBucket[index] = arr[i]\n else:\n maxBucket[index] = max(maxBucket[index], arr[i])\n\n # Filling/Updating minimum value of bucket\n if minBucket[index] == INT_MAX:\n minBucket[index] = arr[i]\n else:\n minBucket[index] = min(minBucket[index], arr[i])\n\n # Finding maximum difference between\n # maximum value of previous bucket\n # minus minimum of current bucket.\n prev_val, max_gap = minVal, 0\n\n for i in range(0, bNum):\n if minBucket[i] == INT_MAX:\n continue\n max_gap = max(max_gap, minBucket[i] - prev_val)\n prev_val = maxBucket[i]\n\n max_gap = max(max_gap, maxVal - prev_val)\n\n return max_gap\n",
"updated_at_timestamp": 1727947200,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef maxSortedAdjacentDiff(self,arr):\n # code here"
}
|
eJyVU7EKwjAQdeiHHJmL5FKqiV8iWHHQDi61QwVBBHc30f+1TYq1kpeSWxK4e/fu8l7uyfuZzGysH+1lcxXHqj43YkWCi4pFSqK81OW+KQ+707npU7KoxC2lv2JJLG0AlOkCQG0Q4rNI40MqUlEzEkMSBOhnQzx2NB3GZuQ2CLVY+FpkpCknQ6yIc4DOQi/qeN2h3bEEfdi/Q95LE5TWFXkFinvtMRt0EuZjOYFFBowpb10Xbb1BSqgkK+l1gZMN87l8iPXbBHTQfhO1OnTbjkz8sz7yM/ulMZPfXA4fffuafwDGk1E+
|
703,480
|
K-th missing element
|
Given an increasing sequence arr, we need to find the K-th smallest missing element, taking the first element of the array as the starting point in the increasing sequence. If there is no k-th missing element then output -1.
Examples:
Input:
arr[] = [1, 3, 4, 5, 7] and k = 2
Output:
6
Explanation:
k = 2, Missing numbers are 2 and 6. So 2nd missing number is 6.
Input:
arr[] = [2, 3, 4, 5, 6, 8] and k = 1
Output:
7
Explanation:
k = 1, the first missing number in the array is 7.
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ k, arr[i] ≤ 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int KthMissingElement(int arr[], int k)"
],
"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 int res = obj.KthMissingElement(arr, k);\n\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "// User function Template for Java\nclass Solution {\n // Function to find the kth missing element in the array.\n int KthMissingElement(int arr[], int k) {\n // Initializing variables.\n int n = arr.length;\n boolean flag = false; // Flag to check if the kth missing element is found.\n int ans = 0; // Variable to store the kth missing element.\n int count = k; // Variable to track the remaining count of missing elements.\n int difference = 0; // Variable to store the difference between consecutive elements.\n // Iterate over the array to find the kth missing element.\n // Only iterate till n-1 to avoid accessing out of bounds memory.\n for (int i = 0; i < n - 1; i++) {\n difference = 0; // Reset the difference for each pair of consecutive elements.\n // Check if there is a gap between the current element and the next element.\n if ((arr[i] + 1) != arr[i + 1]) {\n difference +=\n (arr[i + 1] - arr[i]) - 1; // Calculate the number of missing elements between the\n // current and next element.\n // Check if the difference is greater than or equal to the remaining\n // count of missing elements.\n if (difference >= count) {\n ans = arr[i] + count; // Calculate the kth missing element.\n flag = true; // Set the flag to indicate that the kth missing\n // element is found.\n break; // Exit the loop since the kth missing element is already\n // found.\n } else {\n count -= difference; // Update the remaining count of missing elements.\n }\n }\n }\n // Check if the kth missing element is found.\n if (flag) {\n return ans; // Return the kth missing element.\n }\n return -1; // Return -1 if the kth missing element is not found.\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\n// User function Template for Java\n\nclass Solution {\n\n int KthMissingElement(int arr[], int k) {\n // Complete the function\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"KthMissingElement(self,arr,k)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n k = int(input())\n arr = list(map(int, input().split()))\n ob = Solution()\n res = ob.KthMissingElement(arr, k)\n print(res)\n print(\"~\")\n t -= 1\n",
"solution": "# User function Template for python3\nclass Solution:\n\n def KthMissingElement(self, arr, k):\n # Complete the function\n n = len(arr)\n flag = False # Flag to check if the kth missing element is found.\n ans = 0 # Variable to store the kth missing element.\n count = k # Variable to track the remaining count of missing elements.\n # Variable to store the difference between consecutive elements.\n difference = 0\n\n # Iterate over the array to find the kth missing element.\n # Only iterate till n-1 to avoid accessing out of bounds memory.\n for i in range(n - 1):\n # Reset the difference for each pair of consecutive elements.\n difference = 0\n\n # Check if there is a gap between the current element and the next element.\n if (arr[i] + 1) != arr[i + 1]:\n # Calculate the number of missing elements between the current and next element.\n difference += (arr[i + 1] - arr[i]) - 1\n\n # Check if the difference is greater than or equal to the remaining count of missing elements.\n if difference >= count:\n ans = arr[i] + count # Calculate the kth missing element.\n # Set the flag to indicate that the kth missing element is found.\n flag = True\n # Exit the loop since the kth missing element is already found.\n break\n else:\n # Update the remaining count of missing elements.\n count -= difference\n\n # Check if the kth missing element is found.\n if flag:\n return ans # Return the kth missing element.\n\n return -1 # Return -1 if the kth missing element is not found.\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n def KthMissingElement(self,arr,k) : \n #Complete the function\n"
}
|
eJytU7tOxEAMjBDwHaPUB/I+nOzyJUiAKCAFzd0VOQkJgfgI+FoabOcoQCzhkqysaSzPeuzx6/H70Wll7/LjpKqunuqH9XbX1xeo3fV6iHqFunvcdnd9d3+72fX7/JmkXiT7vMKPKtI3rVQCX/WFYl/8Vos9AiIYDVokZLgyUbGLLE/JCJ4QCJHAhIbQEhIhk7Y4ZS4DtYOiNwyG0ZANG8PWMBnmsYkUf2Taz1OEqBKVolpUjKpROarHBJX5+a91TWwtf1/WsCo46dbDBbgIx4ezBmUNwqdcDC9fJIQGkcFlOh7xQVraCBJLm+cwx1g6/m+ILc0cY5go14kVljjnX0yBGXLsqJZb39zjt3QYdfBYwzdv55+B6K++
|
703,260
|
Sum of distinct elements for a limited range
|
Given an array, arr[] such that every element of the array is an integer in the range 1 to n (n is the size of arr), the task is to find the sum of all the distinct elements of the array.
Examples:
Input:
arr[] = [5, 1, 2, 4, 6, 7, 3, 6, 7]
Output:
28
Explanation:
The distinct elements in the array are 1, 2, 3, 4, 5, 6, 7.
Input:
arr[] = [1, 1, 1]
Output:
1
Constraints:
1 ≤ arr.size() ≤ 10**6
1 ≤ arr[i] ≤ arr.size()
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int sumOfDistinct(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];\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.sumOfDistinct(arr));\n }\n scanner.close();\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n // Function to calculate the sum of distinct elements in the array.\n public int sumOfDistinct(int[] arr) {\n // HashSet to store distinct elements.\n HashSet<Integer> set = new HashSet<>();\n // Variable to store the sum of distinct elements.\n int sum = 0;\n // Iterating over the array.\n for (int num : arr) {\n // Adding element to sum if it's not already in the set.\n if (!set.contains(num)) {\n sum += num;\n set.add(num);\n }\n }\n // Returning the sum of distinct elements.\n return sum;\n }\n}\n",
"updated_at_timestamp": 1727776457,
"user_code": "// User function Template for Java\nclass Solution {\n // Function to calculate the sum of distinct elements in the array.\n public int sumOfDistinct(int[] arr) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"sumOfDistinct(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(Solution().sumOfDistinct(a))\n T -= 1\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "class Solution:\n # Function to calculate the sum of distinct elements in the array.\n def sumOfDistinct(self, arr):\n return sum(set(arr)) # Use set to get distinct elements, then sum them\n",
"updated_at_timestamp": 1727776457,
"user_code": "class Solution:\n # Function to calculate the sum of distinct elements in the array.\n def sumOfDistinct(self, arr):\n # Your code goes here"
}
|
eJyVk01OxDAMhVnAPZ6yHqHaqZuakyAxiAV0wabMopWQAIlDwH1J0yLxY8+06aJVY/vZX17ezz9fL87Kuh7zx81LeOwP4xCuEGjfU1UWwg6hez5090P3cPc0Dt8R8/a+D287/Ml0c6xo9qLZrL2lNIERUUPQIKGFgionX8QssDDQsuZXi99/ve7LZrLbWp5NsxRBZHlN0AYq0BoaoQz1KqkzlsEFlBtiUATVIAE1oATK0yrYo8ZkGkBy9UlDigpPSt6oZn8ZrhPv+G3GeYSo6aUqujrRcbZ9CJ5sSqfx/MdVeB1hJvbFUNfb09ZWG6zvcnHMmoTsqTllpb1Sa+LzuJxmvR12zSbtn1XMYUlWneLtx+UXHmZ2mQ==
|
706,421
|
Minimize the Heights I
|
Givena positive integer k and an array arr[] denoting heights of towers, you have to modify the heightof eachtower either by increasing or decreasing them by k only once.Find out what could be the possibleminimum difference of the heightof shortest and longest towers after you have modified each tower.
Examples:
Input:
k = 2, arr[] = [1, 5, 8, 10]
Output:
5
Explanation:
The array can be modified as [3, 3, 6, 8]. The difference between the largest and the smallest is 8 - 3 = 5.
Input:
k = 3, arr[] = [3, 9, 12, 16, 20]
Output:
11
Explanation:
The array can be modified as [6, 12, 9, 13, 17]. The difference between the largest and the smallest is 17 - 6 = 11.
Constraints
1 ≤ k ≤ 10**4
1 ≤ number of towers ≤ 10**5
0 ≤ arr[i] ≤ 10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1727078372,
"func_sign": [
"public int getMinDiff(int k, int[] arr)"
],
"initial_code": "import java.io.*;\nimport java.util.*;\n\npublic class Main {\n public static void main(String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n\n // Read the number of test cases (t)\n int t = Integer.parseInt(br.readLine().trim());\n\n while (t-- > 0) {\n int k = Integer.parseInt(br.readLine().trim());\n String input = br.readLine().trim();\n\n // Split the input line into integers and store them in the array\n String[] tokens = input.split(\" \");\n int[] arr = new int[tokens.length];\n for (int i = 0; i < tokens.length; i++) {\n arr[i] = Integer.parseInt(tokens[i]);\n }\n\n // Create an instance of the Solution class\n Solution ob = new Solution();\n\n // Call the getMinDiff method\n int res = ob.getMinDiff(k, arr);\n\n // Print the result\n System.out.println(res);\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": null,
"updated_at_timestamp": 1730480075,
"user_code": "// User function Template for Java\nclass Solution {\n public int getMinDiff(int k, int[] arr) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1727077270,
"func_sign": [
"getMinDiff(self,k, arr)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n k = int(input())\n arr = list(map(int, input().strip().split()))\n solution = Solution()\n res = solution.getMinDiff(k, arr)\n print(res)\n print(\"~\")\n",
"solution": "# Backend complete function Template for python3\nclass Solution:\n\n def getMinDiff(self, k, arr):\n n = len(arr)\n v = []\n taken = [0] * n\n\n # we will store all possible heights in a vector\n for i in range(n):\n v.append([arr[i] - k, i])\n v.append([arr[i] + k, i])\n v.sort()\n elements_in_range = 0\n left = right = 0\n\n # By two pointer we will traverse v and whenever we will get a range\n # in which all towers are included, we will update the answer.\n while elements_in_range < n and right < len(v):\n if taken[v[right][1]] == 0:\n elements_in_range += 1\n taken[v[right][1]] += 1\n right += 1\n\n ans = v[right - 1][0] - v[left][0]\n while right < len(v):\n if taken[v[left][1]] == 1:\n elements_in_range -= 1\n taken[v[left][1]] -= 1\n left += 1\n\n while elements_in_range < n and right < len(v):\n if taken[v[right][1]] == 0:\n elements_in_range += 1\n taken[v[right][1]] += 1\n right += 1\n\n if elements_in_range == n:\n ans = min(ans, v[right - 1][0] - v[left][0])\n else:\n break\n\n return ans\n",
"updated_at_timestamp": 1730480075,
"user_code": "#User function Template for python3\n\nclass Solution:\n def getMinDiff(self,k, arr):\n # code here\n"
}
|
eJzNVsGO1DAM5cCJr7B6XqE4TdqEL0GiiAPMgUvZw6yEhEB8BHwSNz4Kv5dMZ6VOSncWEB3F9SSOn2M7T/369PvPZ0/4vPxhyqtP3fv59u7YvZCun2Z19pSXRAhOiFL3ZTHbAxPJVZtmm+1upDt8vD28PR7evflwd6w+uXOav0zzaMZKrfzvPt/IPXA/zcVUAawEVgLrOaw66yl7x7UG8IJb964Rz36jO52X4M5T9pShiRAuOQ0lH2JBSi9BogwySpJsoYvaAbxoLxrsZKKD6CiaRLMdCdGU5Coz6yl7ykAZKQfKkTKVGpQq8SDT7FGp6JAe6e0d7B0ij2cGLJzHqi3YnAxORifJqslitwuZeNxM6WtGU6uUnuFAAh8oDiDnhuKSck25qOlei8WlC+sUi118lUIVl4j95BknWAA2zhHcEvxmY/wl/JRTG9VS1tzYDtXyJbt+D/Pta50j73/pqVh7CY1jY7SRbGTYOAhYKkwVthq4GQLmCnvFBs3R1SwP7ADxNnobwUa0MaAxbSQbGTYOApYKU4WtwlgjPUDAXrFBbccmJRVmGJuVaFFRpR4fFwJCTkwG6iGeKESRI5MD9YH6SH2knqgn6pl6jlt0lmK7WfcG+6ehL3PdTmJDsf47cjNQ69Hsd5Dc6uaR0q67fqoGvJuK4pqLcBuu5UPbGrY4ifC8T/T0YHZaEanfiMZvcPI1d1J4KUkR1zV/CEZf+Z+xBAjukUwBL2yGHV1rrFmUVbOCuX/TtCFc7tn1Z2R+/Hekz+al8R35+tvzX+RSrHM=
|
709,994
|
Insert an Element at the Bottom of a Stack
|
You are given a stack st of n integers and an element x. You have to insert x at the bottom of the given stack.
Examples:
Input:
n = 5
x = 2
st = {4,3,2,1,8}
Output:
{2,4,3,2,1,8}
Explanation:
After insertion of 2, the final stack will be {2,4,3,2,1,8}.
Input:
n = 3
x = 4
st = {5,3,1}
Output:
{4,5,3,1}
Explanation:
After insertion of 4, the final stack will be {4,5,3,1}.
Constraints:
1 <= n <= 10**5
0 <= x, elements of stack <= 10**9
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1689770418,
"func_sign": [
"public Stack<Integer> insertAtBottom(Stack<Integer> st, int x)"
],
"initial_code": "//Initial Template for Java\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n static File file;\n static BufferedReader in;\n static PrintWriter out;\n\n public static void main(String args[]) throws IOException {\n in=new BufferedReader(new InputStreamReader(System.in));\n out=new PrintWriter(System.out);\n int t = Integer.parseInt(in.readLine());\n\n while (t-- > 0) {\n\n String s[] = in.readLine().trim().split(\" \");\n int n = Integer.parseInt(s[0]);\n int x = Integer.parseInt(s[1]);\n s = in.readLine().trim().split(\" \");\n Stack<Integer> st = new Stack<>();\n for (int i = 0; i < n; i++) {\n st.push(Integer.parseInt(s[i]));\n }\n Solution ob = new Solution();\n Stack<Integer> S = ob.insertAtBottom(st, x);\n for (int i : S) {\n out.print(i + \" \");\n }\n out.println();\n \nout.println(\"~\");\n}\n out.close();\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public Stack<Integer> insertAtBottom(Stack<Integer> S, int N) {\n Stack<Integer> temp = new Stack<>();\n \n // Iterate until S becomes empty\n while (!S.empty())\n {\n \n // Push the top element of S\n // into the stack temp\n temp.push(S.peek());\n \n // Pop the top element of S\n S.pop();\n }\n \n // Push N into the stack S\n S.push(N);\n \n // Iterate until temp becomes empty\n while (!temp.empty())\n {\n \n // Push the top element of\n // temp into the stack S\n S.push(temp.peek());\n \n // Pop the top element of temp\n temp.pop();\n }\n \n // Print the elements of S\n return S;\n}\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution {\n public Stack<Integer> insertAtBottom(Stack<Integer> st, int x) {\n \n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1689786026,
"func_sign": [
"insertAtBottom(self,st,x)"
],
"initial_code": "if __name__ == \"__main__\":\n for _ in range(int(input())):\n n, x = map(int, input().split())\n stack = list(map(int, input().split()))\n obj = Solution()\n ans = obj.insertAtBottom(stack, x)\n for e in ans:\n print(e, end=\" \")\n print()\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def insertAtBottom(self, St, X):\n new_stack = []\n while St:\n new_stack.append(St.pop())\n St.append(X)\n while new_stack:\n St.append(new_stack.pop())\n return St\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n def insertAtBottom(self,st,x):\n # code here"
}
|
eJzNVjtOw0AQpaDkEE+uI2Tvx7vmJEgYUUAKGpMikZAQiEPAYeg4GruOZ+zIHscBYpg0z5Hn43kzb/f19P3z7KS2y48Arp6S+2q1WScXSLKyylJkKVlZFWQg4Bk5Rjkjy8gw0owUo4xRmiyQLB9Xy9v18u7mYbOmWrgKfvWIRaCsXsoqeV5gtx0Wtm2G4Yo0I8WIC4YnJHwah8TBEaU6I21KG5s7XwTWvMut0SoDgRQEChDwIOBAIAcBCwIGBEITm4ASaVQDjl+CTFka+9FvZ9vitu1MhfBBXRImRhqhiAc5PKH3E0pop3/AZyRZZ3AHd8mTwZEhJ4MlgyGDJoMiQ0a2d9bnKEJqh6uz13KGJhmaBGiCBjdZiDDiKOX0MCpoRhZmBLqA9tAOOky3hTZiNqMguEh58sh0LU5xLuOUxo8Nf0JZMY3dzm7fQ8pSDOlLystd0HKHlSbgQCAHAQsCJi53s9JhubfuMgk9Yfn13GM8mh0ig1fgZQ+NBoMexxTw+Vj6D2fFVL4mkiQyM/0KQBoXifjp4c+xDln7gzZeWvbueSHE6nvYQ94XxXHGCf6GDotUdGp2fyqObn51nHLb6q7Njy9cVMj12/kX/YT+Aw==
|
703,957
|
Absolute Difference of 1
|
Given an array arr. Return all the numbers less than kand the number which have at least two digits and the absolute difference between every adjacent digit of that number should be 1in the array.
Examples:
Input:
arr[] = [7, 98, 56, 43, 45, 23, 12, 8], k = 54
Output:
[43, 45, 23, 12]
Explanation:
43 45 23 12 all these numbers have adjacent digits diff as 1 and they areless than 54.
Input:
arr[] = [87, 89, 45, 235, 465, 765, 123, 987, 499, 655], k = 1000
Output:
[87, 89, 45, 765, 123, 987]
Explanation:
87 89 45 765 123 987 all these numbers have adjacent digits diff as 1 and they areless than 1000.
Constraints:
1 <= arr.size() <= 10**6
1 <= k, arr[i] <= 10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1617817733,
"func_sign": [
"public ArrayList<Integer> getDigitDiff1AndLessK(int[] arr, int k)"
],
"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 k = Integer.parseInt(read.readLine());\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().getDigitDiff1AndLessK(arr, k);\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": "None",
"updated_at_timestamp": 1727947200,
"user_code": "// User function Template for Java\n\nclass Solution {\n public ArrayList<Integer> getDigitDiff1AndLessK(int[] arr, int k) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1617817733,
"func_sign": [
"getDigitDiff1AndLessK(self, arr, k)"
],
"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\n while t > 0:\n k = int(input())\n arr = list(map(int, input().split()))\n ob = Solution()\n ans = ob.getDigitDiff1AndLessK(arr, k)\n print(*ans)\n print(\"~\")\n t -= 1\n",
"solution": "class Solution:\n # Function to check if the digits in a number differ by 1 or not\n def isDiff1(self, n):\n while n >= 10:\n dig1 = n % 10\n dig2 = (n // 10) % 10\n if abs(dig1 - dig2) != 1:\n return False\n n = n // 10\n return True\n\n # Function to get numbers from a list that have digits differing by 1 and are less than k\n def getDigitDiff1AndLessK(self, arr, k):\n ans = []\n for num in arr:\n if self.isDiff1(num) and num < k and num >= 10:\n ans.append(num)\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def getDigitDiff1AndLessK(self, arr, k):\n # code here"
}
|
eJy1Vs1OwzAM5sCFt7B6nlD+m/AkSBRxgB24FA6bhIRAPAS8Djfei89O0Da0ZK201aq1drY/+4vj9OP86+fiTK7rb/y4ee0ex+f1qruiTg+jVmoYjSXryHnygUJPfaSYSBsymqwhZ8m7YewW1C1fnpf3q+XD3dN6VWJM8n2H+9uCdqE9Q2ulYWpga2HsYO0pIFSPWBHBEkfTChF1NYX/McR2LySqZUzYGdhZYDlgeWAFYPXAiklT4vTxP79LKdVxG3GKfz2PYYyw9syQFbYAmuCLMI7faFXFPey4F9Tk4jXIMiDLgiwHwj0IDyC8B+FRCqatwqYU3yBbIBNfkaMyS6J7Eh1JdEIBfUD6oi2JNiRak2iVn/JDDpUjtRI8CVy7Vi0XM1xILjwXqgvbhfDCeaG9MC+IjMX4DMkpct6hsQvrWyyvwOF6ccOKRIdsmQ13mMi2Eq7RnhN869uimFJx50CcDkl23HGyGLK2srKyrrKquBU2MKYBbjOXq80SGhbAsACIBVAsAGMBHAsAWQDJQqIjybuexCKQ2Ld20QmwqrtfBhLac3YT7c7pvLOOMa3rk1qVEVntsTnJSi9OSWjesSHXZuZzg26Oj6123pwkQ5h6ljTPjuOPmnCUWTO7Tba5ndYyE8A59T+QYTjcja1htP/rhr9qDFDmfBPVUKzSKD5TUO+N4n37efkLAKBs6w==
|
703,387
|
Smallest Non-Zero Number
|
You are given an array arr[]. Your task is to find the smallest number x such that when x is processed sequentially with each element of the array (from index 0 to n-1), it never becomes negative, under the following conditions:
Examples:
Input:
arr[] = [3, 4, 3, 2, 4]
Output:
4
Explanation:
Start with `x = 4`:
- For arr[0] = 3, x becomes 5.
- For arr[1] = 4, x becomes 6.
- For arr[2] = 3, x becomes 9.
- For arr[3] = 2, x becomes 16.
- For arr[4] = 4, x becomes 28.
x remains positive throughout the process.
If x < 4, it would become negative at some point.
Input:
arr[] = [4, 4]
Output:
3
Explanation:
Start with `x = 3`:
- For arr[0] = 4, x becomes 2.
- For arr[1] = 4, x becomes 1.
x remains positive. If x < 3, it would become negative.
Constraints:
1 ≤ arr.size() ≤ 10**6
1<= arr[i] <= 10**4**
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int find(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); // Initialize scanner for input\n int t = Integer.parseInt(scanner.nextLine()); // Read number of test cases\n\n while (t-- > 0) {\n String line =\n scanner.nextLine().trim(); // Read the input line and trim extra spaces\n\n if (line.isEmpty()) {\n continue; // Skip empty lines\n }\n\n // Split the input line by space and parse it into an integer array\n String[] elements = line.split(\" \");\n int[] arr = new int[elements.length];\n\n for (int i = 0; i < elements.length; i++) {\n arr[i] = Integer.parseInt(elements[i]);\n }\n\n // Create an object of Solution and call the find method\n Solution ob = new Solution();\n System.out.println(ob.find(arr)); // Output the result\n System.out.println(\"~\"); // Output the result\n }\n\n scanner.close(); // Close the scanner to avoid resource leaks\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n // Function to process the array and calculate the result\n public int find(int[] arr) {\n int num = 0; // Initialize num to 0\n // Traverse the array from end to start\n for (int i = arr.length - 1; i >= 0; i--) {\n // Update num based on the current array element\n num = (int) Math.round((arr[i] + num) / 2.0);\n }\n // Return the final result\n return num;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n // Function to process the array and calculate the result\n public int find(int[] arr) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"find(self, arr)"
],
"initial_code": "def main():\n import sys\n input = sys.stdin.read\n data = input().strip().split(\"\\n\")\n\n T = int(data[0]) # Read the number of test cases\n\n results = []\n for i in range(1, T + 1):\n # Read the input, strip extra spaces, and convert to a list of integers\n a = list(map(int, data[i].strip().split()))\n\n # Print the result by calling the find function of the Solution class\n results.append(Solution().find(a))\n\n # Print all results, one per line\n for result in results:\n print(result)\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "import math\n\n\nclass Solution:\n # Function to find the number by averaging elements in the array.\n def find(self, arr):\n # Custom round function to mimic C++ round behavior\n def custom_round(x):\n # Mimicking the rounding behavior of C++ where 0.5 rounds away from zero\n if x >= 0:\n return int(math.floor(x + 0.5))\n else:\n return int(math.ceil(x - 0.5))\n\n num = 0\n # Iterating over the array in reverse order.\n for i in range(len(arr) - 1, -1, -1):\n # Averaging the current element with the previous sum using custom rounding\n num = custom_round((arr[i] + num) / 2.0)\n return num\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution:\n # Function to process the array and calculate the result\n def find(self, arr):\n # Your code goes here"
}
|
eJzdVcuKwkAQ9ODJrxjm5EF0onm0+yWCWfagOXiJHiIIy4of4f6vXRERwW5nNIo4kxQJQ6W6p3squ/b/oNOqx6TLD9NfuyhX68p+GRvlZeR4mJej7RlbbFbFrCrmP8t1dQoIa3m5zUv71zOXkY55GL4JkAFSQAKIASPAEBABHAOBQWAQGAQGgUFgEBgEBoFBUlQQFYI6pvTc0OSoxlJUxnMqpRgGZ6wqSUmklElCUo9ogQmcRG6rG7uQOFVPTIwVRaJvdd57hpZH+9bdbXWamqdcDcjAUCjzzZYVhM/HfLrFFn61rd521w9oytoslfXGDO2qhVOTHs7alN5TkYY2K2irzkfGT1s/M+K/y6cc7mn1iN3osRPCl4OW8jOKwx2p3o/za3glQsvyve8fAORVVks=
|
705,614
|
Binary Tree K level sum
|
Given a binary tree s and a number k, the task is to find the sum of tree nodes at level k. The Binary Tree is given in string form s: (node-value(left-subtree)(right-subtree)).
Examples:
Input:
s =
"
(0(5(6()())(4()(9()())))(7(1()())(3()())))" , k = 2
Output:
14
Explanation:
The Tree from the above String will be formed as:
0
/ \
5 7
/ \ / \
6 4 1 3
\
9
Sum of nodes at the 2nd level is 6+4+1+3 = 14.
Input:
s = "(4(8()9())" , k = 1
Output:
17
Explanation:
The Tree from the above String will be formed as:
4
/ \
8 9
Sum of nodes at the 1st level is 8+9 = 17.
Constraints:
1 <= |s| <= 10**5
0 <= k <=
15
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int kLevelSum(String s, 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 = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while (t-- > 0) {\n String s = read.readLine().trim();\n int k = Integer.parseInt(read.readLine().trim());\n\n Solution ob = new Solution();\n System.out.println(ob.kLevelSum(s, k));\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n static int kLevelSum(String s, int k) {\n char S[] = s.toCharArray(); // convert string to char array\n int n = -1; // initialize n to -1\n int ans = 0; // initialize ans to 0\n for (int i = 0; i < S.length; ) // iterate over the char array\n {\n if (n == k\n && S[i] != ')'\n && S[i] != '(') // check if n is equal to K and current char is not '(' or ')'\n {\n String h = \"\"; // initialize an empty string h\n while ((S[i] != '(') && (S[i] != ')')) // iterate until char is not '(' or ')'\n {\n h += S[i]; // append current char to h\n i++; // increment i\n }\n ans += Integer.parseInt(h); // convert h to integer and add it to ans\n }\n if (S[i] == '(') // check if current char is '('\n {\n n++; // increment n\n i++; // increment i\n } else if (S[i] == ')') // check if current char is ')'\n {\n n--; // decrement n\n i++; // increment i\n } else i++; // increment i\n }\n return ans; // return the final answer\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n static int kLevelSum(String s, int k) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"kLevelSum(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 ob = Solution()\n print(ob.kLevelSum(s, k))\n print(\"~\")\n",
"solution": "class Solution:\n\n def kLevelSum(self, s: str, k: int) -> int:\n n = -1\n ans = 0\n i = 0\n while i < len(s):\n # If current level is K and the character is not '(' or ')'\n if n == k and s[i] not in '()':\n h = ''\n # Extract the number and add it to the answer\n while i < len(s) and s[i] not in '()':\n h += s[i]\n i += 1\n ans += int(h)\n # If current character is '(', incrementing the level\n elif s[i] == '(':\n n += 1\n i += 1\n # If current character is ')', decrementing the level\n elif s[i] == ')':\n n -= 1\n i += 1\n # If current character is neither '(' nor ')', move to next character\n else:\n i += 1\n\n # Return the sum of numbers at level K\n return ans\n",
"updated_at_timestamp": 1730291459,
"user_code": "#User function Template for python3\n\nclass Solution:\n def kLevelSum(self,s,k):\n # code here "
}
|
eJy9VLFOwzAQZWDgM6JMF6lCPjuOHSY2fgEJIwbIwOJ2SCUkBOIj4H85O3ZTIV1IU2ikOPar796786s/zr9uLs7ic3tNk7vX8tlvtn15VZToPCBIUFCDhgYMWGgBBVRQjY/zrfPlqii7l0332HdPD+ttnzMI59/p17dV8TOvCGkkjSrOahp1nDU0GnptXLVh3OPSLBfFcWRaEFMQrqN0wOFbETfIhKmEVUROGkAnvMl7LclKmM17SZBiBamGr14PalSoPOenDsfsbRaCChCT4jqDoRALaBKeNocypBowaUd1km8XcuJUVBB4Urkmc9vYQFKeVcmd1ICgGolr3hOKIw4n7bxgI9l2DoF4eGBwd6xkOl6yxlpMHO2+M5/JJkMCMaOY4Umb8RyzaptsKi46jil3n8reiOag3uto4j/sPnPn+Ar+99bBdq4h9k54oT1yLC3EsHJHmvSkN+OCqo+5G/Wcy9HObtRvf7TD28T1KboEZ9nk/vPyG2fpFDE=
|
702,712
|
Find Kth Rotation
|
Given an increasing sorted rotated array arr of distinct integers. The array is right-rotatedktimes. Find the value ofk.Let's suppose we have an array arr = [2, 4, 6, 9], so if we rotate it by 2 times so that it will look like this:After 1st Rotation : [9, 2, 4, 6]After 2nd Rotation : [6, 9, 2, 4]
Examples:
Input:
arr = [5, 1, 2, 3, 4]
Output:
1
Explanation:
The given array is 5 1 2 3 4. The original sorted array is 1 2 3 4 5. We can see that the array was rotated 1 times to the right.
Input:
arr = [1, 2, 3, 4, 5]
Output:
0
Explanation:
The given array is not rotated.
Constraints:
1 <= n <=10**5
1 <= arr
i
<= 10**7
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int findKRotation(List<Integer> arr)"
],
"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 Scanner sc = new Scanner(System.in);\n int t = Integer.parseInt(sc.nextLine());\n while (t-- > 0) {\n List<Integer> arr = new ArrayList<>();\n String input1 = sc.nextLine();\n Scanner ss1 = new Scanner(input1);\n while (ss1.hasNextInt()) {\n arr.add(ss1.nextInt());\n }\n Solution ob = new Solution();\n int res = ob.findKRotation(arr);\n System.out.println(res);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution {\n // Returns count of rotations for an array which\n // is first sorted in ascending order, then rotated\n private int countRotations(List<Integer> arr, int low, int high) {\n // This condition is needed to handle the case\n // when the array is not rotated at all\n if (high < low) return 0;\n\n // If there is only one element left\n if (high == low) return low;\n\n // Find mid\n int mid = low + (high - low) / 2;\n\n // Check if element (mid+1) is minimum element.\n // Consider the cases like {3, 4, 5, 1, 2}\n if (mid < high && arr.get(mid + 1) < arr.get(mid)) return (mid + 1);\n\n // Check if mid itself is minimum element\n if (mid > low && arr.get(mid) < arr.get(mid - 1)) return mid;\n\n // Decide whether we need to go to left half or\n // right half\n if (arr.get(high) > arr.get(mid)) return countRotations(arr, low, mid - 1);\n\n return countRotations(arr, mid + 1, high);\n }\n\n public int findKRotation(List<Integer> arr) {\n int n = arr.size();\n return countRotations(arr, 0, n - 1);\n }\n}",
"updated_at_timestamp": 1730268522,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int findKRotation(List<Integer> arr) {\n // Code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"findKRotation(self, arr)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input().strip())\n for _ in range(t):\n arr = list(map(int, input().strip().split()))\n ob = Solution()\n res = ob.findKRotation(arr)\n print(res)\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n # Returns count of rotations for an array which\n # is first sorted in ascending order, then rotated\n def countRotations(self, arr, low, high):\n # This condition is needed to handle the case\n # when the array is not rotated at all\n if high < low:\n return 0\n\n # If there is only one element left\n if high == low:\n return low\n\n # Find mid\n mid = low + (high - low) // 2\n\n # Check if element (mid+1) is minimum element.\n # Consider the cases like {3, 4, 5, 1, 2}\n if mid < high and arr[mid + 1] < arr[mid]:\n return mid + 1\n\n # Check if mid itself is minimum element\n if mid > low and arr[mid] < arr[mid - 1]:\n return mid\n\n # Decide whether we need to go to left half or right half\n if arr[high] > arr[mid]:\n return self.countRotations(arr, low, mid - 1)\n\n return self.countRotations(arr, mid + 1, high)\n\n def findKRotation(self, arr):\n n = len(arr)\n return self.countRotations(arr, 0, n - 1)\n",
"updated_at_timestamp": 1730268522,
"user_code": "#User function Template for python3\nclass Solution:\n def findKRotation(self, arr):\n # code here"
}
|
eJzNVcFKw0AQ9eDFvxhyLpKd3dkkXr35BYIVD5qDl9hDCoIofoT+r5OZMbQ2m7Y01AbaVwr7+t7bedPP8++bizN5bq/5w91b9twslm12BZmbNy6XBxSdIRp6w2BIhtGwMCwNK0andE7ZXEdWdU+u4BTsS68QFEghKhQKpUKVzSCrXxf1Y1s/Pbws218P+bz5mDfZ+wzWnekpVgQIHgIQRCiA2VgVONbGJtkfW2NXbIi9sI0KMAfkMwjoAQMgAUbAArAErMCbjapM6UnIIYmZJGSSiEkCJomXJFySaEmCJYmVJFR+d3K2kz1kJ4wFhAlF/dVvMI4HnqLbJ8b1K0j9Eo0pl5HTgcXew4hunyJDHyiybMHScHNu9Pu4L7uWgV9dp7o+dV2iwdAT1DFBvRrpXzpMZRpG2wLDMzE68KnxGmS07hxEPHWTbMUdXqiwXZnbXRqGScWd4qI/ypKXFd/fzsqS6peTMHCbpln0FmzqWMrJrsPj/md89ivdMVu3umCm+B9D2nJz91+XPxwqOdw=
|
712,223
|
Combination Sum II
|
Given an array of integers arr, the length of the array n, and an integer k, find all the unique combinations in arr where the sum of the combination is equal to k. Each number can only be used once in a combination.Return the combinations in the lexicographically sorted order, where each combination is in non-decreasing order.
Examples:
Input:
n = 5, k = 7
arr[] = { 1, 2, 3, 3, 5 }
Output:
{ { 1, 3, 3 }, { 2, 5 } }
Explanation:
1 + 3 + 3 = 7
2 + 5 = 7
Input:
n = 6, k = 30
arr[] = { 5, 10, 15, 20, 25, 30 }
Output:
{ { 5, 10, 15 }, { 5, 25 }, { 10, 20 }, { 30 } }
Explanation:
5 + 10 + 15 = 30
5 + 25 = 30
10 + 20 = 30
Expected Time Complexity:
O(2**min(n,p)
)
Expected Auxiliary Space:
O(n)
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1675572590,
"func_sign": [
"public List<List<Integer>> CombinationSum2(int arr[], int n, int k)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.lang.*;\nimport java.util.*;\n\npublic class Main {\n\n public static void main(String[] args) throws IOException {\n BufferedReader br = new BufferedReader(new InputStreamReader(System.in));\n PrintWriter ot = new PrintWriter(System.out);\n int t = Integer.parseInt(br.readLine().trim());\n while (t-- > 0) {\n String s[] = br.readLine().trim().split(\" \");\n int n = Integer.parseInt(s[0]);\n int k = Integer.parseInt(s[1]);\n int a[] = new int[n];\n s = br.readLine().trim().split(\" \");\n for (int i = 0; i < n; i++) a[i] = Integer.parseInt(s[i]);\n List<List<Integer>> ans = new Solution().CombinationSum2(a, n, k);\n for (List<Integer> list : ans) {\n for (int x : list) ot.print(x + \" \");\n ot.println();\n }\n if (ans.size() == 0) ot.println();\n }\n ot.close();\n }\n}",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1727947200,
"user_code": "// User function Template for Java\n\nclass Solution {\n public List<List<Integer>> CombinationSum2(int arr[], int n, int k) {\n // Code Here.\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1692193868,
"func_sign": [
"CombinationSum2(self, arr, n, k)"
],
"initial_code": "# Initial Template for Python 3\n\nfor _ in range(int(input())):\n n, k = map(int, input().split())\n arr = list(map(int, input().split()))\n\n ob = Solution()\n result = ob.CombinationSum2(arr, n, k)\n print(*result, sep='\\n')\n if not result:\n print()\n\n print(\"~\")\n",
"solution": "class Solution:\n\n def solve(self, indx, a, k, n, v, ans):\n # If the combination sum equals the target, add it to the result\n if k == 0:\n ans.append(v[:])\n return\n # If there are no more elements to consider or if the remaining\n # target value is negative, return\n if indx == n or k < 0:\n return\n\n # Iterate through the remaining elements starting from the current position\n for i in range(indx, n):\n # Skip over duplicate elements to avoid duplicate combinations\n if i != indx and a[i] == a[i - 1]:\n continue\n # Add the current element to the combination\n v.append(a[i])\n # Recursively solve for the remaining elements and target value\n self.solve(i + 1, a, k - a[i], n, v, ans)\n # Remove the current element from the combination\n v.pop()\n\n def CombinationSum2(self, arr, n, k):\n # Sort the input array in non-decreasing order\n arr.sort()\n v = []\n ans = []\n # Call the solve function to find the combinations\n self.solve(0, arr, k, len(arr), v, ans)\n # Return the combinations that sum up to the target value\n return ans\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n \n def CombinationSum2(self, arr, n, k):\n # code here"
}
|
eJydVE1LxEAM9aD/4zHnIsl8gf4SoV08aA9exj10QVgU8Tfo/zWTdpeykO52y0xImEleXvPa79u/n7sbfZ724rR791a2u8E9wnFXGNW4Bq7/2PYvQ//6/L4bpvOWN1356or7bHCaRgtpVpZXMPjVcB6hGiuxK0ZeQFSKsFo1MyOyIsJGbX2Duqymk74jKSBdIK19Vwmc1BJGYxVIDeqSOtVlsgpmPMzaQTaHoKxyrSdumEp7dWN1w3QaxyMDjKmyJ3hCIEQhQMhkgpKgyg6yIyn2FOVjFGUnjQ43xygebp2bAgvvoyjWi5evUq+gGwnLMz8zcnvOo3JPJLwoZPMjUMYL9exfgFlyRpGv5zjXsiVks4V5crAUeQkBldHlJDa/9/9gTpyt
|
714,262
|
String Mirror
|
You are given a string strof length n. You want to choose a non-zero integer k (k<=n), such that you can perform the following operation:
Take the prefix of the string of length k and append the reverse of it to itself.
Your task is to find the lexicographically smallest string you can get.
Examples:
Input:
str = "bvdfndkn"
Output:
bb
Explanation:
If we choose k=1, prefix of length k will be "b", reverse of
this prefix will be "b" itself, when we append both we get "bb",
"bb" is the lexicographically smallest string you can get.
If you choose k>1, the resulting string will not be
lexicographically smaller than "bb".
Input:
str = "casd"
Output:
caac
Explanation:
If we choose k=2, prefix of length k will be "ca", reverse of
this prefix will be "ac", when we append both we get "caac",
"caac" is the lexicographically smallest string you can get.
Constraints:
1 <= |str| <= 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1678885472,
"func_sign": [
"public static String stringMirror(String str)"
],
"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 str;\n str = br.readLine();\n \n Solution obj = new Solution();\n String res = obj.stringMirror(str);\n \n System.out.println(res);\n \n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730988842,
"user_code": "class Solution {\n public static String stringMirror(String str) {\n // code here\n }\n}\n \n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1678885472,
"func_sign": [
"stringMirror(self, str : str) -> str"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n str = input()\n obj = Solution()\n res = obj.stringMirror(str)\n print(res)\n print(\"~\")\n",
"solution": "class Solution:\n def stringMirror(self, str):\n # initialize variable lst with first character of the string\n lst = str[0]\n # initialize variable tmp with first character of the string\n tmp = str[0]\n for i in range(1, len(str)):\n if str[i] < lst: # check if current character is smaller than lst\n last = str[i] # update last with current character\n tmp += lst # append lst to tmp\n else:\n break # exit the loop if current character is not smaller than lst\n ans1 = tmp # initialize ans1 with tmp\n ans1 += tmp[::-1] # append reverse of tmp to ans1\n tmp = str[0] # reset tmp to first character of the string\n lst = tmp # reset lst to first character of the string\n for i in range(1, len(str)):\n if str[i] <= lst: # check if current character is smaller or equal to lst\n lst = str[i] # update lst with current character\n tmp += lst # append lst to tmp\n else:\n break # exit the loop if current character is not smaller or equal to lst\n # initialize ans2 with tmp appended with reverse of tmp\n ans2 = tmp + tmp[::-1]\n # return the minimum value between ans1 and ans2\n return min(ans1, ans2)\n",
"updated_at_timestamp": 1730988842,
"user_code": "class Solution:\n def stringMirror(self, str : str) -> str:\n # code here\n \n"
}
|
eJydk00KwjAQhV30ICXrImTrSQQjkr+Fm1gkBY0oHkLv62RoKyivkMyqMHzz3rxMn8372qy4tmf62N3EMfRDFJtWSBW06FrhL7230bvDaYhjS2sVHiqIe9f+AMY6Xwp5Zw1S4h5PRYpUplTRZApA3OOpAE4ATAlZRAT0l5C5pDVUwSthnVyl64xaSExKzHEYhE4jTPkUpZBhlWvhSGrueTaKz3rB6ZQwdkww8vzNiMRlsTqHTGFV/B3ZdsW+/57xW81D9q/1B0iKftE=
|
703,836
|
Max Sum Subarray of size K
|
Given an array of integers Arr of size N and a number K. Returnthe maximum sum of a subarray of size K.
Examples:
Input:
N = 4, K = 2
Arr = [100, 200, 300, 400]
Output:
700
Explanation:
Arr
3
+ Arr
4 =700,
which is maximum.
Input:
N = 4, K = 4
Arr = [100, 200, 300, 400]
Output:
1000
Explanation:
Arr
1
+ Arr
2
+ Arr
3
+ Arr
4 =1000,
which is maximum.
Constraints:
1 <= N <= 10**5
1 <= Arr
i
<= 10**5**
1 <= K <= N
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1729857990,
"func_sign": [
"public long maximumSumSubarray(int[] arr, int k)"
],
"initial_code": "// Initial Template for Java\n\nimport 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 t = Integer.parseInt(br.readLine());\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<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\n int k = Integer.parseInt(br.readLine());\n\n Solution ob = new Solution();\n long ans = ob.maximumSumSubarray(arr, k);\n System.out.println(ans);\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public int maximumSumSubarray(int[] arr, int k) {\n int n = arr.length;\n int res = 0;\n\n // Calculating the sum of the first K elements in the array.\n for (int i = 0; i < k; i++) {\n res += arr[i];\n }\n\n int curr_sum = res;\n\n // Iterating over the remaining elements in the array.\n for (int i = k; i < n; i++) {\n // Calculating the sum of the current subarray by\n // subtracting the first element of the previous subarray\n // and adding the current element.\n curr_sum += arr[i] - arr[i - k];\n // Updating the result with the maximum of the current sum\n // and the previous result.\n res = Math.max(res, curr_sum);\n }\n\n // Returning the maximum sum of a subarray of size K.\n return res;\n }\n}",
"updated_at_timestamp": 1730473405,
"user_code": "// User function Template for Java\n\nclass Solution {\n public long maximumSumSubarray(int[] arr, int k) {\n // Code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1729857990,
"func_sign": [
"maximumSumSubarray(self,arr,k)"
],
"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 k = int(input().strip())\n ob = Solution()\n ans = ob.maximumSumSubarray(arr, k)\n print(ans)\n tc -= 1\n print(\"~\")\n tc -= 1\n",
"solution": "class Solution:\n\n def maximumSumSubarray(self, arr, k):\n n = len(arr)\n res = sum(arr[:k]) # Calculate the sum of the first k elements\n curr_sum = res\n\n for i in range(k, n):\n curr_sum += arr[i] - arr[i - k] # Update the current sum\n res = max(res, curr_sum) # Update the maximum sum if necessary\n\n return res # Return the maximum sum of a subarray of size k\n",
"updated_at_timestamp": 1730473405,
"user_code": "#User function Template for python3\nclass Solution:\n def maximumSumSubarray (self,arr,k):\n # code here "
}
|
eJzdVstuFEEM5MCVf7DmHKF2P6f5EiQWcYA9cFly2EhICMRHwJEbH0rZtVkGlB6WkAdKr7ocpV22x2175vPjr9+fPPL1/Bv+ePFhers7v9hPz2RKm52GIBE7YWfsgl2xG/aM3bGhAzBNNVU1XTVlhfZmV8wKjMAGTMACDIAPOtii5BrVmEY0niiUFFoKNe0ehNmBORxLLJKK5CKlSC3SisxFOo4CNs4VCgoNzaaODSWFlkJNOyJK05lM2/fn29f77ZtX7y72h0euHvInuCqFf0wfz2SRk4gjiZIkC1xLk1m6WFxMlqWi23KcHZtjdSyO2TE5RkfFgw1Ciu2qOEDQmHKp4tjEcRbHLo7ItKGKYxRHeDXMQvpmVwd+c5xTz33kfPmssy1ptqTawr1gSbYlyZZEW7gcLAkHyf/xnLrk0Qbt0Tb90Kk5H8RcPMejkOVB/FApw8e/smSdEdi8KAbD6Jgcs2NxrI7NcXbshupcda46V52rzlXnqnPVuepcdW4MK6WN8z6K2dti0SJp0Tpl0VJt0WqXJUKhFJEiUWSKQlEpGsVMQSvW1DqKXD1zo0rrh+ZQikiRKDIFr6RXikYxH5qKZT4aUpE21jszUiSKHI4VwAkeOMQD53jgKD9mLqxcWr5UGHunc/qma3qmY/qV+afX462RraQr+UoDSgtKE0obSiPaF4+8Mh5sqK+Eju76pdVO6MY/NORwdt9GcXf8bqq8Y4KxYX2fOE7KXc8TFEXJ633x372yNK+9s24q02T/nuuTkopvJ1zG+nfA7WQ13Fpar91+/9pXOeh4AF0rqnCHUyFFGEv1vj8y6l9PhTr8yjjhfXWvL6zDp4DH/vLL0x8cXhXm
|
703,907
|
Maximum weight difference
|
Given an array arr[].The task is to choose k numbers from the array such that the absolute difference between the sum of chosen numbers and the sum of remaining numbers is maximum.
Examples:
Input:
arr[] = [8, 4, 5, 2, 10] , k=2
Output:
17
Explanation:
If we select 2 and 4, then abs((2+4) - (8+5+10)) = 17.
Input:
arr[] = [1, 1, 1, 1, 1, 1, 1, 1] , k=3
Output:
2
Explanation:
We can select any 3 1's.
Constraints:
1 <= k <= arr.size() <=10**5
1 <= arr[i] <= 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1617816639,
"func_sign": [
"public long MaxWeightDiff(int[] arr, int k)"
],
"initial_code": "// Initial Template for Java\n\nimport 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 t = Integer.parseInt(br.readLine());\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<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\n int k = Integer.parseInt(br.readLine());\n // Create Solution object and find closest sum\n Solution ob = new Solution();\n long ans = ob.MaxWeightDiff(arr, k);\n System.out.println(ans);\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "Main",
"solution": "class Solution {\n public long MaxWeightDiff(int[] arr, int k) {\n int n = arr.length;\n // Sort the given array\n Arrays.sort(arr);\n // Initialize the sums\n long sum = 0, sum1 = 0, sum2 = 0;\n // Get the sum of the entire array\n for (int i = 0; i < n; i++) {\n sum += arr[i];\n }\n // Get the sum of the first k elements\n for (int i = 0; i < k; i++) {\n sum1 += arr[i];\n }\n // Get the sum of the last k elements\n for (int i = n - k; i < n; i++) {\n sum2 += arr[i];\n }\n // Return the maximum possible difference\n return Math.max(Math.abs(sum1 - (sum - sum1)), Math.abs(sum2 - (sum - sum2)));\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public long MaxWeightDiff(int[] arr, int k) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1617816639,
"func_sign": [
"MaxWeightDiff(self, arr,k)"
],
"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 k = int(input().strip())\n ob = Solution()\n ans = ob.MaxWeightDiff(arr, k)\n print(ans)\n tc -= 1\n print(\"~\")\n",
"solution": "# User function Template for python3\nclass Solution:\n\n def MaxWeightDiff(self, arr, k):\n n = len(arr)\n\n # Sort the given array\n arr.sort()\n\n # Initialize the sums\n sum_total = 0\n sum1 = 0\n sum2 = 0\n\n # Get the sum of the entire array\n for i in range(n):\n sum_total += arr[i]\n\n # Get the sum of the first k elements\n for i in range(k):\n sum1 += arr[i]\n\n # Get the sum of the last k elements\n for i in range(n - k, n):\n sum2 += arr[i]\n\n # Return the maximum possible difference\n return max(abs(sum1 - (sum_total - sum1)),\n abs(sum2 - (sum_total - sum2)))\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def MaxWeightDiff(self, arr,k):\n # code here"
}
|
eJzNVctOw0AM5MCJn8DKgVOF6t3NrsOXIBHEAXrgEji0EhIC8RHwv4zdSi1Qh/TBw5bsSIm9k9nZ9cvh28nRgdn5MR4uHqvb7n42rc6o4rbjsRo1ahaFAkViSlTbm9B2qRpRNXm4n1xPJzdXd7PpojwmfB/b7rntqqcRfWpsfdCFMhUSaojHxEwciNE/EdfEmbgQC3FDYaxgnJWA0llmFbjGYjFbrC0mi9FisMgW7afFasVqxWrFasVqxWrFasVqxWoFaGoHqoHw0C7Y/g+ph20PfW212DioQpWBHJEjckJOyNAM1cgZOSMX5IIsyILcqNbmfbBKcQCU4u63ymrpccXTitdLR0lwlglNr6hEjYoaZTX8GYySGkU1CmqQNauyfVEEbZJcUYBOMAkSyagDayAMXJHp3m1aeyQV2qu3XdhUKmDjpx2oPGaGoNpssa8PHxxy/x5VHgfvshy4ERDI7ltW4loU3ucDiNTD/ctcFgmhd5P7AOSheHsAcGZ38vkjdceZOm+p+NcPvL+ZeKBC+oYe7qmNztp23rNXALDNSMt7nWnMTc9QWz1O25ylfV1Ml6+n72u5XLE=
|
702,730
|
Sum of Array
|
You are given an integer array arr[]. The task is to find the sum of it.
Examples:
Input:
arr[] = [1, 2, 3, 4]
Output:
10
Explanation:
1 + 2 + 3 + 4 = 10.
Input:
arr[] = [1, 3, 3]
Output:
7
Explanation:
1 + 3 + 3 = 7.
Constraints:
1 <= arr.size <= 10**5
1 <= arr[i] <= 10**4
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int sum(int arr[])"
],
"initial_code": "// Initial Template for Java\n\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 =\n Integer.parseInt(scanner.nextLine().trim()); // Read number of test cases\n\n while (t-- > 0) {\n String line = scanner.nextLine().trim(); // Read the entire line\n String[] numsStr = line.split(\" \"); // Split the line into string numbers\n int[] nums = new int[numsStr.length];\n for (int i = 0; i < numsStr.length; i++) {\n nums[i] =\n Integer.parseInt(numsStr[i]); // Convert each string to integer\n }\n\n int ans =\n new Solution().sum(nums); // Compute the sum using the Solution class\n\n System.out.println(ans); // Print the result\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "Main",
"solution": "None",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n int sum(int arr[]) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"_sum(self,arr)"
],
"initial_code": "# Driver code\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._sum(arr)\n print(ans)\n tc -= 1\n print(\"~\")\n # no change needed, the indentation was already correct\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def _sum(self, arr):\n # return sum using sum\n # inbuilt sum() function\n return sum(arr)\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef _sum(self,arr):\n \t\t# code here\n"
}
|
eJztmMFuE0EMhjnwIL/CkQrteMb2mCdBoogD9MAl9NBKSAjEQ8D74n8leiidNK1aNqQ7da1Kyb/Neuz/28yP57/kxbN5vXmZf7z9uvm0Pb+82LzGppxuy5QLa17zg+bNCTZnX87PPlycfXz/+fLiT8NN8zrdfj/dbr6d4Fov4ih+xvc+um+pDWreEWXKCxQpqKUVaLECL70gZBIUEUGVJlAxgUsXRJ0qSpWKWluFVqvw2iuiTQ2lSUNtLS/frMFbbwidFEVFUbUpVE3h2hVhk6GYGKo1yw9kBrduCJ8cxcVRvTnUzeHeHdGnjtKlo/bWod06vPe8j5gCJSRQowU0LOARMTfHoD6i3pqPSsS+WmOf2DF6g+IGd6Zz3zwXjBuvudDYOTUXhK1Xcs07iCNRDDuxheuwExc31/8lD8qruxgw72H+0kPCmYxJmRpTZRKmwsRd71TMrkNPCjpW0M+Cbhf0wqBTBn00LSuTU0G/DafCqXAqnAqnwqlwKpwKo8KoMCqMCqPCqDAqjAqjwqhQKpQKpUKpUCqUCqVCqVAqdFSslvcko15kJfEU03Bwd3RWQcITSUIk1pD7MttlGkEaQiI0YZlYTAAm6hJqAZmQHE67SLYmRZOXScZkYNKOXJsS0QnjtJUEbKI0oZl4TBAm8tAmJL4T1InktJ7EbAI10ZmQJA6HHi232M5TnI4dg7GjWotj+Hrwue3hLjfv2f4Cu/9zQ6vqLisMn1Ze+N8Pn2GDr65Dv1dcG/qb3zWe+m7jqV++sjfFakh3zIcWg2Y07uyuTjyYrw08ofn3Xx2W3ra/Y53E45xEuWUQDykWZu/eNU3UFq+rwa0Gd8x5iYhdL9/V4Q5kAB91+OIuJ5Pae7VbDmAOpmyrb2H1rfvkx4wH9aelC7U7l3IIn+Iqj86XOLJX50vvfr76DRH03Bk=
|
712,111
|
Search in Rotated Array 2
|
Given a sorted and rotated array arr and a target key k which is rotated at some point, and may contain duplicates and given an element key. Check whether the key is present in the array or not.
Examples:
Input:
arr[] = [2, 5, 6, 0, 0, 1, 2], k = 0
Output:
true
Explanation:
0 is found at index 3.
Input:
arr[] = [2, 5, 6, 0, 0, 1, 2], k = 3
Output:
false
Explanation:
There is no element that has value 3.
Constraints
:
1 ≤ arr.size() ≤ 10**6
0 ≤ arr[i] ≤ 10**8
1 ≤ key ≤ 10**8
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1663847756,
"func_sign": [
"public static boolean Search(int[] arr, int k)"
],
"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 res = obj.Search(arr, k);\n if (res)\n System.out.println(\"true\");\n else\n System.out.println(\"false\");\n\n // System.out.println(res);\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n public static boolean Search(int[] arr, int k) {\n // initialize left and right pointers for binary search\n int n = arr.length;\n int l = 0;\n int r = arr.length - 1;\n\n while (l <= r) {\n // calculate middle index\n int mid = l + (r - l) / 2;\n // if middle element is equal to k, return true\n if (arr[mid] == k) {\n return true;\n }\n // check if left and right pointers need to be adjusted\n if ((arr[l] == arr[mid]) && (arr[r] == arr[mid])) {\n l++;\n r--;\n }\n // if left side is normally sorted\n else if (arr[l] <= arr[mid]) {\n // check if k is within left and middle, adjust right pointer\n // accordingly\n if ((arr[l] <= k) && (arr[mid] > k))\n r = mid - 1;\n else\n l = mid + 1;\n }\n // if right side is normally sorted\n else {\n // check if k is within middle and right, adjust left pointer\n // accordingly\n if ((arr[mid] < k) && (arr[r] >= k))\n l = mid + 1;\n else\n r = mid - 1;\n }\n }\n // return false if k is not found\n return false;\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "class Solution {\n public static boolean Search(int[] arr, int k) {\n // code here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1675176561,
"func_sign": [
"Search(self, arr, key)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n while t > 0:\n k = int(input())\n arr = list(map(int, input().split()))\n ob = Solution()\n res = ob.Search(arr, k)\n if res:\n print(\"true\")\n else:\n print(\"false\")\n print(\"~\")\n t -= 1\n",
"solution": "class Solution:\n\n def Search(self, arr, k):\n n = len(arr)\n l, r = 0, len(arr) - 1\n\n while l <= r:\n mid = l + (r - l) // 2\n if arr[mid] == k:\n return 1\n if arr[l] == arr[mid] == arr[r]:\n l += 1\n r -= 1\n elif arr[l] <= arr[mid]:\n if arr[l] <= k < arr[mid]:\n r = mid - 1\n else:\n l = mid + 1\n else:\n if arr[mid] < k <= arr[r]:\n l = mid + 1\n else:\n r = mid - 1\n return 0\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def Search(self, arr, key):\n # code here"
}
|
eJytVN0KwiAU7qLe4+D1CN2QsZ4kyIgogyAsykERxR6i3rezn5gW0nR5vDgg34/fdiyGz2I0qNb0gs3sSrbqkGsyAcKEorhJBESeD3Kl5Xqxz3Vzqo+5FOouFLlFYKM4bn8UQzEOZrEA7aQkYZAE6AsVg13MnyVGC2CVg2Oz3J1cJBm6QSiHFLKQIJtltBiJUUHhGFxdu37eA4JL3H/er7wDYG+zaZ00fEXtTMCPtbwYc0wIVdwW5X9R9WWg/b+dyeAtT6uUyofHG/vhvB1hIdoh9r5Qzdf5MZw/xi9Ae6XV
|
713,142
|
Absolute difference divisible by K
|
Given an array of integersof size n and an integerk, find all the pairs in the arraywhose absolute difference is divisible by k.Example 1:
Examples:
Input:
n = 3
arr[] = {3, 7, 11}
k = 4
Output:
3
Explanation:
(11-3) = 8 is divisible by 4
(11-7) = 4 is divisible by 4
(7-3) = 4 is divisible by 4
Input:
n = 4
arr[] = {1, 2, 3, 4}
k = 2
Output:
2
Explanation:
Valid pairs are (1,3), and (2,4).
Constraints:
2 ≤ n ≤ 10**5
1 ≤ k,arr[i] ≤ 10**5
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1671445136,
"func_sign": [
"static long countPairs(int n, int[] arr, int k)"
],
"initial_code": "//Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\nclass GFG {\n\tpublic static void main(String args[]) throws IOException {\n\t\tBufferedReader read =\n\t\tnew BufferedReader(new InputStreamReader(System.in));\n\t\tint t = Integer.parseInt(read.readLine());\n\t\twhile (t-- > 0) {\n\t\t\tint n = Integer.parseInt(read.readLine());\n\t\t\tString S[] = read.readLine().split(\" \");\n\t\t\tint[] arr = new int[n];\n\t\t\tfor (int i = 0; i < n; i++)\n\t\t\t\tarr[i] = Integer.parseInt(S[i]);\n\t\t\tint k = Integer.parseInt(read.readLine());\n\n\t\t\tSolution ob = new Solution();\n\t\t\tSystem.out.println(ob.countPairs(n, arr, k));\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n}",
"script_name": "GFG",
"solution": "//Back-end complete function Template for Java\n\nclass Solution {\n\tstatic long countPairs(int n, int[] arr, int k) {\n\n\t\t// intialize the count\n\t\tlong cnt = 0;\n\n\t\t// making every element of arr in\n\t\t// range 0 to k - 1\n\t\tfor (int i = 0; i < n; i++)\n\t\t{\n\t\t\tarr[i] = (arr[i] + k) % k;\n\t\t}\n\n\t\t// create an array hash[]\n\t\tlong hash[] = new long[k];\n\t\tArrays.fill(hash, 0);\n\n\t\t// store to count of element of arr\n\t\t// in hash[]\n\t\tfor (int i = 0; i < n; i++)\n\t\t{\n\t\t\thash[arr[i]]++;\n\t\t}\n\n\t\t// count the pair whose absolute\n\t\t// difference is divisible by k\n\t\tfor (int i = 0; i < k; i++)\n\t\t{\n\t\t\tcnt += (hash[i] * (hash[i] - 1)) / 2;\n\t\t}\n\n\t\t// return the value of count\n\t\treturn cnt;\n\t}\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution {\n\tstatic long countPairs(int n, int[] arr, int k) {\n\t\t// code here\n\t}\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1671445136,
"func_sign": [
"countPairs(self, n, arr, 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 arr = list(map(int, input().split()))\n k = int(input())\n\n ob = Solution()\n print(ob.countPairs(n, arr, k))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n def countPairs(self, n, arr, k):\n\n # intialize the count\n cnt = 0\n\n # making every element of arr in\n # range 0 to k - 1\n for i in range(n):\n arr[i] = (arr[i] + k) % k\n\n # create an array hash\n hash = [0]*k\n\n # store to count of element of arr\n # in hash\n for i in range(n):\n hash[arr[i]] += 1\n\n # count the pair whose absolute\n # difference is divisible by k\n for i in range(k):\n cnt += (hash[i] * (hash[i] - 1)) // 2\n\n # return the value of count\n return cnt\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def countPairs (self, n, arr, k):\n # code here"
}
|
eJy1VMtOhTAQdWH8jpOub8xMaUvxS0zEuFAWbvAuIDHxET9C/9eZcsnNNRaBYAsHEtozp2eG+Tj/er04S+O6l5ebF/PY7vvOXMFw3dq6ZciTzQ6med43913zcPfUd8cl73Vr3nY43eflwmFO7KbM9qDbmcAelmA9Clnpcyw+w6L0TISKEAklIRA8wZHQKe/wPcPqcqyDJaSjbisdC70ZZVlSIapHZak6FalaVTKlGGnlUoUpACwKOPE/oERENZw2l4lcIjR5osSCHTiAo5x/aTJ59AkKMWGZMCT0CV3CIqFNyAkpXz5ZA+JwflEtHuicqGAbV6RJ7s0zVQmbnn1mxqaq66fb/2x3zim7uVVjEPaHMHT64/h5QYowr3CEfIPa+VusW6v39z4pVIt75dCw13fsYyX72U1nLOHbz8tvRuHHUg==
|
700,243
|
Run Length Encoding
|
Given a string s, Your task is to complete the function encode that returns the run length encodedstring for the givenstring.egif the input string is “wwwwaaadexxxxxx”, then the function should return “w4a3d1e1x6″.You are required to complete the function encode that takes only one argument the string which is to be encoded and returns the encoded string.
Examples:
Input:
s = aaaabbbccc
Output:
a4b3c3
Explanation:
a repeated 4 times consecutively b 3 times, c also 3 times.
Input:
s = abbbcdddd
Output:
a1b3c1d4
Explanation:
a repeated 1 time, b 3 times, c 1 time and d repeated 4 times.
Expected Time Complexity:
O(n)
Expected Auxiliary Space:
O(1)
Constraints:
1<=( n = length of s )<=10**6
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1708940422,
"func_sign": [
"public static String encode(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.encode(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 encode(String s) {\n // Initializing an empty string to store the encoded string\n StringBuilder dest = new StringBuilder();\n\n // Iterating over each character in the source string\n for (int i = 0; i < s.length(); i++) {\n // Appending the current character to the destination string\n dest.append(s.charAt(i));\n\n // Initializing and updating a counter\n int cnt = 1;\n\n // Checking if there are consecutive characters equal to the current character\n while (i + 1 < s.length() && s.charAt(i) == s.charAt(i + 1)) {\n // Incrementing the counter\n cnt++;\n // Moving to the next character in the source string\n i++;\n }\n\n // Appending the count of consecutive characters to the destination string\n dest.append(cnt);\n }\n\n // Returning the encoded string\n return dest.toString();\n }\n}",
"updated_at_timestamp": 1730272862,
"user_code": "class Solution {\n public static String encode(String s) {\n // code here\n }\n}\n "
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1617138615,
"func_sign": [
"encode(self, s : str) -> str"
],
"initial_code": "if __name__ == \"__main__\":\n t = int(input())\n for _ in range(t):\n s = (input())\n obj = Solution()\n res = obj.encode(s)\n print(res)\n\n print(\"~\")\n",
"solution": "class Solution:\n def encode(self, s: str) -> str:\n cnt = 0\n string = ''\n i = 0\n while i < len(s):\n string += s[i]\n cnt = 1\n while i + 1 < len(s) and s[i] == s[i + 1]:\n cnt += 1\n i += 1\n if i + 1 < len(s) and s[i] == s[i + 1]:\n continue\n else:\n i += 1\n string += str(cnt)\n return string\n",
"updated_at_timestamp": 1730272862,
"user_code": "\nclass Solution:\n def encode(self, s : str) -> str:\n # code here\n \n"
}
|
eJy1VsuO00AQ5MCFv4h8XiF1e8wivgSJIOR5ePx+ZfxEID4C/oYbP8b0bjYBbcZxomydEsnqqaqu7pkfr3/9efPqAR9/2x+fvnpJWXfG+7DxYFsOFmEYSjU+wLvbeGqslTBKfqk6s/9wYKEvQcH4blt+35bet7vN/2Vqi2aPtt0RjDGdRW8xOMrWrHnf4i4wfsd6NoCjeMiFVJGOkzTLi7Kqm3Znun4Yp9lRNwQOAohwBBpiSCCFDHIooIQKamighR0Y6KCHAUaYYHaeHXIuhJRKRZHWcZwkaZpleV4UZVlVJJrkklQrcxjHaZqdrJCjQIkKI9QYY4IpZphjgSVWWGOD1gs02GGPA4444YxOViER48RNED1JDBWRJLgIBDwQgQxUELn6OBOmaaIs2GTY3tkWOsrNweSPbPB7v/MXeD6xfOJIBLUmL8lN8pMcJU/z3EWccSaYZIpFTLOYJSxlGcuZ49RDRh5DcoqE46BnAcFjQI4kVsQ0t4LSJIljraNIKSmF4Dy8LK6Y+SkkNijaBkbZ4AgboNAV1PkyuHrK7p3qDhLNqVE8pZ3vxS/O8DlnwKWYds5i5eawkdaFwnTuReVksdrxK5fJuX65/blw+FYl+MIJ9c+Te34H3WBXLJjyj0T6+1I+vUTNWyyVdc48Dsv5i+YG9/DieDf9NW8Ke6s39yveFbdfIOKaDTIsP72Oj67PP9/+BaM5kPg=
|
706,234
|
Even and Odd
|
Given an array arr[] of size N containing equal number of odd and even numbers. Arrange the numbers in such a way that all the even numbers get the even index and odd numbers get the odd index.Note: There are multiple possible solutions, Print any one of them. Also, 0-based indexing is considered.
Examples:
Input:
N = 6
arr[] = {3, 6, 12, 1, 5, 8}
Output:
1
Explanation:
6 3 12 1 8 5 is a possible solution.
The output will always be 1 if your
rearrangement is correct.
Input:
N = 4
arr[] = {1, 2, 3, 4}
Output:
1
Constraints:
1 ≤ N ≤ 10**5
1 ≤ arr[i] ≤ 10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1616193367,
"func_sign": [
"static void reArrange(int[] arr, int N)"
],
"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 \n String S[] = read.readLine().split(\" \");\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 ob.reArrange(arr,N);\n \n System.out.println(check(arr,N));\n \nSystem.out.println(\"~\");\n}\n }\n static int check(int arr[], int n)\n {\n int flag = 1;\n int c=0, d=0;\n for(int i=0; i<n; i++)\n {\n if(i%2==0)\n {\n if(arr[i]%2==1)\n {\n flag = 0;\n break;\n }\n else\n c++;\n }\n else\n {\n if(arr[i]%2==0)\n {\n flag = 0;\n break;\n }\n else\n d++;\n }\n }\n if(c!=d)\n flag = 0;\n \n return flag;\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n static void reArrange(int[] arr, int N) {\n int oddInd = 1; // index for odd elements\n int evenInd = 0; // index for even elements\n while (true) { // continue until no more swaps can be made\n while (evenInd < N && arr[evenInd] % 2 == 0) // find next even number\n evenInd += 2;\n while (oddInd < N && arr[oddInd] % 2 == 1) // find next odd number\n oddInd += 2;\n if (evenInd < N && oddInd < N) { // if both even and odd numbers exist\n int temp = arr[evenInd];\n arr[evenInd] = arr[oddInd]; // swap even and odd elements\n arr[oddInd] = temp;\n } else {\n break; // no more swaps can be made, exit the loop\n }\n }\n }\n}\n;\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution {\n static void reArrange(int[] arr, int N) {\n // code here\n }\n};"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1616193367,
"func_sign": [
"reArrange(self, arr, N)"
],
"initial_code": "# Initial Template for Python 3\ndef check(arr, n):\n flag = 1\n c = d = 0\n for i in range(n):\n if i % 2 == 0:\n if arr[i] % 2:\n flag = 0\n break\n else:\n c += 1\n else:\n if arr[i] % 2 == 0:\n flag = 0\n break\n else:\n d += 1\n if c != d:\n flag = 0\n\n return flag\n\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\n ob = Solution()\n ob.reArrange(arr, N)\n\n print(check(arr, N))\n\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n\n # Function to rearrange the elements in the given array.\n def reArrange(self, arr, N):\n oddInd = 1\n evenInd = 0\n\n while (True):\n\n # Finding the next even index.\n while (evenInd < N and arr[evenInd] % 2 == 0):\n evenInd += 2\n\n # Finding the next odd index.\n while (oddInd < N and arr[oddInd] % 2 == 1):\n oddInd += 2\n\n # Swapping the elements at even and odd indices.\n if (evenInd < N and oddInd < N):\n arr[evenInd], arr[oddInd] = arr[oddInd], arr[evenInd]\n\n else:\n break\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def reArrange(self, arr, N):\n # code here "
}
|
eJy1lEFLw0AUhD2Iv2PIucjue9kk6y8RrHjQHLzEHlooiOKP0P/qTedtC7YlTcgSS1tKk53Zb+ZlPy6/fq4u0uv2mz/uXovnbrVZFzco/LLzbtlFNKhRIaCEQuBh/xYLFO121T6u26eHl836b807L74tcCzUUCutLvdazWQJoat4iEAoVEICpILUkAYSoQ5KC4EqlDsN0ApaQxtoRDl9y174IazCB/gaPsLsSVAxEe9gN0xlsBimL7PAD42ZZGCOMStDCvRUyrck1jLhVom4SdDTo9vbqGkGk6xNMSZB8jszYo80Yo80Yo9mxB59nhcZlCyBTDXZYkppdiTb+A4i8fiE5hOlmfXkmjcgqe5/3OHJFlXmcLKvoTQG43AzMmnMpzo3tOFwamcZ29OT1WUfrYPnw8iB05u7O3PzWD26C6y3IF47qmiko+x5CHmP4f3n9S9Cadc7
|
703,061
|
Count Substrings
|
Given a binary string S. The task is to count the number of substrings that starts and end with 1.Note: The starting and the ending 1s should be different.
Examples:
Input:
S = "10101"
Output:
3
Explanation:
The 3 substrings are "101",
"10101" and "101".
Input:
S = "100"
Output:
0
Explanation:
No substring that starts and
ends with 1.
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int countSubstr(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 String s = sc.next();\n\n \t\tSystem.out.println (new Solution().countSubstr (s));\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 Solution {\n // countSubstr function to count the number of substrings in a string\n int countSubstr(String s) {\n int cnt =\n 0; // initialize a counter variable to keep track of the number of occurrences of '1' in the\n // string\n for (int i = 0; i < s.length(); ++i) // iterate through each character in the string\n {\n if (s.charAt(i) == '1') // if the character is '1'\n cnt++; // increment the counter\n }\n if (cnt\n <= 1) // if the counter is less than or equal to 1 (only one or no occurrences of '1' in the\n // string)\n return 0; // return 0\n // calculate the number of substrings using the formula\n return ((cnt) * (cnt - 1)) / 2;\n }\n}\n// Contributed By: Pranay Bansal\n",
"updated_at_timestamp": 1730470043,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n int countSubstr (String S)\n {\n // your code here \n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"countSubstr(self, S)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == \"__main__\":\n t = int(input())\n for tc in range(t):\n s = input()\n ob = Solution()\n print(ob.countSubstr(s))\n\n# Contributed By: Pranay Bansal\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n\n # Function to count the number of binary substrings.\n def countSubstr(self, s):\n cnt = 0\n\n # iterating over each character in the string.\n for i in s:\n # checking if the character is '1'.\n if i == '1':\n # if yes, incrementing the count.\n cnt = cnt + 1\n\n # returning the count of binary substrings.\n return (cnt*(cnt - 1)) // 2\n # Contributed By: Pranay Bansal\n",
"updated_at_timestamp": 1730470043,
"user_code": "#User function Template for python3\nclass Solution:\n\tdef countSubstr(self, S):\n\t\t# your code here"
}
|
eJy1lMEKgkAQhjvUU3SROUvsrBnRkwQVHcpDF/OgIETQQ9T7tjsmCv6z6KFdZReZ+fn9ZnZf8w8tZjL2S7c5POiWF1VJu4iSY87MxrjFuOn37D+Z30NxRFldZJcyu57vVdmlWW5eesZRT9BKthsi44cuwekgfe2NtMmNlKxGpiLlApzaRh5gp7PifekawE7Ssui5aIgJLE0rFUOAjhdRkgwK1tzCYN0Pjg6Wx25hUqgGqBN4QjskGP90/pY1/mo9xxV0yEQr0BBduLN1sLDUE7roPwzBlTHmwgBHrDuhoaOJIISJovYL/K+AO71XX373fZ4=
|
702,740
|
Max Length Removal
|
You are given a binary string S consisting of only characters '0' and '1'. You can repeatedly delete any occurrence of the sub-string "100" from S. Your task is to determine the length of the longest continuous sub-string that can be completely removed by applying this deletion operation.
Examples:
Input:
s = "1011100000100"
Output:
6
Explanation:
The sub-strings that can be removed are highlighted as:
101{110000}0{100}
.
First, we can remove the sub-string "110000" by transforming it into "100" and then further removing "100", leaving the string "1010" (length = 6 removed).
Then, we can remove the next "100" (length = 3 removed).
The longest removable sub-string is "110000", and its length is 6.
Input:
s = "111011"
Output:
0
Explanation:
There is no sub-string which can be make null.
Constraints:
1 ≤ string length ≤ 10**6
s[i] = {0, 1}
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615835030,
"func_sign": [
"public static int longestNull(String s)"
],
"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 s = new String(br.readLine());\n\n Solution obj = new Solution();\n System.out.println(obj.longestNull(s));\n\n System.out.println(\"~\");\n }\n }\n}\n",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\n// Java implementation of program to find\n// the maximum length that can be removed\nclass Solution {\n // User defined class Pair\n static class Pair {\n char first;\n int second;\n\n Pair(char first, int second) {\n this.first = first;\n this.second = second;\n }\n }\n\n /* Function to find the length of longest\n sub-string that can me make removed\n arr --> pair type of array whose first\n field store character in string\n and second field stores\n corresponding index of that character*/\n public static int longestNull(String str) {\n ArrayList<Pair> arr = new ArrayList<>();\n // store {'@',-1} in arr , here this value\n // will work as base index\n arr.add(new Pair('@', -1));\n int maxlen = 0; // Initialize result\n // one by one iterate characters of string\n for (int i = 0; i < str.length(); ++i) {\n // make pair of char and index , then\n // store them into arr\n arr.add(new Pair(str.charAt(i), i));\n // now if last three elements of arr[]\n // are making sub-string \"100\" or not\n while (arr.size() >= 3\n && arr.get(arr.size() - 3).first == '1'\n && arr.get(arr.size() - 2).first == '0'\n && arr.get(arr.size() - 1).first == '0') {\n // if above condition is true then\n // delete sub-string \"100\" from arr[]\n arr.remove(arr.size() - 3);\n arr.remove(arr.size() - 2);\n arr.remove(arr.size() - 1);\n }\n // index of current last element in arr[]\n int tmp = arr.get(arr.size() - 1).second;\n // This is important, here 'i' is the index\n // of current character inserted into arr[]\n // and 'tmp' is the index of last element\n // in arr[] after continuous deletion of\n // sub-string \"100\" from arr[] till we make\n // it null, difference of these to 'i-tmp'\n // gives the length of current sub-string\n // that can be make null by continuous\n // deletion of sub-string \"100\"\n maxlen = Math.max(maxlen, i - tmp);\n }\n return maxlen;\n }\n}\n",
"updated_at_timestamp": 1730468398,
"user_code": "// User function Template for Java\n\nclass Solution {\n public static int longestNull(String s) {\n // Your code goes here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615835030,
"func_sign": [
"longestNull(self,s)"
],
"initial_code": "# Initial Template for Python 3\n\ndef main():\n T = int(input())\n while T > 0:\n s = input()\n ob = Solution()\n print(ob.longestNull(s))\n T -= 1\n print(\"~\")\n\n\nif __name__ == \"__main__\":\n main()\n",
"solution": "# Back-end complete function Template for Python 3\n\n# Python3 implementation of program to find the maximum length\n# that can be removed\n# Function to find the length of longest sub-that\n# can me make removed\n# arr --> pair type of array whose first field store\n# character in and second field stores\n# corresponding index of that character\nclass Solution:\n\n def longestNull(self, S):\n arr = []\n # store {'@',-1} in arr , here this value will\n # work as base index\n arr.append(['@', -1])\n\n maxlen = 0 # Initialize result\n\n # one by one iterate characters of Sing\n for i in range(len(S)):\n # make pair of char and index , then store\n # them into arr\n arr.append([S[i], i])\n\n # now if last three elements of arr[] are making\n # sub-\"100\" or not\n while (len(arr) >= 3 and arr[len(arr) - 3][0] == '1'\n and arr[len(arr) - 2][0] == '0'\n and arr[len(arr) - 1][0] == '0'):\n # if above condition is true then delete\n # sub-\"100\" from arr[]\n arr.pop()\n arr.pop()\n arr.pop()\n\n # index of current last element in arr[]\n tmp = arr[-1]\n # This is important, here 'i' is the index of\n # current character inserted into arr[]\n # and 'tmp' is the index of last element in arr[]\n # after continuous deletion of sub-Sing\n # \"100\" from arr[] till we make it null, difference\n # of these to 'i-tmp' gives the length of current\n # sub-that can be make null by continuous\n # deletion of sub-\"100\"\n maxlen = max(maxlen, i - tmp[1])\n\n return maxlen\n",
"updated_at_timestamp": 1730468398,
"user_code": "#User function Template for python3\n\nclass Solution:\n def longestNull(self,s):\n # Your code goes here "
}
|
eJxrYJnqy8IABhFuQEZ0tVJmXkFpiZKVgpJhTJ6Bko6CUmpFQWpySWpKfH5pCVTKICavLiZPqVZHAVW9IanqDXDZYIxDhwFOHTjtMCTZVaQ7C6gDtyYz3C4zwKcPp2VwQKLHDOCAbI2E/EqCCWSaQbbFZLud5GwAtYn0pApzLlgzifGLxz5sXqIgHAlpjZ2iBwBRP1Ad
|
704,714
|
Killing Spree
|
There are Infinite People Standing in a row, indexed from 1.
A person having index 'i' hasstrength of (i*i).
You have Strength 'P'. You need to tell what is the maximum number of People You can Kill With your Strength P.
You can only Kill a person with strength 'X' if P >= 'X' and after killing him, Your Strength decreases by 'X'.
Examples:
Input:
N = 14
Output:
3
Explanation:
The strengths of people is 1, 4, 9, 16, ....
and so on. WE can kill the first 3 person ,
after which our Power becomes 0 and we cant
kill anyone else. So answer is 3
Input:
N = 10
Output:
2
Constraints:
1 ≤ T ≤ 10**3
1 ≤ N ≤ 10**12
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"long killinSpree(long 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 \n BufferedReader read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n long N = Long.parseLong(input_line[0]);\n Solution ob = new Solution();\n long ans = ob.killinSpree(N);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "class Solution {\n // Function to calculate the sum of squares up to a given number h\n long sum(long h) {\n return (h * (h + 1) * (2 * h + 1) / 6);\n }\n\n // Function to find the largest number AC such that the sum of squares up to AC is less than or\n // equal to n\n long killinSpree(long n) {\n long AC = 0;\n long sta = 0, endd = 144225;\n // Binary search to find the largest AC\n while (sta <= endd) {\n long midd = (sta + endd) / 2;\n // If the sum of squares up to midd is less than or equal to n, update AC and move the start\n // pointer\n if (sum(midd) <= n) {\n AC = Math.max(AC, midd);\n sta = midd + 1;\n } else {\n // If the sum of squares up to midd is greater than n, move the end pointer\n endd = midd - 1;\n }\n }\n return AC;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution{\n \n long killinSpree(long n)\n {\n // Code Here\n }\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"killinSpree(self, n)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n ob = Solution()\n t = int(input())\n for _ in range(t):\n N = int(input())\n ans = ob.killinSpree(N)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n def killinSpree(self, n):\n # Function to calculate the sum of squares from 1 to h\n def sumt(h):\n return (h * (h + 1) * (2 * h + 1)) // 6\n\n h = 1 # initial value for h\n AC = 0 # variable to store the maximum value of h\n sta = 0 # start index for binary search\n endd = 144225 # end index for binary search\n\n # binary search to find the maximum value of h such that sumt(h) <= n\n while sta <= endd:\n midd = (sta + endd) // 2\n if sumt(midd) <= n:\n AC = max(AC, midd) # update the maximum value of h\n sta = midd + 1\n else:\n endd = midd - 1\n return AC # return the maximum value of h\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def killinSpree (self, n):\n # code here\n\n"
}
|
eJytlD0OwjAMhRngHlXmCjk/dVJOgkSBATKwBIZWQkIgDgH3JaqIlFa4LRRPGfI5fs927tOnnU3qWG78YXVhB3eqSrZIGC8chyhYmjB7PtldaffbY1WGa0oJf/VWOHZNkyafR/EDng143fNI4FxIlaE2OXBB4JoboGo3GjMlBYfckLVLFARuoqBwaZCqXUdB4gIlJb3fOcScovu71gFHrhOwlJJyDd6F13konFMtMwNMF76vWZdrrbGF9hrQfn6T1Y1OG2X7w6ZS0mFkkWGJmhPdvVOd7QnTATCkMC/5o+Ja2sjvxQwZN/RfRNCzfsxfN7aOiQ==
|
703,171
|
Divisible by 8
|
Given a number S,you need to check whether any permutation of the number Sdivisible by 8 or not.
Examples:
Input:
S = "80"
Output:
"Divisible"
Explanation:
80 is divisible by 8
Input:
S = "101"
Output:
"Not divisible"
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"int isDivisible8(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 read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n { \n String s = read.readLine().trim();\n Solution ob = new Solution();\n if(ob.isDivisible8(s) == 1)\n System.out.println(\"Divisible\");\n else\n System.out.println(\"Not Divisible\");\n }\n }\n}",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730436740,
"user_code": "//User function Template for Java\n\nclass Solution{\n int isDivisible8(String S){\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"isDivisible8(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 if (ob.isDivisible8(s)):\n print(\"Divisible\")\n else:\n print(\"Not Divisible\")\n print(\"~\")\n",
"solution": "class Solution:\n def isDivisible8(self, S):\n # code here\n\n n = len(S) # Getting the length of the input string\n\n # List of two-digit numbers divisible by 8\n two_digit = [0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96]\n\n if len(S) > 2: # Check if the input string has more than 2 characters\n for i in range(n): # Iterate through the characters in the string\n # Iterate through the characters after the current character\n for j in range(i+1, n):\n # Iterate through the characters after the second character\n for k in range(j+1, n):\n # Check if the combined three-digit number is divisible by 8\n if (int(S[i] + S[j] + S[k]) % 8 == 0):\n return 1 # If divisible by 8, return 1\n else:\n if int(S) in two_digit: # Check if the two-digit number is in the list of numbers divisible by 8\n return 1 # If divisible by 8, return 1\n\n return 0 # If no three-digit or two-digit numbers are divisible by 8, return 0\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def isDivisible8(self, S):\n # code here"
}
|
eJxrYJnKzcoABhEsQEZ0tVJmXkFpiZKVgpJhTJ6FuaWZko6CUmpFQWpySWpKfH5pCVTWJbMsszgzKSc1Jq8uJk+pVkcBVauhkbGJqZm5hSWZ+o1MzCzItdrY1NwSpN+ATAPI1Ue2g8kNZCNjHBr98ksUCLqWbOdSZC3IZjyRS4wRRuAwo8QRYBMo8oURRYEAtp9C/VQIApAR+PMacWEBLSooTI5UClakNGZMRlDHTtEDAAtVpwA=
|
701,168
|
Modular Multiplicative Inverse
|
Given two integers ‘a’ and ‘m’. The task is to find the smallest modular multiplicative inverse of ‘a’ under modulo ‘m’. if it does not exist then return -1.
Examples:
Input:
a = 3
m = 11
Output:
4
Explanation:
Since (4*3) mod 11 = 1, 4
is modulo inverse of 3. One might think,
15 also as a valid output as "(15*3)
mod 11" is also 1, but 15 is not in
ring {0, 1, 2, ... 10}, so not valid.
Input:
a = 10
m = 17
Output:
12
Explanation:
Since (12*10) mod 17 = 1,
12 is the modulo inverse of 10.
Constraints:
1 <= a<= 10**4
1 <= m <= 10**4
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int modInverse(int a, int m)"
],
"initial_code": "//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.io.*;\nimport java.util.*;\nclass Main {\n\tpublic static void main (String[] args) {\n\t \n\t //taking input using Scanner class\n\t\tScanner sc=new Scanner(System.in);\n\t\t\n\t\t//taking testcases\n\t\tint T=sc.nextInt();\n\t\t\n\t\twhile(T-->0)\n\t\t{\n\t\t Solution obj=new Solution ();\n\t\t int a,m;\n\t\t \n\t\t \n //taking input a and m\n\t\t a=sc.nextInt();\n\t\t m=sc.nextInt();\n\t\t \n\t\t \n\t\t \n //calling function modInverse()\n\t\t System.out.println(obj.modInverse(a,m));\n\t\t \n\t\t \n\t\t\nSystem.out.println(\"~\");\n}\n\t\t\n\t}\n}\n\n",
"script_name": "Main",
"solution": "//Back-end complete function Template for Java\n\n\nclass Solution\n{\n \n public int modInverse(int a, int m)\n {\n // taking mod of a with m\n a = a%m;\n \n // For every number x, check if (a*x)%m is 1\n for (int x=1; x<m; x++)\n if ((a*x) % m == 1)\n return x;\n \treturn -1;\n }\n\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution\n{\n \n public int modInverse(int a, int m)\n {\n //Your code here\n }\n\n}\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"modInverse(self,a,m)"
],
"initial_code": "# Initial Template for Python 3\nimport math\n# Position this line where user code will be pasted.\n\n\ndef main():\n T = int(input())\n while T > 0:\n am = [int(x) for x in input().strip().split()]\n a = am[0]\n m = am[1]\n ob = Solution()\n print(ob.modInverse(a, m))\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 def modInverse(self, a, m):\n # taking mod of a with m\n a = a % m\n\n # For every number x, check if (a*x)%m is 1\n for x in range(1, m):\n if ((a * x) % m == 1):\n return x\n\n return -1\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution: \n ##Complete this function\n def modInverse(self,a,m):\n ##Your code here"
}
|
eJylVLtOBDEMpID/sFJQ3aHYifPgS5A4RAFb0CxX7ElI6E58BPwvXlid2GLCLbiKlIztGXvydv6xvjj7iptLO9y+uqd+uxvcNTne9LXWTOy9t7Nbketett3D0D3eP++G6ZWo95v+YPf7Fc3RLCGSpagQrJIVgDXlQrXkBMFrBtAQNVEu1S+HWj2lGATzLb4ArMRUiINmzJdFBKrl2aQOWCvUs4lESSNGQrZsQdaSLIdmCyoWfx7PXG1MO8R2nlGX/zUklui3yUHwcU+XV52KQipsXBq7xIHhSoy+DZNx5wwbCUuuowItL+NvALnix4xP8wg22LdKevrEk8TY3sIl2Y6TvHu/+gTrJIrA
|
701,722
|
Sort an array according to the other
|
Given two integer arrays A1[ ] and A2[ ] of size N and M respectively. Sort the first array A1[ ]such that all the relative positions of the elements in the first array are the same as the elements in the second array A2[ ].See example for better understanding.Note: If elements are repeated in the second array, consider their first occurance only.
Examples:
Input:
N = 11
M = 4
A1[] = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8}
A2[] = {2, 1, 8, 3}
Output:
2 2 1 1 8 8 3 5 6 7 9
Explanation:
Array elements of A1[] are
sorted according to A2[]. So 2 comes first
then 1 comes, then comes 8, then finally 3
comes, now we append remaining elements in
sorted order.
Input:
N = 11
M = 4
A1[] = {2, 1, 2, 5, 7, 1, 9, 3, 6, 8, 8}
A2[] = {99, 22, 444, 56}
Output:
1 1 2 2 3 5 6 7 8 8 9
Explanation:
No A1[] elements are in A2[]
so we cannot sort A1[] according to A2[].
Hence we sort the elements in non-decreasing
order.
Constraints:
1 ≤ N, M≤ 10**6
1 ≤ A1[i], A2[i] ≤10**6
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1616489310,
"func_sign": [
"public static int[] sortA1ByA2(int A1[], int N, int A2[], int M)"
],
"initial_code": "//Initial Template for Java\n\n/*package whatever //do not write package name here */\n\nimport java.util.*;\nimport java.lang.*;\nimport java.io.*;\n\nimport java.util.HashMap; \nimport java.util.Map; \nimport java.util.Map.Entry; \n\n//Position this line where user code will be pasted.\nclass Main {\n\tpublic static void main (String[] args) {\n\t\tScanner sc=new Scanner(System.in);\n\t\t\n\t\tint t=sc.nextInt();\n\t\t\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 a1[]=new int[n];\n\t\t int a2[]=new int[m];\n\t\t \n\t\t for(int i=0;i<n;i++)\n\t\t a1[i]=sc.nextInt();\n\t\t \n\t\t for(int i=0;i<m;i++)\n\t\t a2[i]=sc.nextInt();\n\t\t Solution ob=new Solution();\n\t\t a1 = ob.sortA1ByA2(a1,n,a2,m);\n\t\t for(int x:a1)\n\t\t System.out.print(x+\" \");\n\t\t \n\t\t System.out.println();\n\t\t\nSystem.out.println(\"~\");\n}\n\t}\n\t\n\n}\n",
"script_name": "Main",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n // Function to sort an array according to the other array.\n public static int[] sortA1ByA2(int A1[], int N, int A2[], int M) {\n TreeMap<Integer, Integer> map = new TreeMap<>();\n // storing all the elements of first array in map.\n for (int l = 0; l < N; l++)\n if (!map.containsKey(A1[l])) map.put(A1[l], 1);\n else map.put(A1[l], map.get(A1[l]) + 1);\n int i = 0;\n for (int l = 0; l < M; l++) {\n // if any element of second array has value more than 0 in map, we\n // store those elements in array and decrement the count in map.\n if (map.containsKey(A2[l])) {\n for (int k = 0; k < map.get(A2[l]); k++) A1[i++] = (A2[l]);\n map.remove(A2[l]);\n }\n }\n // iterating over the map which helps in storing\n // elements in increasing order.\n for (Entry<Integer, Integer> nag : map.entrySet()) {\n // storing elements whose frequency is more than 0, as many times as\n // their count in output list.\n for (int p = 0; p < nag.getValue(); p++) A1[i++] = nag.getKey();\n }\n // returning the output.\n return A1;\n }\n}\n",
"updated_at_timestamp": 1730273357,
"user_code": "//User function Template for Java\n\nclass Solution{\n // A1[] : the input array-1\n // N : size of the array A1[]\n // A2[] : the input array-2\n // M : size of the array A2[]\n \n //Function to sort an array according to the other array.\n public static int[] sortA1ByA2(int A1[], int N, int A2[], int M)\n {\n //Your code here\n }\n}\n\n"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1616489310,
"func_sign": [
"relativeSort(self,A1, N, A2, M)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n while t > 0:\n n, m = list(map(int, input().split()))\n a1 = list(map(int, input().split()))\n a2 = list(map(int, input().split()))\n\n ob = Solution()\n a1 = ob.relativeSort(a1, n, a2, m)\n print(*a1, end=\" \")\n print()\n\n t -= 1\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\nclass Solution:\n # Function to sort an array according to the other array.\n def relativeSort(self, A1, N, A2, M):\n\n d = {}\n # storing all the elements of first array in map.\n for i in A1:\n if i in d:\n d[i] += 1\n else:\n d[i] = 1\n\n ans = []\n an = []\n arr = set(A1)-set(A2)\n\n # iterating over first array.\n for i in arr:\n # if current element is present in map, we store them.\n if i in d:\n # appending element i, d[i] number of times in array an[].\n an.extend([i]*d[i])\n\n # iterating over second array.\n for i in A2:\n # if current element is present in map, we store them.\n if i in d:\n # appending element i, d[i] number of times in array ans[].\n ans.extend([i]*d[i])\n\n # storing an in list and sorting it.\n ll = list(an)\n ll.sort()\n\n # appending the list ll to array ans[].\n ans.extend(ll)\n\n # returning the output.\n return ans\n",
"updated_at_timestamp": 1730273357,
"user_code": "#User function Template for python3\n\nclass Solution:\n # A1[] : the input array-1\n # N : size of the array A1[]\n # A2[] : the input array-2\n # M : size of the array A2[]\n \n #Function to sort an array according to the other array.\n def relativeSort (self,A1, N, A2, M):\n # Your Code Here\n "
}
|
eJzVV0uO00AQZcEBOEIpGzajkfvnDydBIogFZMHGzCIjISEQh4D78uq5nfGvPAnJZDRlKY6T7nqvvl3+/frv7ZtXlPdv8eXDj83X9u5+v3knG7dtXSFp2wbpLo/L4Yrdj16SPmzbzY1sdt/vdp/3uy+fvt3v8/7htpQ3bttfWP/zRiY4SUpFo0hDkZoiFUVKiiSKRIoEiniKOIqANDZLpSr11qvNe3SByXlpfSElFGblGSoDZzaZW2aaeWcrLIu9VPyE6Q4gYBXEleKAX4trxBfiFW7bAk6/Ffqr/ocVpWnA0mJq9wSIimdQqiWAEQOlIQtdnPUhmHCT5ZZqzzyKTIYcHlJCjLL1ifTSyH41c/ps8RgtI6WOEKICsEZRj/NCR/Uhh6Aj8+5DFahmHpFEkMTIJZPpYFXP8sBxSHCQChbTJLXWIZaBZJNzqIZCr24tqIymqrKaiBV9BGAtGvGRTBUl0BZRnVDmbUfP1x5sGHr5gFsdMpmgZgsIBesSNw+GYIuNpWIoyY7tPK/HAVkKGjPIM7USg1ZpT9KS9nbnsrcwZnGQU8N4jeqW1EtaYkYwqQLeYiMRkasklhK1vUmEVwGFpllIaCSgOsGjlJAkaOOTAMc7uby/wAMA2FkrtKMJTo2GbuBHOzce3ZkzPo2zpS/IhxoeZIvaVKmJMFTN9TQ90Rm1OkY9FOiwROdV6kt41Oq7hVZf3+de/JX783qre6R7v/zrSRokkukZWmTskC85NfBsOml0GGXPMUfRxZo3ivgq7fuU5q2knmJYsAeE6VywGhJv9roldgv0OPodSa6WeQvvSems7M1inJ11LNDpqXYm69MORV9f51h0tHftVJrYnOaJFDI9EG9OSqLRqDJMnkZhVJmqPiO/z5qCF4bgY8ff/3hnLK7w1njm6+KBpHkCIGorZ0AXr+NOgpXgGO0mk/r45/YfKx145A==
|
703,114
|
Factorials of large numbers
|
Given an integer N, find its factorial.return a list of integers denoting the digits that make up the factorial of N.Example 1:
Examples:
Input:
N = 5
Output:
[1,2,0]
Explanation
: 5! = 1*2*3*4*5 = 120
Input:
N = 10
Output:
[3,6,2,8,8,0,0]
Explanation
:
10! = 1*2*3*4*5*6*7*8*9*10 = 3628800
Constraints
:
1 ≤ N ≤ 1000
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1730504080,
"func_sign": [
"public static ArrayList<Integer> factorial(int n)"
],
"initial_code": "// Initial Template for Java\n\nimport java.io.*;\nimport java.util.*;\n\n//Position this line where user code will be pasted.\n\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 N = sc.nextInt();\n Solution ob = new Solution();\n ArrayList<Integer> ans = ob.factorial(N);\n for (Integer val : ans) System.out.print(val + \" \");\n System.out.println();\n\n System.out.println(\"~\");\n }\n }\n}",
"script_name": "GfG",
"solution": "class Solution {\n\n // Method to calculate the factorial of a number n\n public ArrayList<Integer> factorial(int n) {\n // ArrayList to store the result of the factorial\n ArrayList<Integer> number = new ArrayList<>();\n // Initializing the result with 1 (since 0! = 1 and 1! = 1)\n number.add(1);\n\n // Loop from 2 to n, multiplying the current result by i at each step\n for (int i = 2; i <= n; i++) {\n multiply(i, number);\n }\n\n Collections.reverse(number);\n return number; // Return the factorial as a list of digits\n }\n\n // Helper method to multiply the current result by n\n private void multiply(int n, ArrayList<Integer> number) {\n int carry = 0; // Initialize carry to handle values greater than 9\n\n // Traverse each digit in the current result\n for (int i = 0; i < number.size(); i++) {\n // Multiply n with the current digit\n int num = n * number.get(i);\n // Set the last digit of (num + carry) to current position\n number.set(i, (num + carry) % 10);\n carry = (num + carry) / 10;\n }\n\n // Handle remaining carry, if any, by adding additional digits to the result\n while (carry > 0) {\n // Add the last digit of carry to the result\n number.add(carry % 10);\n // Update carry by removing the last digit\n carry /= 10;\n }\n }\n}",
"updated_at_timestamp": 1731327142,
"user_code": "// User function Template for Java\n\nclass Solution {\n public static ArrayList<Integer> factorial(int n) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1730504080,
"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 ans = ob.factorial(N)\n # Join each digit to form the full number without spaces\n print(\" \".join(str(i) for i in ans))\n print(\"~\")\n",
"solution": "class Solution:\n\n def factorial(self, N):\n number = [1]\n\n for i in range(2, N + 1):\n self.multiply(i, number)\n\n number.reverse()\n return number\n\n def multiply(self, n, number):\n carry = 0\n\n for i in range(len(number)):\n num = n * number[i]\n number[i] = (num + carry) % 10\n carry = (num + carry) // 10\n\n while carry > 0:\n number.append(carry % 10)\n carry //= 10\n",
"updated_at_timestamp": 1731327142,
"user_code": "#User function Template for python3\n\nclass Solution:\n def factorial(self, n):\n #code here"
}
|
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
|
705,707
|
Count the paths
|
Given a Directed acyclic graph(DAG) with n nodes labelled from 0 to n-1. Given edges, start, and destination, count the number of ways to reach from start to destination. There is a directed Edge from vertex edges[i][0] to the vertex edges[i][1]. Your task is to find the number of ways to reach from start to destination.
Examples:
Input:
edges = [[0,1], [0,3], [0,2], [2, 0], [2,1], [1,3]], n = 4, start = 0, destination = 3
Output:
3
Explanation:
There are three ways to reach at 3 from 0. These are : 2->1->3 , 2->0->3 and 2->0->1->3.
Input:
edges = [[0,1]], n = 2, start = 0, destination = 1
Output:
1
Explanation:
There is only one way to reach at 1 from 0 that is : 0->1.
Constraints:
1 <= n <= 15
0 <= start, destination, edges[i][0], edges[i][1] <= n-1
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int possible_paths(int[][] edges, int n, int start, int destination)"
],
"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 n = Integer.parseInt(S[0]);\n int m = Integer.parseInt(S[1]);\n int s = Integer.parseInt(S[2]);\n int d = Integer.parseInt(S[3]);\n int[][] edges = new int[m][2];\n for (int i = 0; i < m; i++) {\n String[] S1 = br.readLine().trim().split(\" \");\n edges[i][0] = Integer.parseInt(S1[0]);\n edges[i][1] = Integer.parseInt(S1[1]);\n }\n Solution obj = new Solution();\n int ans = obj.possible_paths(edges, n, s, d);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730479277,
"user_code": "// User function Template for Java\n\nclass Solution {\n public int possible_paths(int[][] edges, int n, int start, int destination) {\n // Code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"possible_paths(self, edges, n, start, destination)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n n, m, s, d = input().split()\n n = int(n)\n m = int(m)\n s = int(s)\n d = int(d)\n edges = []\n for _ in range(m):\n x, y = input().split()\n x = int(x)\n y = int(y)\n edges.append([x, y])\n obj = Solution()\n ans = obj.possible_paths(edges, n, s, d)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n # Function to count the number of paths from starting node s to destination node d\n def count_dfs(self, graph, u, d, vis):\n # If the current node is the destination, return 1\n if u == d:\n return 1\n # Mark the current node as visited\n vis[u] = True\n ans = 0\n # Iterate through each adjacent node of the current node\n for v in graph[u]:\n # If the adjacent node has not been visited, recursively count the number of paths\n if not vis[v]:\n ans += self.count_dfs(graph, v, d, vis)\n # Mark the current node as unvisited\n vis[u] = False\n # Return the number of paths from starting node s to destination node d\n return ans\n\n # Function to find all possible paths from starting node s to destination node d\n def possible_paths(self, edges, n, start, destination):\n # Create adjacency list representation of the graph\n graph = [[] for i in range(n)]\n for e in edges:\n graph[e[0]].append(e[1])\n # Create a boolean array to keep track of visited nodes\n vis = [False for i in range(n)]\n # Call the count_dfs function to count the number of paths\n return self.count_dfs(graph, start, destination, vis)\n",
"updated_at_timestamp": 1731593285,
"user_code": "#User function Template for python3\n\nclass Solution:\n def possible_paths(self, edges, n, start, destination):\n #Code here"
}
|
eJzFVbtOAzEQvIIC/mLlOkK2z0++BAkjCkhBY1IkEhIK4iPgY+nwrk1yBPmILwFS2MrK3p2ZnT2/nLx1Zx39Lt9Pu+7qid3HxWrJLoCJEIUGyYGDUCGmFReZotDjkmISNC4mxB5siApciBp8iAYED9GCSHcciHTJg8BbOZcQeZN562nrMY/cHJNsBmz+uJjfLud3Nw+rZYGVSjyHyNYz2MGKd4Cqa8xkEJFFRC7H6C9ho5jeQPWIjmKmsWaihvLYoo5AdSSq06M6Ktf4xLLVLolVKWRGyOlUyQ/7wL/2gfRTWEkjG+JFhF1m6PGcxXMO7/pGCEnABOC7EbZ8CxRVSawqiVM/UmI9oiERLRV1Y3abW2R+atGOmLzqBV33gmzwgiqDI3Lrsj8mWH7oimIuPXQ7zzgIgtmY3xeu5BmdDUHT5yoQbIsxRz4QW3e6oTtFPkJgasasQdirw/xILZ427v8y74cO/L6Ghl909AG8YTLx6WN13Lk65DWb9JyNDfNfTXPba9D2HPDKYba+fj3/AOUbh8A=
|
703,872
|
Repeated IDs
|
Geek is given a task to select at most 10 employees for a company project. Each employee is represented by a single-digit ID number which is unique for all the selected employees for the project. Geek has a technical problem in his system which printed ID number multiple times. You are given array arrhaving all printed IDs. Help him to get rid of the repeated IDs.
Examples:
Input:
arr[] = [8, 8, 6, 2, 1]
Output:
[8, 6, 2, 1]
Explanation:
8 is repeated, so takes 8 single time.
Input:
arr[] = [7, 6, 7, 4, 2, 7]
Output:
[7, 6, 4, 2]
Explanation:
7 and 6 are repeated, so take 7 and 6 single time.
Constraints:
1 ≤ arr.size() ≤ 10**6
0 ≤ arr[i] ≤ 9
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public ArrayList<Integer> uniqueId(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().uniqueId(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": "None",
"updated_at_timestamp": 1729753320,
"user_code": "// User function Template for Java\n\nclass Solution {\n public ArrayList<Integer> uniqueId(int[] arr) {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"uniqueId(self, arr)"
],
"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\n while t > 0:\n arr = list(map(int, input().split()))\n ob = Solution()\n ans = ob.uniqueId(arr)\n print(*ans)\n print(\"~\")\n t -= 1\n",
"solution": "class Solution:\n\n def uniqueId(self, arr):\n h = [0] * 10 # list to keep track of the count of each element\n v = [] # list to store the unique elements\n\n for k in arr:\n if h[k] == 0: # check if the element has already been encountered\n v.append(k) # add the element to the list\n h[k] += 1 # update the count of the element\n\n return v # return the list containing unique elements\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def uniqueId(self, arr):\n # code here\n "
}
|
eJytU8sOgjAQ9GD8jknPxPAqgl9iIsaDcvCCHCAhMT5OfoH+r6sxRmSX0ApzIdvp7LYzvYzv18no9S3O9LM8qF1eVKWaQ3lp7oJBmisHKquLbFNm2/W+Kt8baOVEi0cHTZUEDESVRFDx4CNACI0IM8SkIU/CcoXZYmJExAxphw+vQ5Xlsqoa1hC7a6GXC+a07ZrsGscVOjE30K51dGK4/RPTDxa5soacPwOvTBLY3yttkiJXIP/SxLkYB01dMLzJtvP6WezyHyYvaBgXjPMkjvLFIlrwR+4GPmKT+ZG20l7dpg9yc6/8
|
702,054
|
Search an element in sorted and rotated array
|
Given a sorted and rotated array A of N distinct elements which are rotated at some point, and given an element K. The task is to find the index of the given element K in array A.
Examples:
Input:
N = 9
A[] = {5,6,7,8,9,10,1,2,3}
K = 10
Output:
5
Explanation:
10 is found at index 5.
Input:
N = 3
A[] = {3,1,2}
K = 1
Output:
1
Constraints:
1 ≤ N ≤ 10**7
0 ≤ A
i≤ 10**8
1 ≤ K ≤ 10**8
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1617909219,
"func_sign": [
"static int Search(int array[], int target)"
],
"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 = sc.nextInt();\n\n while(t > 0){\n \tint n = sc.nextInt();\n \tint[] array = new int[n];\n \tfor(int i=0; i<n; i++)\n \t{\n \t\tarray[i] = sc.nextInt();\n \t}\n \tint target = sc.nextInt();\n\n Solution ob = new Solution();\n\t\t\tSystem.out.println(ob.Search(array,target));\n t--;\n \nSystem.out.println(\"~\");\n}\n } \n} ",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n // Function to perform binary search on the rotated sorted array\n static int Search(int array[], int target) {\n int n = array.length;\n int low = 0, high = n - 1, ans = -1;\n // Perform binary search until low index is less than or equal to high index\n while (low <= high) {\n int mid = (low + high) / 2;\n // If target is found at mid index, update ans and break the loop\n if (target == array[mid]) {\n ans = mid;\n break;\n }\n // Check if left half of the array is in sorted order\n if (array[low] <= array[mid]) {\n // Check if target is present in the left half of the array\n if (array[low] <= target && target <= array[mid]) {\n high = mid - 1;\n } else {\n low = mid + 1;\n }\n }\n // Check if right half of the array is in sorted order\n else {\n // Check if target is present in the right half of the array\n if (array[mid] < array[high]) {\n if (array[mid] <= target && target <= array[high]) {\n low = mid + 1;\n } else {\n high = mid - 1;\n }\n }\n }\n }\n // Return the index of the target or -1 if it is not found\n return ans;\n }\n}\n",
"updated_at_timestamp": 1730272891,
"user_code": "//User function Template for Java\n\nclass Solution \n{ \n static int Search(int array[], int target)\n\t{\n\t // code here\n\t}\n} \n\n"
}
|
{
"class_name": null,
"created_at_timestamp": 1617909219,
"func_sign": [
"Search(arr,n,k)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n tcs = int(input())\n for _ in range(tcs):\n n = int(input())\n arr = [int(x) for x in input().split()]\n k = int(input())\n\n print(Search(arr, n, k))\n\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\n\ndef search(arr, l, h, key):\n if l > h:\n return -1\n\n mid = (l + h) // 2\n if arr[mid] == key:\n return mid\n\n # If arr[l...mid] is sorted\n if arr[l] <= arr[mid]:\n\n # As this subarray is sorted, we can quickly\n # check if key lies in half or other half\n if key >= arr[l] and key <= arr[mid]:\n return search(arr, l, mid - 1, key)\n return search(arr, mid + 1, h, key)\n\n # If arr[l..mid] is not sorted, then arr[mid... r]\n # must be sorted\n elif key >= arr[mid] and key <= arr[h]:\n return search(arr, mid + 1, h, key)\n return search(arr, l, mid - 1, key)\n\n\ndef Search(arr, n, k):\n return search(arr, 0, n - 1, k)\n",
"updated_at_timestamp": 1730272891,
"user_code": "#User function Template for python3\n\ndef Search(arr,n,k):\n #code here"
}
|
eJztlt2KFDEQhb3wzpf4mOtVuiqppOKTCLZ4oXMhQrvILAii+BD6vlbPjDrump2dH1kQhww03V0n55ycVPrLw2/vHz1Y/569jYvnHxdvpsur1eIpCxknHcZJDClIRRxp6ICgJDJGoeI0JG4KokhC8jjFWFywWH64XL5aLV+/fHe12oK2cfocDz9d8PtMFjOlgSSkAE+kTDJSIVWSkxp5IAtZyTF3Jhu5kCvZyQ3bT4ubSjRqFE1oRg0taEUdbRtGHRGzLX9UIUM8McEUS1hwMaxgFXOsUQaKUJSSKJkSVAulUpzSqANVqEpN1Ew1aiipVKc2fMAFVzzhGTe84CHU8UYbaEJTWqJlmtEKrdLCh9mIM9vDaWs1TtX67uaeuzY7fIPzdV3xkvbBe9gz9Obfqeytuc7bhD3F0ot9jDXvUBGmHEw76n+o34jo1HctvW2D3wZYOoB1vY1j/ecNOaxDFMHxoOkHY53QEzi2KcgJXaG3yL/GNiRHRMx0J2R5ODBmPwHE90E87qr439vu0NuObW3Xzf233C1+z/7edys5Wy+5wxeZnOuTbD5bJO+eLvXg42UTa9ltGmuW5wz23032mRNqW6tefH3yHYDLrik=
|
706,217
|
3 sum closest
|
Given an array A[]ofNintegers and an integerX.The task is to find the sum of three integers in A[]such that it is closest toX.
Examples:
Input:
N = 4
A[] = {-1 , 2, 1, -4}
X = 1
Output:
2
Explanation:
Sums of triplets:
(-1) + 2 + 1 = 2
(-1) + 2 + (-4) = -3
2 + 1 + (-4) = -1
2 is closest to 1.
Input:
N = 5
A[] = {1, 2, 3, 4, -5}
X = 10
Output:
9
Explanation:
Sums of triplets:
1 + 2 + 3 = 6
2 + 3 + 4 = 9
1 + 3 + 4 = 7
...
9 is closest to 10.
Constraints:
3 ≤ N ≤ 10**3
-10**3≤ Arr[i]≤ 10**3
-10**4≤ X≤ 10**4
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1618854875,
"func_sign": [
"static int closest3Sum(int A[], int N, int X)"
],
"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 read = new BufferedReader(new InputStreamReader(System.in));\n int t = Integer.parseInt(read.readLine());\n while(t-- > 0)\n {\n int N = Integer.parseInt(read.readLine());\n String input_line[] = read.readLine().trim().split(\"\\\\s+\");\n int Arr[]= new int[N];\n for(int i = 0; i < N; i++)\n Arr[i] = Integer.parseInt(input_line[i]);\n int X = Integer.parseInt(read.readLine());\n \n Solution ob = new Solution();\n System.out.println(ob.closest3Sum(Arr, N, X));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n static int closest3Sum(int[] arr, int target) {\n int n = arr.length;\n Arrays.sort(arr);\n int res = 0;\n int minDiff = Integer.MAX_VALUE;\n for (int i = 0; i < n - 2; i++) {\n // Initialize the left and right pointers\n int l = i + 1, r = n - 1;\n while (l < r) {\n int currSum = arr[i] + arr[l] + arr[r];\n // If |currSum - target| < minDiff, then we have\n // found a triplet which is closer to target\n if (Math.abs(currSum - target) < minDiff) {\n minDiff = Math.abs(currSum - target);\n res = currSum;\n }\n // If multiple sums are closest, take maximum one\n else if (Math.abs(currSum - target) == minDiff) {\n res = Math.max(res, currSum);\n }\n // If currSum > target then we will decrease the\n // right pointer to move closer to target\n if (currSum > target) r--;\n // If currSum <= target then we will increase the\n // left pointer to move closer to target\n else l++;\n }\n }\n return res;\n }\n}\n;\n",
"updated_at_timestamp": 1730266731,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n static int closest3Sum(int A[], int N, int X)\n {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1618854875,
"func_sign": [
"closest3Sum(self, A, N, X)"
],
"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 Arr = input().split()\n for itr in range(N):\n Arr[itr] = int(Arr[itr])\n X = int(input())\n ob = Solution()\n print(ob.closest3Sum(Arr, N, X))\n print(\"~\")\n",
"solution": "class Solution:\n def closest3Sum(self, Arr, N, X):\n # Sorting the array to easily find the closest sum\n Arr.sort()\n closestSum = 2**32\n\n # iterating over all possible combinations of three numbers\n for i in range(N-2):\n ptr1 = i+1\n ptr2 = N-1\n\n # comparing the sum with the target value and updating closestSum\n while ptr1 < ptr2:\n Sum = Arr[i]+Arr[ptr1]+Arr[ptr2]\n\n if abs(X-Sum) < abs(X-closestSum):\n closestSum = Sum\n # if both sums are equally close to the target, update closestSum\n elif abs(X - Sum) == abs(X - closestSum):\n closestSum = Sum\n\n # adjusting the pointers based on the sum value\n if Sum > X:\n ptr2 -= 1\n else:\n ptr1 += 1\n\n return closestSum\n",
"updated_at_timestamp": 1730266731,
"user_code": "#User function Template for python3\n\nclass Solution:\n def closest3Sum(self, A, N, X):\n # code here"
}
|
eJylVMFOwzAM5YD4DqvnBaVp0zZ8BTeQCOIAPXAJO3QSEgLxEfC/+KVZKahu121TrC2xn+3nl3yef99cnMXP7TX/uHvLnsN212VXlOU+5BpLa1LROudIwVhswWjK+YyMD4Ydsg1l7eu2fezap4eXXZeAcOTDhw/Z+4b+Jmh8YGhSRlOhqdSMTJWmmrcajrESpJUAKy6Yhq8PhQBQCPE5txI7UyVMoWNxPQHoli3+Yh8O8Kx0YklIlcvt11xgQuzxY5o+YYEoCVMCtOCMS+MZla7hVfMCJ1Yuj50ENJemPxp3LwRleE5YubG8ZWx0lBLgeJpsG3Xzn81fAtIUYv5qJDf2OJZySDo1ASUDcehxP4vRAGTe7NxUp3QyzPao0hcDl9V1orx6zsHaYRUoN3BxcMzsk4Dp7SUOTc8/EZM96DX8rUhWGsf3rDa4axPMLUjpZJWOHq6Zi77uDQZVEulJPYvc339d/gDbrLkz
|
704,209
|
N-divisors
|
Given three integers A, B, N. Your task is to print the number of numbers between A and B including them,which have N-divisors. A number is called N-divisor if it has total N divisors including 1 and itself.
Examples:
Input:
A = 1
B = 7
N = 2
Output:
4
Explanation:
2,3,5,7 have 2-divisors
Input:
A = 1
B = 25
N = 3
Output:
3
Explanation:
4,9,25 are the numbers
having 3-divisors
Constraints:
1<=A<=B<=10**4
1 <= N <= 16
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int count(int A,int B,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 String S[] = read.readLine().split(\" \");\n int A = Integer.parseInt(S[0]);\n int B = Integer.parseInt(S[1]);\n int N = Integer.parseInt(S[2]);\n Solution ob = new Solution();\n System.out.println(ob.count(A,B,N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n static int count(int A, int B, int N) {\n int count = 0;\n // loop for every number from A to B\n for (int i = A; i <= B; i++) {\n int c = 0;\n // count how many factors number i have\n for (int j = 1; j * j <= i; j++) {\n if (i % j == 0) {\n c++;\n if ((i / j) != j) c++;\n }\n }\n // if number of factors of i equals N increase count\n if (c == N) count++;\n }\n // return answer\n return count;\n }\n}\n",
"updated_at_timestamp": 1730474447,
"user_code": "//User function Template for Java\nclass Solution{\n static int count(int A,int B,int N){ \n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"count(self,A,B,N)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n A, B, N = input().split()\n A = int(A)\n B = int(B)\n N = int(N)\n ob = Solution()\n print(ob.count(A, B, N))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def count(self, A, B, N):\n count = 0\n # loop for every number from A to B\n for i in range(A, B+1):\n c = 0\n j = 1\n # count how many factors number i have\n while j*j <= i:\n if i % j == 0:\n c += 1\n if (i/j) != j:\n c += 1\n j += 1\n # if number of factors of i equals N increase count\n if c == N:\n count += 1\n # return answer\n return count\n",
"updated_at_timestamp": 1730474447,
"user_code": "#User function Template for python3\n\nclass Solution:\n def count(self,A,B,N): \n # code here"
}
|
eJxrYJm6j4UBDCK2AxnR1UqZeQWlJUpWCkqGMXmGCkAYk6eko6CUWlGQmlySmhKfX1qCUFAHlKzVUcDUZYRTlwFuXQZ4LMOrzYR0bUC7DIDYjCwLgYBMH4J0GpOs09LS0gCqmXSvmoK0mYEIU9ItBmmDWExRSBnGxJAfWJQlDnRDDAwMwTxgsFAWHqS7RQFiMynZyQCHYnRlBkQqRHJIXkwMeuogI6cTCF8yQon0aI+dogcAKcFuPw==
|
705,088
|
Party in Town
|
Geek town has N Houses numbered from 1 to N. They are connected with each other via N-1 bidirectional roads. Givenan adjacency list adjto represent the connections. To host the optimal party, you need to identifythe house from which the distance to the farthest house isminimum. Find thisdistance.
Examples:
Input:
N = 4
adj = {{2},{1,3,4},{2},{2}}
Output:
1
Explanation:
Party should take place at house number 2.
Maximum distance from house number 2 is 1.
Input:
N = 4
adj = {{2},{1,3},{2,4},{3}}
Output:
2
Explanation:
Party should take place at house number 2 or 3.
So, the minimum distance between the farthest
house and the party house is 2.
Constraints:
1 <=N <=1000
1 <= adj[i][j] <= N
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"static int partyHouse(int N, ArrayList<ArrayList<Integer>> adj)"
],
"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 ArrayList<ArrayList<Integer>> adj = new ArrayList<ArrayList<Integer>>();\n \t\tfor(int i = 0;i < N+1;i++){\n \t ArrayList<Integer> arr = new ArrayList<Integer>();\n \t adj.add(arr);\n \t\t}\n \t\tfor(int i = 0;i < N-1;i++){\n \t\t String a[] = in.readLine().trim().split(\"\\\\s+\");\n \t\t int x = Integer.parseInt(a[0]);\n \t\t int y = Integer.parseInt(a[1]);\n \t\t adj.get(x).add(y);\n \t\t adj.get(y).add(x);\n \t\t}\n \t\t\n \t\tSolution ob = new Solution();\n \t\tSystem.out.println(ob.partyHouse(N, adj));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "class Solution {\n static int dfs(int node, int par, ArrayList<ArrayList<Integer>> adj) {\n int maxi = 0;\n for (int u : adj.get(node)) {\n if (u != par) maxi = Math.max(maxi, dfs(u, node, adj));\n }\n if (par != 0) // check if node is not the root node\n return 1 + maxi; // return 1 plus the maximum depth of its children\n else return maxi; // if root node, return maximum depth of its children\n }\n\n static int partyHouse(int N, ArrayList<ArrayList<Integer>> adj) {\n int mini = Integer.MAX_VALUE; // initialize variable to store minimum depth\n for (int i = 1; i <= N; i++) {\n int h = dfs(i, 0, adj); // calculate maximum depth for each node\n mini = Math.min(mini, h); // update minimum depth if needed\n }\n return mini; // return the minimum depth\n }\n}\n",
"updated_at_timestamp": 1730477356,
"user_code": "//User function Template for Java\n\nclass Solution{\n static int partyHouse(int N, ArrayList<ArrayList<Integer>> adj)\n {\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"partyHouse(self, N, adj)"
],
"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 adj = [[] for x in range(N+1)]\n for i in range(N-1):\n x, y = [int(a) for a in input().split()]\n adj[x].append(y)\n adj[y].append(x)\n\n ob = Solution()\n print(ob.partyHouse(N, adj))\n print(\"~\")\n",
"solution": "class Solution:\n # Function to perform depth-first search to find the maximum depth of a node.\n def dfs(self, i, vis, d):\n # update the maximum depth\n self.md = max(self.md, d)\n # mark the current node as visited\n vis[i] = True\n # explore all adjacent nodes\n for k in self.adj[i]:\n # if the adjacent node is not visited, recursively call dfs\n if not vis[k]:\n self.dfs(k, vis, d + 1)\n\n # Function to find the minimum number of rooms required to accommodate all guests\n def partyHouse(self, N, adj):\n # initialize minimum rooms needed to a large value\n mini = 10**10\n # store the adjacency list of the graph\n self.adj = adj\n # iterate over all guests\n for i in range(1, N + 1):\n # initialize maximum depth for each guest\n self.md = 0\n # mark all nodes as unvisited\n vis = [False] * (N + 1)\n # find the maximum depth of the current guest using dfs\n self.dfs(i, vis, 0)\n # update the minimum rooms needed\n mini = min(mini, self.md)\n # return the minimum rooms needed to accommodate all guests\n return mini\n",
"updated_at_timestamp": 1730477356,
"user_code": "#User function Template for python3\n\nclass Solution:\n def partyHouse(self, N, adj):\n # code here"
}
|
eJytlD1Ow0AQhV0A53jaOkKe/bU5CRKLKMAFzZLCkSIhEIeAw9KxsxgSIGNYCxdp7Pf589uZPB29NCdNuc5fj5vm4l7dpvVmVGdQFJOOiaDVCmrYrofrcbi5utuMu/uPMamHFb6GXAnlMExMBjYmCycwtMDw+ww9MTIavhLUTSD6lDETiH9CTAGdgDQCktpDHzgx/cTMb0YfUw9qBbyT8MLzrfC82X1h5UHZ/W4ItjKu2295bsRxI54bCdxIx4303Ai31oGodMKhFsQxArGHBvHcGBAfvQXlODkQn58HZQQFaKnLIHXpDitqVjSsaFjRsqItiq4o+qIYimFXBLO0NMPinLyPce15llikZcG0IMOTvCRHbLlAc259wp/XR1r4GTz+ZT3rtv/jP1R8z0zD9d2ipH5u9q+gy+fTN3ryzNE=
|
703,715
|
Addition of Two Numbers
|
Given two numbers Aand B. Your task is to return the sum of A and B.
Examples:
Input:
A = 1, B = 2
Output:
3
Explanation:
Addition of 1 and 2 is 3.
Input:
A = 10, B = 20
Output:
30
Explanation:
Addition os 10 and 20 is 30.
Constraints:
1 <= A, B<= 10**18
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1618328593,
"func_sign": [
"static int addition(int A, int B)"
],
"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[] inp=read.readLine().split(\" \");\n int A=Integer.parseInt(inp[0]);\n int B=Integer.parseInt(inp[1]);\n Solution ob = new Solution();\n System.out.println(ob.addition(A,B));\n }\n }\n}\n",
"script_name": "GFG",
"solution": "None",
"updated_at_timestamp": 1730472762,
"user_code": "//User function Template for Java\nclass Solution{\n static int addition(int A, int B){\n // code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1618328593,
"func_sign": [
"addition(ob,A,B)"
],
"initial_code": "# Initial Template for Python 3\nif __name__ == '__main__':\n t = int(input())\n for _ in range(t):\n A, B = map(int, input().strip().split(\" \"))\n ob = Solution()\n print(ob.addition(A, B))\n print(\"~\")\n",
"solution": "class Solution:\n # Function to add two numbers.\n def addition(self, A, B):\n return A + B\n",
"updated_at_timestamp": 1730472762,
"user_code": "#User function Template for python3\nclass Solution:\n def addition (ob,A,B):\n # code here "
}
|
eJxrYJn6jYkBDCLeAxnR1UqZeQWlJUpWCkqGMXmGCoZKOgpKqRUFqcklqSnx+aUlUEmjmLy6mDylWh0FNB0GCkYGOPQYG+DSpGCESwsOHQYKuCzBaQdQCy7PGBpi04TLBmzuh/mc1OAyAOk0ALrZ0NAAT8hhdR8kGEgNB4iNCmArwSFPlsWGBoZ4gtMAp3eJthir82F68fscXRNudbFT9ADlFejY
|
703,905
|
Sum Of Digits
|
Given a number,N. Find the sum of all the digits of N
Examples:
Input:
N = 12
Output:
3
Explanation:
Sum of 12's digits:
1 + 2 = 3
Input:
N = 23
Output:
5
Explanation:
Sum of 23's digits:
2 + 3 = 5
Constraints:
1<=N<=10**5
|
geeksforgeeks
|
Easy
|
{
"class_name": "Solution",
"created_at_timestamp": 1619087265,
"func_sign": [
"static int sumOfDigits(int N)"
],
"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 int N = Integer.parseInt(read.readLine());\n Solution ob = new Solution();\n System.out.println(ob.sumOfDigits(N));\n \nSystem.out.println(\"~\");\n}\n }\n}",
"script_name": "GFG",
"solution": "// Back-end complete function Template for Java\nclass Solution {\n static int sumOfDigits(int N) {\n int count = 0;\n while (N > 0) {\n // extract the last digit\n int b = N % 10;\n // add it to count\n count += b;\n // remove the last digit\n N = N / 10;\n }\n return count;\n }\n}\n",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\nclass Solution{\n static int sumOfDigits(int N) {\n // code here\n }\n}\n "
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1619087265,
"func_sign": [
"sumOfDigits(self, 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.sumOfDigits(N))\n print(\"~\")\n",
"solution": "# Back-end complete function Template for Python 3\nclass Solution:\n def sumOfDigits(self, N):\n count = 0\n while N > 0:\n # extract the last digit\n b = N % 10\n # add it to count\n count += b\n # remove the last digit\n N = N // 10\n return count\n",
"updated_at_timestamp": 1729753320,
"user_code": "#User function Template for python3\n\nclass Solution:\n def sumOfDigits (self, N):\n # code here"
}
|
eJytk80KgkAUhVv4IDJriZk7Pzo9SZDRoly0mVwoBFH0EPUq7Xq3ZkqFhDMSdDcKes49fnO8JvdnMnvP8uFvVie2d3XbsEXKROlskRvNspRVx7raNtVuc2ib7rHUpbuUjp2z9FskwgAR0mglCWkEXMQ5RyICGhsGaBRcRFIhDDCdyQvLETuOOIRBn4Q5CMhBAg0pU6B0FE03AZEM4tEbQCp5rBz+OlhAB4GWjy2cnkwDvULtfu7dB9w/Y/h+9dWEYkJxxPg0Iw3HHpEfHR5Ex6Hfi3nY8ErsJxrIrG/zFwCbcok=
|
705,719
|
Negative weight cycle
|
Given a weighted directed graph with n nodes and m edges. Nodes are labeled from 0 to n-1, the task is to check if it contains a negative weight cycle or not.Note:edges[i] isdefined as u, v and weight.
Examples:
Input:
n = 3, edges = {{0,1,-1},{1,2,-2},
{2,0,-3}}
Output:
1
Explanation:
The graph contains negative weight
cycle as 0->1->2->0 with weight -1,-2,-3.
Input:
n = 3, edges = {{0,1,-1},{1,2,-2},
{2,0,3}}
Output:
0
Explanation:
The graph does not contain any
negative weight cycle.
Constraints:
1 <= n <= 100
0 <= m <= n*(n-1)
, where m is the total number of Edges in the directed graph.
|
geeksforgeeks
|
Medium
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"public int isNegativeWeightCycle(int n, int[][] edges)"
],
"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[] S1 = br.readLine().trim().split(\" \");\n int n = Integer.parseInt(S1[0]);\n int m = Integer.parseInt(S1[1]);\n int[][] edges = new int[m][3];\n for(int i = 0; i < m; i++){\n String S2[] = br.readLine().trim().split(\" \");\n for(int j = 0; j < 3; j++)\n edges[i][j] = Integer.parseInt(S2[j]);\n }\n Solution obj = new Solution();\n int ans = obj.isNegativeWeightCycle(n, edges);\n System.out.println(ans);\n \nSystem.out.println(\"~\");\n}\n }\n}\n",
"script_name": "GFG",
"solution": "// Back-end function Template for Java\n\nclass Solution {\n public int isNegativeWeightCycle(int n, int[][] edges) {\n int inf = 1000000000; // Initialize the value of infinity\n int[] d = new int[n]; // Create an array to store the distances from the starting node\n int[] p = new int[n]; // Create an array to store the parent nodes\n \n Arrays.fill(d, 0); // Initialize all distances to 0\n Arrays.fill(p, -1); // Initialize all parent nodes to -1\n \n int x = -1; // Initialize x as -1\n \n for (int i = 0; i < n; i++) { // Iterate through all nodes\n x = -1; // Reset x to -1\n for (int j = 0; j < edges.length; j++) { // Iterate through all edges\n if (d[edges[j][0]] + edges[j][2] < d[edges[j][1]]) { // Check if there is a negative weight cycle\n d[edges[j][1]] = d[edges[j][0]] + edges[j][2]; // Update the distance\n p[edges[j][1]] = edges[j][0]; // Update the parent node\n x = edges[j][1]; // Set x as the node with updated distance\n }\n }\n }\n \n if (x == -1) // If x is still -1, there is no negative weight cycle\n return 0;\n else\n return 1; // If x is not -1, there is a negative weight cycle\n }\n}",
"updated_at_timestamp": 1729753320,
"user_code": "//User function Template for Java\n\nclass Solution\n{\n public int isNegativeWeightCycle(int n, int[][] edges)\n {\n //code here\n }\n}"
}
|
{
"class_name": "Solution",
"created_at_timestamp": 1615292571,
"func_sign": [
"isNegativeWeightCycle(self, n, edges)"
],
"initial_code": "# Initial Template for Python 3\n\nif __name__ == '__main__':\n T = int(input())\n for i in range(T):\n n, m = input().split()\n n = int(n)\n m = int(m)\n edges = []\n for _ in range(m):\n edges.append(list(map(int, input().split())))\n obj = Solution()\n ans = obj.isNegativeWeightCycle(n, edges)\n print(ans)\n print(\"~\")\n",
"solution": "class Solution:\n def isNegativeWeightCycle(self, n, edges):\n inf = 1000000000000000000 # initializing the value of infinity\n # creating an array to store the minimum distances\n d = [0 for i in range(n)]\n # creating an array to store the parent nodes\n p = [-1 for i in range(n)]\n for i in range(n): # iterating over all the nodes\n x = -1 # initializing x to -1\n for e in edges: # iterating over all the edges\n # if the distance to the destination node is less than the current minimum distance\n if d[e[0]] + e[2] < d[e[1]]:\n d[e[1]] = d[e[0]] + e[2] # update the minimum distance\n p[e[1]] = e[0] # update the parent node\n x = e[1] # update x to the destination node\n if x == -1: # if x is still -1, there is no negative weight cycle\n return 0\n return 1 # else, there is a negative weight cycle\n",
"updated_at_timestamp": 1731586315,
"user_code": "#User function Template for python3\n\nclass Solution:\n\tdef isNegativeWeightCycle(self, n, edges):\n\t\t#Code here"
}
|
eJydlM0OATEQxx08yKRnK+20FfEkEisO7MGlHFYiEeIheEI3T2FmB4nSpfawbXbn/5vP9tg9X7ud5hlfaDPZqWVYb2o1AmXKgEAvDQYKXwbVA1Vt19W8rhaz1aa+m+kyHOjnvgevWg9etLQ30JAQLC8WHC8OdBvXJLgOXJJLQMwOFAEFaBlICJcdk5E6kdZkawcwEPco+aDkg1In5IQ9L77B22y+5byY74Tvmc8o/UfpfTJULVVEKIZ/hIhxSzN7SP7zNC2N+mFCHt8gGpv05HwOolUSGROhMOz4N/OWg/BWinTt3kzT8xebpscgTiyjD8/rKHFuw9cGTE/9G/oBdi8=
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.