diff --git "a/dataset/processed/dataset_test.csv" "b/dataset/processed/dataset_test.csv" new file mode 100644--- /dev/null +++ "b/dataset/processed/dataset_test.csv" @@ -0,0 +1,3799 @@ +Code_ID,Code_Text,Label,Source_Type,Generation_Prompt,Language,normalized_code,original_line_count,normalized_line_count +,"from dataclasses import dataclass, field, fields + +class ValidationError(Exception): pass + +def vfield(d=None, v=()): + return field(default=d, metadata={""v"": v}) + +def validate(o): + for f in fields(o): + for fn in f.metadata.get(""v"", ()): + if not fn(getattr(o, f.name)): + raise ValidationError(f""{f.name} invalid"") + +@dataclass +class User: + name: str + age: int = vfield(0, v=[lambda x: 0 <= x <= 150]) + email: str = vfield("""", v=[lambda x: ""@"" in x]) + +# ---------- INPUT ---------- +u = User(""Arsen"", 30, ""arsen@example.com"") + +# ---------- OUTPUT ---------- +try: + validate(u) + print(""User is valid"") +except ValidationError as e: + print(e) +",1.0,GPT,write a shorter python code for Data Validation Library with Dataclasses including I/O,python,"from dataclasses import dataclass, field, fields + +class ValidationError(Exception): pass + +def vfield(d=None, v=()): + return field(default=d, metadata={""v"": v}) + +def validate(o): + for f in fields(o): + for fn in f.metadata.get(""v"", ()): + if not fn(getattr(o, f.name)): + raise ValidationError(f""{f.name} invalid"") + +@dataclass +class User: + name: str + age: int = vfield(0, v=[lambda x: 0 <= x <= 150]) + email: str = vfield("""", v=[lambda x: ""@"" in x]) + +# ---------- INPUT ---------- +u = User(""Arsen"", 30, ""arsen@example.com"") + +# ---------- OUTPUT ---------- +try: + validate(u) + print(""User is valid"") +except ValidationError as e: + print(e)",28,28 +,"class Solution: + def generateParenthesis(self, n): + res = [[] for _ in range(n+1)] + res[0] = [""""] + + for k in range(n + 1): + for i in range(k): + for left in res[i]: + for right in res[k-i-1]: + res[k].append(""("" + left + "")"" + right) + + return res[-1]",0.0,GFG,,python,"class Solution: + def generateParenthesis(self, n): + res = [[] for _ in range(n+1)] + res[0] = [""""] + + for k in range(n + 1): + for i in range(k): + for left in res[i]: + for right in res[k-i-1]: + res[k].append(""("" + left + "")"" + right) + + return res[-1]",12,12 +,"public class Singleton { + private static volatile Singleton instance; + public static Singleton getInstance() { + if (instance == null) { + synchronized (Singleton.class) { + if (instance == null) instance = new Singleton(); + } + } + return instance; + } +}",1.0,GEMINI,write a program to Implement a thread-safe Singleton that prevents unnecessary synchronization.,java,"public class Singleton { + private static volatile Singleton instance; + public static Singleton getInstance() { + if (instance == null) { + synchronized (Singleton.class) { + if (instance == null) instance = new Singleton(); + } + } + return instance; + } +}",11,11 +,"import numpy as np + +arr = np.array([3+4j, 1+7j, 3+2j, 2+5j, 1+2j]) +# Use lexsort with imaginary part as the first key, real part as the second +sorted_indices = np.lexsort((np.imag(arr), np.real(arr))) +sorted_arr = arr[sorted_indices] + +print(""Sorted array:"", sorted_arr)",1.0,DEEPAI,"Write a NumPy program to sort a given complex array using the real part first, then the imaginary part.",python,"import numpy as np + +arr = np.array([3+4j, 1+7j, 3+2j, 2+5j, 1+2j]) +# Use lexsort with imaginary part as the first key, real part as the second +sorted_indices = np.lexsort((np.imag(arr), np.real(arr))) +sorted_arr = arr[sorted_indices] + +print(""Sorted array:"", sorted_arr)",8,8 +,"public class FactorialDP { + public static long factorial(int n) { + if (n <= 1) return 1; + long[] dp = new long[n + 1]; + dp[0] = dp[1] = 1; + for (int i = 2; i <= n; i++) { + dp[i] = dp[i - 1] * i; + } + return dp[n]; + } +} +",1.0,PERPLEXITY,Implement a Java dynamic programming solution to compute factorial of a large number using an array.,java,"public class FactorialDP { + public static long factorial(int n) { + if (n <= 1) return 1; + long[] dp = new long[n + 1]; + dp[0] = dp[1] = 1; + for (int i = 2; i <= n; i++) { + dp[i] = dp[i - 1] * i; + } + return dp[n]; + } +}",11,11 +,"class Solution { + public int missingNumber(int[] nums) { + int n = nums.length; + int[] v = new int[n+1]; + Arrays.fill(v, -1); + for(int i = 0; i < nums.length; i++) { + v[nums[i]] = nums[i]; + } + for(int i = 0; i < v.length; i++) { + if(v[i] == -1) return i; + } + return 0; + } +} +",0.0,leetcode,,java,"class Solution { + public int missingNumber(int[] nums) { + int n = nums.length; + int[] v = new int[n+1]; + Arrays.fill(v, -1); + for(int i = 0; i < nums.length; i++) { + v[nums[i]] = nums[i]; + } + for(int i = 0; i < v.length; i++) { + if(v[i] == -1) return i; + } + return 0; + } +}",14,14 +,"from collections import Counter + +def leastInterval(tasks, n): + count = Counter(tasks) + max_freq = max(count.values()) + max_count = sum(1 for v in count.values() if v == max_freq) + + return max(len(tasks), (max_freq - 1) * (n + 1) + max_count) +",1.0,GPT,"Solve the problem ""Task Scheduler"". + +Given a list of tasks and a cooldown n, +return the least number of units of time needed to finish all tasks +with cooldown constraints. +",python,"from collections import Counter + +def leastInterval(tasks, n): + count = Counter(tasks) + max_freq = max(count.values()) + max_count = sum(1 for v in count.values() if v == max_freq) + + return max(len(tasks), (max_freq - 1) * (n + 1) + max_count)",8,8 +,"# Define a function named 'printValues' that generates a list of squares of numbers from 1 to 20 +def printValues(): + # Create an empty list 'l' + l = list() + + # Iterate through numbers from 1 to 20 (inclusive) + for i in range(1, 21): + # Calculate the square of 'i' and append it to the list 'l' + l.append(i**2) + + # Print the list containing squares of numbers from 1 to 20 + print(l) + +# Call the 'printValues' function to generate and print the list of squares +printValues() ",0.0,W3RESOURCE,,python,"# Define a function named 'printValues' that generates a list of squares of numbers from 1 to 20 +def printValues(): + # Create an empty list 'l' + l = list() + + # Iterate through numbers from 1 to 20 (inclusive) + for i in range(1, 21): + # Calculate the square of 'i' and append it to the list 'l' + l.append(i**2) + + # Print the list containing squares of numbers from 1 to 20 + print(l) + +# Call the 'printValues' function to generate and print the list of squares +printValues() ",15,15 +,"def setZeroes(matrix): + rows, cols = len(matrix), len(matrix[0]) + row_zero = any(matrix[0][c] == 0 for c in range(cols)) + col_zero = any(matrix[r][0] == 0 for r in range(rows)) + + for r in range(1, rows): + for c in range(1, cols): + if matrix[r][c] == 0: + matrix[r][0] = matrix[0][c] = 0 + + for r in range(1, rows): + for c in range(1, cols): + if matrix[r][0] == 0 or matrix[0][c] == 0: + matrix[r][c] = 0 + + if row_zero: + for c in range(cols): + matrix[0][c] = 0 + if col_zero: + for r in range(rows): + matrix[r][0] = 0 +",1.0,GPT,"Solve the problem ""Set Matrix Zeroes"". + +Given an m x n matrix, +if an element is 0, set its entire row and column to 0. +Do it in-place with constant extra space. + +Provide Python solution. +",python,"def setZeroes(matrix): + rows, cols = len(matrix), len(matrix[0]) + row_zero = any(matrix[0][c] == 0 for c in range(cols)) + col_zero = any(matrix[r][0] == 0 for r in range(rows)) + + for r in range(1, rows): + for c in range(1, cols): + if matrix[r][c] == 0: + matrix[r][0] = matrix[0][c] = 0 + + for r in range(1, rows): + for c in range(1, cols): + if matrix[r][0] == 0 or matrix[0][c] == 0: + matrix[r][c] = 0 + + if row_zero: + for c in range(cols): + matrix[0][c] = 0 + if col_zero: + for r in range(rows): + matrix[r][0] = 0",21,21 +,"public class PalindromeChecking +{ +public static void main(String[] args) +{ +String inpstr =""AMMA""; +char[] inpArray = inpstr.toCharArray(); +char[] revArray = new char[inpArray.length]; +int j=0; +for (int i = inpArray.length - 1; i >= 0; i--) { +revArray[j]=inpArray[i]; +j++; +} +String revstr=String.valueOf(revArray); +if(inpstr.equals(revstr)) +{ +System.out.println(""The given string is a Palindrome""); +} +else +{ +System.out.println(""The given string is not a Palindrome""); +} +} +} ",0.0,IPSGWALIOR.ORG,,java,"public class PalindromeChecking +{ +public static void main(String[] args) +{ +String inpstr =""AMMA""; +char[] inpArray = inpstr.toCharArray(); +char[] revArray = new char[inpArray.length]; +int j=0; +for (int i = inpArray.length - 1; i >= 0; i--) { +revArray[j]=inpArray[i]; +j++; +} +String revstr=String.valueOf(revArray); +if(inpstr.equals(revstr)) +{ +System.out.println(""The given string is a Palindrome""); +} +else +{ +System.out.println(""The given string is not a Palindrome""); +} +} +}",23,23 +,"def insertionSort(nlist): + for index in range(1,len(nlist)): + + currentvalue = nlist[index] + position = index + + while position>0 and nlist[position-1]>currentvalue: + nlist[position]=nlist[position-1] + position = position-1 + + nlist[position]=currentvalue + +nlist = [14,46,43,27,57,41,45,21,70] +insertionSort(nlist) +print(nlist)",0.0,W3RESOURCE,,python,"def insertionSort(nlist): + for index in range(1,len(nlist)): + + currentvalue = nlist[index] + position = index + + while position>0 and nlist[position-1]>currentvalue: + nlist[position]=nlist[position-1] + position = position-1 + + nlist[position]=currentvalue + +nlist = [14,46,43,27,57,41,45,21,70] +insertionSort(nlist) +print(nlist)",15,15 +,"import java.lang.annotation.*; +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface LogExecution { + String value() default """"; +} +public class AnnotationProcessor { + public static void process(Object obj) throws Exception { + for (java.lang.reflect.Method m : obj.getClass().getMethods()) { + if (m.isAnnotationPresent(LogExecution.class)) { + System.out.println(""Logging: "" + m.getName()); + } + } + } +} +",1.0,PERPLEXITY,Create a basic custom annotation with processor stub for runtime processing,java,"import java.lang.annotation.*; +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface LogExecution { + String value() default """"; +} +public class AnnotationProcessor { + public static void process(Object obj) throws Exception { + for (java.lang.reflect.Method m : obj.getClass().getMethods()) { + if (m.isAnnotationPresent(LogExecution.class)) { + System.out.println(""Logging: "" + m.getName()); + } + } + } +}",15,15 +,"def searchMatrix(matrix, target): + if not matrix or not matrix[0]: + return False + + rows, cols = len(matrix), len(matrix[0]) + l, r = 0, rows * cols - 1 + + while l <= r: + m = (l + r) // 2 + val = matrix[m // cols][m % cols] + if val == target: + return True + elif val < target: + l = m + 1 + else: + r = m - 1 + + return False +",1.0,GPT,"Solve the problem ""Search a 2D Matrix"". + +The matrix has the following properties: +- Integers in each row are sorted +- First integer of each row is greater than the last integer of the previous row + +Given a target, return true if found. + +Provide O(log(m*n)) Python solution. +",python,"def searchMatrix(matrix, target): + if not matrix or not matrix[0]: + return False + + rows, cols = len(matrix), len(matrix[0]) + l, r = 0, rows * cols - 1 + + while l <= r: + m = (l + r) // 2 + val = matrix[m // cols][m % cols] + if val == target: + return True + elif val < target: + l = m + 1 + else: + r = m - 1 + + return False",18,18 +,"public RandomListNode copyRandomList(RandomListNode head) { + RandomListNode iter = head, next; + + // First round: make copy of each node, + // and link them together side-by-side in a single list. + while (iter != null) { + next = iter.next; + + RandomListNode copy = new RandomListNode(iter.label); + iter.next = copy; + copy.next = next; + + iter = next; + } + + // Second round: assign random pointers for the copy nodes. + iter = head; + while (iter != null) { + if (iter.random != null) { + iter.next.random = iter.random.next; + } + iter = iter.next.next; + } + + // Third round: restore the original list, and extract the copy list. + iter = head; + RandomListNode pseudoHead = new RandomListNode(0); + RandomListNode copy, copyIter = pseudoHead; + + while (iter != null) { + next = iter.next.next; + + // extract the copy + copy = iter.next; + copyIter.next = copy; + copyIter = copy; + + // restore the original list + iter.next = next; + + iter = next; + } + + return pseudoHead.next; +}",0.0,leetcode,,java,"public RandomListNode copyRandomList(RandomListNode head) { + RandomListNode iter = head, next; + + // First round: make copy of each node, + // and link them together side-by-side in a single list. + while (iter != null) { + next = iter.next; + + RandomListNode copy = new RandomListNode(iter.label); + iter.next = copy; + copy.next = next; + + iter = next; + } + + // Second round: assign random pointers for the copy nodes. + iter = head; + while (iter != null) { + if (iter.random != null) { + iter.next.random = iter.random.next; + } + iter = iter.next.next; + } + + // Third round: restore the original list, and extract the copy list. + iter = head; + RandomListNode pseudoHead = new RandomListNode(0); + RandomListNode copy, copyIter = pseudoHead; + + while (iter != null) { + next = iter.next.next; + + // extract the copy + copy = iter.next; + copyIter.next = copy; + copyIter = copy; + + // restore the original list + iter.next = next; + + iter = next; + } + + return pseudoHead.next; +}",45,45 +,"import time + +class Timer: + def __init__(self, func): + self.func = func + + def __get__(self, obj, objtype=None): + return lambda *a, **k: self(obj, *a, **k) + + def __call__(self, obj, *a, **k): + t = time.time() + r = self.func(obj, *a, **k) + print(f""{self.func.__name__}: {time.time()-t:.4f}s"") + return r +",1.0,GPT,"write a python code for Class-Based Decorator for Execution Time , let the code be more shorter .",python,"import time + +class Timer: + def __init__(self, func): + self.func = func + + def __get__(self, obj, objtype=None): + return lambda *a, **k: self(obj, *a, **k) + + def __call__(self, obj, *a, **k): + t = time.time() + r = self.func(obj, *a, **k) + print(f""{self.func.__name__}: {time.time()-t:.4f}s"") + return r",14,14 +,"static boolean dfs(char[][] b,int i,int j,String w,int k){ + if(k==w.length()) return true; + if(i<0||j<0||i==b.length||j==b[0].length||b[i][j]!=w.charAt(k)) return false; + char t=b[i][j]; b[i][j]='#'; + boolean r=dfs(b,i+1,j,w,k+1)||dfs(b,i-1,j,w,k+1)||dfs(b,i,j+1,w,k+1)||dfs(b,i,j-1,w,k+1); + b[i][j]=t; return r; +} ",1.0,GPT,give me an efficient java code to Find if word exists in grid using DFS + Trie.,java,"static boolean dfs(char[][] b,int i,int j,String w,int k){ + if(k==w.length()) return true; + if(i<0||j<0||i==b.length||j==b[0].length||b[i][j]!=w.charAt(k)) return false; + char t=b[i][j]; b[i][j]='#'; + boolean r=dfs(b,i+1,j,w,k+1)||dfs(b,i-1,j,w,k+1)||dfs(b,i,j+1,w,k+1)||dfs(b,i,j-1,w,k+1); + b[i][j]=t; return r; +}",7,7 +,"class MagicDictionary { + Set originalWords; + Map extensions; + + public MagicDictionary() { + originalWords = new HashSet<>(); + extensions = new HashMap<>(); + } + + public void buildDict(String[] dictionary) { + for (String word : dictionary) { + originalWords.add(word); + char[] str = word.toCharArray(); + int n = str.length; + for (int i = 0; i < n; i++) { + char temp = str[i]; + str[i] = '*'; + String key = new String(str); + extensions.put(key, extensions.getOrDefault(key, 0) + 1); + str[i] = temp; + } + } + } + + public boolean search(String searchWord) { + char[] str = searchWord.toCharArray(); + int n = str.length; + for (int i = 0; i < n; i++) { + char temp = str[i]; + str[i] = '*'; + String key = new String(str); + if (extensions.containsKey(key)) { + // If count >= 2, then there's definitely a different word that maps to this pattern + // If count == 1, make sure it's not the same word + if (extensions.get(key) >= 2 || !originalWords.contains(searchWord)) { + return true; + } + } + str[i] = temp; + } + return false; + } +}",0.0,leetcode,,java,"class MagicDictionary { + Set originalWords; + Map extensions; + + public MagicDictionary() { + originalWords = new HashSet<>(); + extensions = new HashMap<>(); + } + + public void buildDict(String[] dictionary) { + for (String word : dictionary) { + originalWords.add(word); + char[] str = word.toCharArray(); + int n = str.length; + for (int i = 0; i < n; i++) { + char temp = str[i]; + str[i] = '*'; + String key = new String(str); + extensions.put(key, extensions.getOrDefault(key, 0) + 1); + str[i] = temp; + } + } + } + + public boolean search(String searchWord) { + char[] str = searchWord.toCharArray(); + int n = str.length; + for (int i = 0; i < n; i++) { + char temp = str[i]; + str[i] = '*'; + String key = new String(str); + if (extensions.containsKey(key)) { + // If count >= 2, then there's definitely a different word that maps to this pattern + // If count == 1, make sure it's not the same word + if (extensions.get(key) >= 2 || !originalWords.contains(searchWord)) { + return true; + } + } + str[i] = temp; + } + return false; + } +}",43,43 +,"// Define the Cat class +public class Cat { + // Private instance variables + private String name; + private int age; + // Default constructor + public Cat() { + // Initialize name to ""Unknown"" + this.name = ""Unknown""; + // Initialize age to 0 + this.age = 0; + } + // Getter for name + public String getName() { + return name; + } + // Getter for age + public int getAge() { + return age; + } + // Main method to test the Cat class + public static void main(String[] args) { + // Create a new Cat object using the default constructor + Cat myCat = new Cat(); + // Use the getter methods to access private variables + System.out.println(""Cat's Name: "" + myCat.getName()); + System.out.println(""Cat's Age: "" + myCat.getAge()); + } +} ",0.0,WE3RESOURCE,,java,"// Define the Cat class +public class Cat { + // Private instance variables + private String name; + private int age; + // Default constructor + public Cat() { + // Initialize name to ""Unknown"" + this.name = ""Unknown""; + // Initialize age to 0 + this.age = 0; + } + // Getter for name + public String getName() { + return name; + } + // Getter for age + public int getAge() { + return age; + } + // Main method to test the Cat class + public static void main(String[] args) { + // Create a new Cat object using the default constructor + Cat myCat = new Cat(); + // Use the getter methods to access private variables + System.out.println(""Cat's Name: "" + myCat.getName()); + System.out.println(""Cat's Age: "" + myCat.getAge()); + } +}",29,29 +,"from bs4 import BeautifulSoup +import requests + +handle = input('Input your account name on Twitter: ') +temp = requests.get('https://twitter.com/'+handle) +bs = BeautifulSoup(temp.text,'lxml') + +try: + favorite_box = bs.find('li',{'class':'ProfileNav-item ProfileNav-item--favorites'}) + favorite = favorite_box.find('a').find('span',{'class':'ProfileNav-value'}) + print(""Number of post {} liked are {}: "".format(handle,favorite.get('data-count'))) + +except: + print('Account name not found...') + ",0.0,WERESOURCE,,python,"from bs4 import BeautifulSoup +import requests + +handle = input('Input your account name on Twitter: ') +temp = requests.get('https://twitter.com/'+handle) +bs = BeautifulSoup(temp.text,'lxml') + +try: + favorite_box = bs.find('li',{'class':'ProfileNav-item ProfileNav-item--favorites'}) + favorite = favorite_box.find('a').find('span',{'class':'ProfileNav-value'}) + print(""Number of post {} liked are {}: "".format(handle,favorite.get('data-count'))) + +except: + print('Account name not found...')",14,14 +,"import java.util.*; + +class Solution { + public List basicCalculatorIV(String expression, String[] evalvars, int[] evalints) { + Map evalmap = new HashMap<>(); + for (int i = 0; i < evalvars.length; i++) evalmap.put(evalvars[i], evalints[i]); + + List tokens = tokenize(expression); + Map, Integer> poly = parseExpression(tokens, evalmap); + + List, Integer>> list = new ArrayList<>(poly.entrySet()); + list.sort((a, b) -> { + if (b.getKey().size() != a.getKey().size()) return b.getKey().size() - a.getKey().size(); + // lexicographic compare by joining with '*' + return String.join(""*"", a.getKey()).compareTo(String.join(""*"", b.getKey())); + }); + + List ans = new ArrayList<>(); + for (var e : list) { + int coeff = e.getValue(); + if (coeff == 0) continue; + StringBuilder sb = new StringBuilder(); + sb.append(coeff); + for (String v : e.getKey()) sb.append(""*"").append(v); + ans.add(sb.toString()); + } + return ans; + } + + private List tokenize(String expr) { + List tokens = new ArrayList<>(); + StringBuilder sb = new StringBuilder(); + for (char c : expr.toCharArray()) { + if (Character.isLetterOrDigit(c)) sb.append(c); + else { + if (sb.length() > 0) { tokens.add(sb.toString()); sb.setLength(0); } + if (c == '+' || c == '-' || c == '*' || c == '(' || c == ')') tokens.add(String.valueOf(c)); + } + } + if (sb.length() > 0) tokens.add(sb.toString()); + return tokens; + } + + private Map, Integer> parseExpression(List tokens, Map evalmap) { + Deque, Integer>> vals = new ArrayDeque<>(); + Deque ops = new ArrayDeque<>(); + Map prec = Map.of(""+"",1, ""-"",1, ""*"",2); + + for (String tok : tokens) { + if (tok.equals(""("")) ops.push(tok); + else if (tok.equals("")"")) { + while (!ops.peek().equals(""("")) applyOp(vals, ops.pop()); + ops.pop(); + } else if (prec.containsKey(tok)) { + while (!ops.isEmpty() && prec.containsKey(ops.peek()) && prec.get(ops.peek()) >= prec.get(tok)) { + applyOp(vals, ops.pop()); + } + ops.push(tok); + } else { + vals.push(parseToken(tok, evalmap)); + } + } + while (!ops.isEmpty()) applyOp(vals, ops.pop()); + return vals.isEmpty() ? new HashMap<>() : vals.pop(); + } + + private void applyOp(Deque, Integer>> vals, String op) { + Map, Integer> b = vals.pop(); + Map, Integer> a = vals.pop(); + if (op.equals(""+"")) vals.push(add(a, b)); + else if (op.equals(""-"")) vals.push(sub(a, b)); + else vals.push(mul(a, b)); + } + + private Map, Integer> parseToken(String tok, Map evalmap) { + Map, Integer> res = new HashMap<>(); + if (tok.matches(""-?\\d+"")) { + res.put(Collections.emptyList(), Integer.parseInt(tok)); + } else if (evalmap.containsKey(tok)) { + res.put(Collections.emptyList(), evalmap.get(tok)); + } else { + res.put(Arrays.asList(tok), 1); + } + return res; + } + + private Map, Integer> combine(Map, Integer> m) { + Map, Integer> res = new HashMap<>(); + for (var e : m.entrySet()) { + if (e.getValue() != 0) res.put(e.getKey(), res.getOrDefault(e.getKey(), 0) + e.getValue()); + } + res.entrySet().removeIf(kv -> kv.getValue() == 0); + return res; + } + + private Map, Integer> add(Map, Integer> a, Map, Integer> b) { + Map, Integer> res = new HashMap<>(a); + for (var e : b.entrySet()) res.put(e.getKey(), res.getOrDefault(e.getKey(), 0) + e.getValue()); + return combine(res); + } + + private Map, Integer> sub(Map, Integer> a, Map, Integer> b) { + Map, Integer> res = new HashMap<>(a); + for (var e : b.entrySet()) res.put(e.getKey(), res.getOrDefault(e.getKey(), 0) - e.getValue()); + return combine(res); + } + + private Map, Integer> mul(Map, Integer> a, Map, Integer> b) { + Map, Integer> res = new HashMap<>(); + for (var ea : a.entrySet()) { + for (var eb : b.entrySet()) { + List merged = new ArrayList<>(ea.getKey()); + merged.addAll(eb.getKey()); + Collections.sort(merged); + res.put(merged, res.getOrDefault(merged, 0) + ea.getValue() * eb.getValue()); + } + } + return combine(res); + } +}",0.0,leetcode,,java,"import java.util.*; + +class Solution { + public List basicCalculatorIV(String expression, String[] evalvars, int[] evalints) { + Map evalmap = new HashMap<>(); + for (int i = 0; i < evalvars.length; i++) evalmap.put(evalvars[i], evalints[i]); + + List tokens = tokenize(expression); + Map, Integer> poly = parseExpression(tokens, evalmap); + + List, Integer>> list = new ArrayList<>(poly.entrySet()); + list.sort((a, b) -> { + if (b.getKey().size() != a.getKey().size()) return b.getKey().size() - a.getKey().size(); + // lexicographic compare by joining with '*' + return String.join(""*"", a.getKey()).compareTo(String.join(""*"", b.getKey())); + }); + + List ans = new ArrayList<>(); + for (var e : list) { + int coeff = e.getValue(); + if (coeff == 0) continue; + StringBuilder sb = new StringBuilder(); + sb.append(coeff); + for (String v : e.getKey()) sb.append(""*"").append(v); + ans.add(sb.toString()); + } + return ans; + } + + private List tokenize(String expr) { + List tokens = new ArrayList<>(); + StringBuilder sb = new StringBuilder(); + for (char c : expr.toCharArray()) { + if (Character.isLetterOrDigit(c)) sb.append(c); + else { + if (sb.length() > 0) { tokens.add(sb.toString()); sb.setLength(0); } + if (c == '+' || c == '-' || c == '*' || c == '(' || c == ')') tokens.add(String.valueOf(c)); + } + } + if (sb.length() > 0) tokens.add(sb.toString()); + return tokens; + } + + private Map, Integer> parseExpression(List tokens, Map evalmap) { + Deque, Integer>> vals = new ArrayDeque<>(); + Deque ops = new ArrayDeque<>(); + Map prec = Map.of(""+"",1, ""-"",1, ""*"",2); + + for (String tok : tokens) { + if (tok.equals(""("")) ops.push(tok); +... truncated ... + else if (op.equals(""-"")) vals.push(sub(a, b)); + else vals.push(mul(a, b)); + } + + private Map, Integer> parseToken(String tok, Map evalmap) { + Map, Integer> res = new HashMap<>(); + if (tok.matches(""-?\\d+"")) { + res.put(Collections.emptyList(), Integer.parseInt(tok)); + } else if (evalmap.containsKey(tok)) { + res.put(Collections.emptyList(), evalmap.get(tok)); + } else { + res.put(Arrays.asList(tok), 1); + } + return res; + } + + private Map, Integer> combine(Map, Integer> m) { + Map, Integer> res = new HashMap<>(); + for (var e : m.entrySet()) { + if (e.getValue() != 0) res.put(e.getKey(), res.getOrDefault(e.getKey(), 0) + e.getValue()); + } + res.entrySet().removeIf(kv -> kv.getValue() == 0); + return res; + } + + private Map, Integer> add(Map, Integer> a, Map, Integer> b) { + Map, Integer> res = new HashMap<>(a); + for (var e : b.entrySet()) res.put(e.getKey(), res.getOrDefault(e.getKey(), 0) + e.getValue()); + return combine(res); + } + + private Map, Integer> sub(Map, Integer> a, Map, Integer> b) { + Map, Integer> res = new HashMap<>(a); + for (var e : b.entrySet()) res.put(e.getKey(), res.getOrDefault(e.getKey(), 0) - e.getValue()); + return combine(res); + } + + private Map, Integer> mul(Map, Integer> a, Map, Integer> b) { + Map, Integer> res = new HashMap<>(); + for (var ea : a.entrySet()) { + for (var eb : b.entrySet()) { + List merged = new ArrayList<>(ea.getKey()); + merged.addAll(eb.getKey()); + Collections.sort(merged); + res.put(merged, res.getOrDefault(merged, 0) + ea.getValue() * eb.getValue()); + } + } + return combine(res); + } +}",120,101 +,"import hashlib + +class BloomFilter: + def __init__(self, size, hash_count): + self.size = size # Size of the bit array + self.hash_count = hash_count # Number of hash functions + self.bit_array = [0] * size # Bit array to store elements + + def _hashes(self, item): + """"""Generate hash_count hashes for the item using different hash functions."""""" + hashes = [] + for i in range(self.hash_count): + # Create a unique hash for each iteration + hash_result = int(hashlib.md5((str(item) + str(i)).encode()).hexdigest(), 16) % self.size + hashes.append(hash_result) + return hashes + + def add(self, item): + """"""Add an item to the Bloom filter."""""" + hashes = self._hashes(item) + for hash_value in hashes: + self.bit_array[hash_value] = 1 + + def check(self, item): + """"""Check if an item is possibly in the Bloom filter."""""" + hashes = self._hashes(item) + return all(self.bit_array[hash_value] == 1 for hash_value in hashes) + +# Example usage +size = 1000 # Size of the bit array +hash_count = 10 # Number of hash functions + +bloom_filter = BloomFilter(size, hash_count) + +# Add items to the Bloom filter +bloom_filter.add(""Red"") +bloom_filter.add(""Green"") +bloom_filter.add(""Blue"") +bloom_filter.add(""Orange"") + +# Check for item membership +print(""Red in filter:"", bloom_filter.check(""Red"")) # Should be True +print(""Green in filter:"", bloom_filter.check(""Green"")) # Should be True +print(""Orange in filter:"", bloom_filter.check(""Orange"")) # Should be True +print(""Black in filter:"", bloom_filter.check(""Black"")) # Should be False (most likely)",0.0,W3RESOURCE,,python,"import hashlib + +class BloomFilter: + def __init__(self, size, hash_count): + self.size = size # Size of the bit array + self.hash_count = hash_count # Number of hash functions + self.bit_array = [0] * size # Bit array to store elements + + def _hashes(self, item): + """"""Generate hash_count hashes for the item using different hash functions."""""" + hashes = [] + for i in range(self.hash_count): + # Create a unique hash for each iteration + hash_result = int(hashlib.md5((str(item) + str(i)).encode()).hexdigest(), 16) % self.size + hashes.append(hash_result) + return hashes + + def add(self, item): + """"""Add an item to the Bloom filter."""""" + hashes = self._hashes(item) + for hash_value in hashes: + self.bit_array[hash_value] = 1 + + def check(self, item): + """"""Check if an item is possibly in the Bloom filter."""""" + hashes = self._hashes(item) + return all(self.bit_array[hash_value] == 1 for hash_value in hashes) + +# Example usage +size = 1000 # Size of the bit array +hash_count = 10 # Number of hash functions + +bloom_filter = BloomFilter(size, hash_count) + +# Add items to the Bloom filter +bloom_filter.add(""Red"") +bloom_filter.add(""Green"") +bloom_filter.add(""Blue"") +bloom_filter.add(""Orange"") + +# Check for item membership +print(""Red in filter:"", bloom_filter.check(""Red"")) # Should be True +print(""Green in filter:"", bloom_filter.check(""Green"")) # Should be True +print(""Orange in filter:"", bloom_filter.check(""Orange"")) # Should be True +print(""Black in filter:"", bloom_filter.check(""Black"")) # Should be False (most likely)",45,45 +,"import tweepy + +# Replace with your actual bearer token from Twitter Developer Portal +BEARER_TOKEN = 'YOUR_BEARER_TOKEN_HERE' + +# Initialize the client with bearer token (sufficient for read access) +client = tweepy.Client(bearer_token=BEARER_TOKEN) + +# Input for Twitter username (without @) +username = input(""Enter Twitter username: "") + +try: + # Get the user by username + user = client.get_user(username=username) + + if user.data: + # Access public_metrics which includes total tweet count + public_metrics = user.data.public_metrics + tweet_count = public_metrics['tweet_count'] + + print(f""@{username} has posted {tweet_count:,} tweets (including retweets and replies)."") + else: + print(""User not found."") + +except tweepy.TweepyException as e: + print(f""Error: {e}"") +",1.0,PERPLEXITY,Write a Python program to count number of tweets by a given Twitter account. add a input feature where the user would give their account as an input .,python,"import tweepy + +# Replace with your actual bearer token from Twitter Developer Portal +BEARER_TOKEN = 'YOUR_BEARER_TOKEN_HERE' + +# Initialize the client with bearer token (sufficient for read access) +client = tweepy.Client(bearer_token=BEARER_TOKEN) + +# Input for Twitter username (without @) +username = input(""Enter Twitter username: "") + +try: + # Get the user by username + user = client.get_user(username=username) + + if user.data: + # Access public_metrics which includes total tweet count + public_metrics = user.data.public_metrics + tweet_count = public_metrics['tweet_count'] + + print(f""@{username} has posted {tweet_count:,} tweets (including retweets and replies)."") + else: + print(""User not found."") + +except tweepy.TweepyException as e: + print(f""Error: {e}"")",26,26 +,"def shellSort(alist): + sublistcount = len(alist)//2 + while sublistcount > 0: + for start_position in range(sublistcount): + gap_InsertionSort(alist, start_position, sublistcount) + + print(""After increments of size"",sublistcount, ""The list is"",nlist) + + sublistcount = sublistcount // 2 + +def gap_InsertionSort(nlist,start,gap): + for i in range(start+gap,len(nlist),gap): + + current_value = nlist[i] + position = i + + while position>=gap and nlist[position-gap]>current_value: + nlist[position]=nlist[position-gap] + position = position-gap + + nlist[position]=current_value + + +nlist = [14,46,43,27,57,41,45,21,70] +shellSort(nlist) +print(nlist) ",0.0,W3RESOURCE,,python,"def shellSort(alist): + sublistcount = len(alist)//2 + while sublistcount > 0: + for start_position in range(sublistcount): + gap_InsertionSort(alist, start_position, sublistcount) + + print(""After increments of size"",sublistcount, ""The list is"",nlist) + + sublistcount = sublistcount // 2 + +def gap_InsertionSort(nlist,start,gap): + for i in range(start+gap,len(nlist),gap): + + current_value = nlist[i] + position = i + + while position>=gap and nlist[position-gap]>current_value: + nlist[position]=nlist[position-gap] + position = position-gap + + nlist[position]=current_value + + +nlist = [14,46,43,27,57,41,45,21,70] +shellSort(nlist) +print(nlist)",26,26 +,"class WordFilter { + constructor(words) { + this.pTrie = new Array(27) + this.sTrie = new Array(27) + let wordSet = new Set() + for (let index = words.length - 1; ~index; index--) { + let word = words[index], wlen = word.length + if (wordSet.has(word)) + continue; + wordSet.add(word) + this.insert(word, index, this.pTrie, 0, wlen, 1) + this.insert(word, index, this.sTrie, wlen-1, -1, -1) + } + } + + insert(word, index, trie, start, end, step) { + for (let i = start; i != end; i += step) { + let c = word.charCodeAt(i) - 97 + if (!trie[c]) trie[c] = new Array(27) + trie = trie[c] + if (!trie[26]) trie[26] = [] + trie[26].push(index) + } + } + + retrieve(word, trie, start, end, step) { + for (let i = start; i != end; i += step) { + let c = word.charCodeAt(i) - 97 + if (!trie[c]) return [] + trie = trie[c] + } + return trie[26] + } + + f(pre, suf) { + let pVals = this.retrieve(pre, this.pTrie, 0, pre.length, 1), + sVals = this.retrieve(suf, this.sTrie, suf.length-1, -1, -1), + svix = 0, pvix = 0 + while (svix < sVals.length && pvix < pVals.length) { + let sVal = sVals[svix], pVal = pVals[pvix] + if (sVal === pVal) return sVal + sVal > pVal ? svix++ : pvix++ + } + return -1 + } +};",0.0,leetcode,,java,"class WordFilter { + constructor(words) { + this.pTrie = new Array(27) + this.sTrie = new Array(27) + let wordSet = new Set() + for (let index = words.length - 1; ~index; index--) { + let word = words[index], wlen = word.length + if (wordSet.has(word)) + continue; + wordSet.add(word) + this.insert(word, index, this.pTrie, 0, wlen, 1) + this.insert(word, index, this.sTrie, wlen-1, -1, -1) + } + } + + insert(word, index, trie, start, end, step) { + for (let i = start; i != end; i += step) { + let c = word.charCodeAt(i) - 97 + if (!trie[c]) trie[c] = new Array(27) + trie = trie[c] + if (!trie[26]) trie[26] = [] + trie[26].push(index) + } + } + + retrieve(word, trie, start, end, step) { + for (let i = start; i != end; i += step) { + let c = word.charCodeAt(i) - 97 + if (!trie[c]) return [] + trie = trie[c] + } + return trie[26] + } + + f(pre, suf) { + let pVals = this.retrieve(pre, this.pTrie, 0, pre.length, 1), + sVals = this.retrieve(suf, this.sTrie, suf.length-1, -1, -1), + svix = 0, pvix = 0 + while (svix < sVals.length && pvix < pVals.length) { + let sVal = sVals[svix], pVal = pVals[pvix] + if (sVal === pVal) return sVal + sVal > pVal ? svix++ : pvix++ + } + return -1 + } +};",46,46 +,"class Solution { + public String[] findWords(String[] words) { + ArrayList ans=new ArrayList<>(); + String first = ""qwertyuiop""; + String Secound =""asdfghjkl""; + String Third=""zxcvbnm""; + for(String i : words){ + if(isinrow(i,first) || isinrow(i,Secound) || isinrow(i,Third)) + ans.add(i); + } + return ans.toArray(new String[0]); + } + private boolean isinrow(String s,String row){ + for(char c:s.toCharArray()){ + if(row.indexOf(Character.toLowerCase(c))==-1){ + return false; + } + } + return true; + } +}",0.0,leetcode,,java,"class Solution { + public String[] findWords(String[] words) { + ArrayList ans=new ArrayList<>(); + String first = ""qwertyuiop""; + String Secound =""asdfghjkl""; + String Third=""zxcvbnm""; + for(String i : words){ + if(isinrow(i,first) || isinrow(i,Secound) || isinrow(i,Third)) + ans.add(i); + } + return ans.toArray(new String[0]); + } + private boolean isinrow(String s,String row){ + for(char c:s.toCharArray()){ + if(row.indexOf(Character.toLowerCase(c))==-1){ + return false; + } + } + return true; + } +}",21,21 +,"def maxArea(height): + l, r = 0, len(height) - 1 + res = 0 + + while l < r: + res = max(res, min(height[l], height[r]) * (r - l)) + if height[l] < height[r]: + l += 1 + else: + r -= 1 + + return res +",1.0,GPT,"Given an array height, find two lines that together with the x-axis form a container, +such that the container contains the most water.",python,"def maxArea(height): + l, r = 0, len(height) - 1 + res = 0 + + while l < r: + res = max(res, min(height[l], height[r]) * (r - l)) + if height[l] < height[r]: + l += 1 + else: + r -= 1 + + return res",12,12 +,"public class Solution { +public List> palindromePairs(String[] words) { + List> res = new ArrayList>(); + if(words == null || words.length == 0){ + return res; + } + //build the map save the key-val pairs: String - idx + HashMap map = new HashMap<>(); + for(int i = 0; i < words.length; i++){ + map.put(words[i], i); + } + + //special cases: """" can be combine with any palindrome string + if(map.containsKey("""")){ + int blankIdx = map.get(""""); + for(int i = 0; i < words.length; i++){ + if(isPalindrome(words[i])){ + if(i == blankIdx) continue; + res.add(Arrays.asList(blankIdx, i)); + res.add(Arrays.asList(i, blankIdx)); + } + } + } + + //find all string and reverse string pairs + for(int i = 0; i < words.length; i++){ + String cur_r = reverseStr(words[i]); + if(map.containsKey(cur_r)){ + int found = map.get(cur_r); + if(found == i) continue; + res.add(Arrays.asList(i, found)); + } + } + + //find the pair s1, s2 that + //case1 : s1[0:cut] is palindrome and s1[cut+1:] = reverse(s2) => (s2, s1) + //case2 : s1[cut+1:] is palindrome and s1[0:cut] = reverse(s2) => (s1, s2) + for(int i = 0; i < words.length; i++){ + String cur = words[i]; + for(int cut = 1; cut < cur.length(); cut++){ + if(isPalindrome(cur.substring(0, cut))){ + String cut_r = reverseStr(cur.substring(cut)); + if(map.containsKey(cut_r)){ + int found = map.get(cut_r); + if(found == i) continue; + res.add(Arrays.asList(found, i)); + } + } + if(isPalindrome(cur.substring(cut))){ + String cut_r = reverseStr(cur.substring(0, cut)); + if(map.containsKey(cut_r)){ + int found = map.get(cut_r); + if(found == i) continue; + res.add(Arrays.asList(i, found)); + } + } + } + } + + return res; +} + +public String reverseStr(String str){ + StringBuilder sb= new StringBuilder(str); + return sb.reverse().toString(); +} + +public boolean isPalindrome(String s){ + int i = 0; + int j = s.length() - 1; + while(i <= j){ + if(s.charAt(i) != s.charAt(j)){ + return false; + } + i++; + j--; + } + return true; +}",0.0,leetcode,,java,"public class Solution { +public List> palindromePairs(String[] words) { + List> res = new ArrayList>(); + if(words == null || words.length == 0){ + return res; + } + //build the map save the key-val pairs: String - idx + HashMap map = new HashMap<>(); + for(int i = 0; i < words.length; i++){ + map.put(words[i], i); + } + + //special cases: """" can be combine with any palindrome string + if(map.containsKey("""")){ + int blankIdx = map.get(""""); + for(int i = 0; i < words.length; i++){ + if(isPalindrome(words[i])){ + if(i == blankIdx) continue; + res.add(Arrays.asList(blankIdx, i)); + res.add(Arrays.asList(i, blankIdx)); + } + } + } + + //find all string and reverse string pairs + for(int i = 0; i < words.length; i++){ + String cur_r = reverseStr(words[i]); + if(map.containsKey(cur_r)){ + int found = map.get(cur_r); + if(found == i) continue; + res.add(Arrays.asList(i, found)); + } + } + + //find the pair s1, s2 that + //case1 : s1[0:cut] is palindrome and s1[cut+1:] = reverse(s2) => (s2, s1) + //case2 : s1[cut+1:] is palindrome and s1[0:cut] = reverse(s2) => (s1, s2) + for(int i = 0; i < words.length; i++){ + String cur = words[i]; + for(int cut = 1; cut < cur.length(); cut++){ + if(isPalindrome(cur.substring(0, cut))){ + String cut_r = reverseStr(cur.substring(cut)); + if(map.containsKey(cut_r)){ + int found = map.get(cut_r); + if(found == i) continue; + res.add(Arrays.asList(found, i)); + } + } + if(isPalindrome(cur.substring(cut))){ + String cut_r = reverseStr(cur.substring(0, cut)); + if(map.containsKey(cut_r)){ + int found = map.get(cut_r); + if(found == i) continue; + res.add(Arrays.asList(i, found)); + } + } + } + } + + return res; +} + +public String reverseStr(String str){ + StringBuilder sb= new StringBuilder(str); + return sb.reverse().toString(); +} + +public boolean isPalindrome(String s){ + int i = 0; + int j = s.length() - 1; + while(i <= j){ + if(s.charAt(i) != s.charAt(j)){ + return false; + } + i++; + j--; + } + return true; +}",79,79 +,"public int deleteAndEarn(int[] nums) { + var numToCount = new HashMap(); + var min = Integer.MAX_VALUE; + var max = Integer.MIN_VALUE; + for (var num : nums) { + numToCount.compute(num, (k, v) -> v == null ? 1 : ++v); + min = Math.min(min, num); + max = Math.max(max, num); + } + + var prevIncEarn = 0; + var prevExcEarn = 0; + for (var i = min; i <= max; i++) { + var incEarn = prevExcEarn + i * numToCount.getOrDefault(i, 0); + var excEarn = Math.max(prevIncEarn, prevExcEarn); + prevIncEarn = incEarn; + prevExcEarn = excEarn; + } + return Math.max(prevIncEarn, prevExcEarn); +}",0.0,leetcode,,java,"public int deleteAndEarn(int[] nums) { + var numToCount = new HashMap(); + var min = Integer.MAX_VALUE; + var max = Integer.MIN_VALUE; + for (var num : nums) { + numToCount.compute(num, (k, v) -> v == null ? 1 : ++v); + min = Math.min(min, num); + max = Math.max(max, num); + } + + var prevIncEarn = 0; + var prevExcEarn = 0; + for (var i = min; i <= max; i++) { + var incEarn = prevExcEarn + i * numToCount.getOrDefault(i, 0); + var excEarn = Math.max(prevIncEarn, prevExcEarn); + prevIncEarn = incEarn; + prevExcEarn = excEarn; + } + return Math.max(prevIncEarn, prevExcEarn); +}",20,20 +,"import java.util.UUID; +public class UUIDUtil { + public static String generate() { + return UUID.randomUUID().toString(); + } + public static boolean isValid(String uuid) { + try { + UUID.fromString(uuid); + return true; + } catch (IllegalArgumentException e) { + return false; + } + } +} +",1.0,PERPLEXITY,Implement a Java utility to generate UUID v4 strings and validate their format,java,"import java.util.UUID; +public class UUIDUtil { + public static String generate() { + return UUID.randomUUID().toString(); + } + public static boolean isValid(String uuid) { + try { + UUID.fromString(uuid); + return true; + } catch (IllegalArgumentException e) { + return false; + } + } +}",14,14 +,"class Solution: + def leastInterval(self, tasks: List[str], n: int) -> int: + count = [0] * 26 + for task in tasks: + count[ord(task) - ord('A')] += 1 + + maxf = max(count) + maxCount = 0 + for i in count: + maxCount += 1 if i == maxf else 0 + + time = (maxf - 1) * (n + 1) + maxCount + return max(len(tasks), time)",0.0,GFG,,python,"class Solution: + def leastInterval(self, tasks: List[str], n: int) -> int: + count = [0] * 26 + for task in tasks: + count[ord(task) - ord('A')] += 1 + + maxf = max(count) + maxCount = 0 + for i in count: + maxCount += 1 if i == maxf else 0 + + time = (maxf - 1) * (n + 1) + maxCount + return max(len(tasks), time)",13,13 +,"class Solution: + def swimInWater(self, grid: List[List[int]]) -> int: + N = len(grid) + visit = set() + minH = [[grid[0][0], 0, 0]] # (time/max-height, r, c) + directions = [[0, 1], [0, -1], [1, 0], [-1, 0]] + + visit.add((0, 0)) + while minH: + t, r, c = heapq.heappop(minH) + if r == N - 1 and c == N - 1: + return t + for dr, dc in directions: + neiR, neiC = r + dr, c + dc + if (neiR < 0 or neiC < 0 or + neiR == N or neiC == N or + (neiR, neiC) in visit + ): + continue + visit.add((neiR, neiC)) + heapq.heappush(minH, [max(t, grid[neiR][neiC]), neiR, neiC])",0.0,GFG,,python,"class Solution: + def swimInWater(self, grid: List[List[int]]) -> int: + N = len(grid) + visit = set() + minH = [[grid[0][0], 0, 0]] # (time/max-height, r, c) + directions = [[0, 1], [0, -1], [1, 0], [-1, 0]] + + visit.add((0, 0)) + while minH: + t, r, c = heapq.heappop(minH) + if r == N - 1 and c == N - 1: + return t + for dr, dc in directions: + neiR, neiC = r + dr, c + dc + if (neiR < 0 or neiC < 0 or + neiR == N or neiC == N or + (neiR, neiC) in visit + ): + continue + visit.add((neiR, neiC)) + heapq.heappush(minH, [max(t, grid[neiR][neiC]), neiR, neiC])",21,21 +,"import java.util.concurrent.locks.AbstractQueuedSynchronizer; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; + +public class WriterPreferenceReadWriteLock implements ReadWriteLock { + private final Sync sync; + + public WriterPreferenceReadWriteLock() { + this.sync = new Sync(); + } + + private static class Sync extends AbstractQueuedSynchronizer { + private static final int READER_MASK = (1 << 16) - 1; + private static final int WRITER_MASK = ~READER_MASK; + + private int readers() { + return getState() & READER_MASK; + } + + private int writers() { + return (getState() >>> 16) & READER_MASK; + } + + private int incrementReaders() { + return getState() + 1; + } + + private int decrementReaders() { + return getState() - 1; + } + + private int incrementWriters() { + return getState() + (1 << 16); + } + + private int decrementWriters() { + return getState() - (1 << 16); + } + + @Override + protected boolean tryAcquire(int arg) { + Thread current = Thread.currentThread(); + int state = getState(); + + // If no readers or writers, try to acquire write lock + if (state == 0) { + if (compareAndSetState(0, 1 << 16)) { + setExclusiveOwnerThread(current); + return true; + } + } else if (getExclusiveOwnerThread() == current) { + // Reentrant write lock + setState(state + (1 << 16)); + return true; + } + return false; + } + + @Override + protected boolean tryRelease(int arg) { + if (getExclusiveOwnerThread() != Thread.currentThread()) { + throw new IllegalMonitorStateException(); + } + + int newState = decrementWriters(); + boolean free = (newState & WRITER_MASK) == 0; + + if (free) { + setExclusiveOwnerThread(null); + } + setState(newState); + return free; + } + + @Override + protected int tryAcquireShared(int arg) { + Thread current = Thread.currentThread(); + int state = getState(); + + // If there are waiting writers, don't acquire read lock + if (hasQueuedPredecessors()) { + return -1; + } + + // If no writers, try to acquire read lock + if ((state & WRITER_MASK) == 0) { + if (compareAndSetState(state, incrementReaders())) { + return 1; + } + } + return -1; + } + + @Override + protected boolean tryReleaseShared(int arg) { + int newState; + int currentState; + + do { + currentState = getState(); + newState = decrementReaders(); + } while (!compareAndSetState(currentState, newState)); + + return true; + } + + @Override + protected boolean isHeldExclusively() { + return getExclusiveOwnerThread() == Thread.currentThread(); + } + + Condition newCondition() { + return new ConditionObject(); + } + } + + private static class ReadLock implements Lock { + private final Sync sync; + + ReadLock(Sync sync) { + this.sync = sync; + } + + @Override + public void lock() { + sync.acquireShared(1); + } + + @Override + public void lockInterruptibly() throws InterruptedException { + sync.acquireSharedInterruptibly(1); + } + + @Override + public boolean tryLock() { + return sync.tryAcquireShared(1) >= 0; + } + + @Override + public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { + return sync.tryAcquireSharedNanos(1, unit.toNanos(time)); + } + + @Override + public void unlock() { + sync.releaseShared(1); + } + + @Override + public Condition newCondition() { + throw new UnsupportedOperationException(""Read locks don't support conditions""); + } + } + + private static class WriteLock implements Lock { + private final Sync sync; + + WriteLock(Sync sync) { + this.sync = sync; + } + + @Override + public void lock() { + sync.acquire(1); + } + + @Override + public void lockInterruptibly() throws InterruptedException { + sync.acquireInterruptibly(1); + } + + @Override + public boolean tryLock() { + return sync.tryAcquire(1); + } + + @Override + public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { + return sync.tryAcquireNanos(1, unit.toNanos(time)); + } + + @Override + public void unlock() { + sync.release(1); + } + + @Override + public Condition newCondition() { + return sync.newCondition(); + } + } + + @Override + public Lock readLock() { + return new ReadLock(sync); + } + + @Override + public Lock writeLock() { + return new WriteLock(sync); + } +}",1.0,DEEPSEEK,Implement a read-write lock that gives preference to writers to prevent writer starvation.,java,"import java.util.concurrent.locks.AbstractQueuedSynchronizer; +import java.util.concurrent.locks.Condition; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReadWriteLock; + +public class WriterPreferenceReadWriteLock implements ReadWriteLock { + private final Sync sync; + + public WriterPreferenceReadWriteLock() { + this.sync = new Sync(); + } + + private static class Sync extends AbstractQueuedSynchronizer { + private static final int READER_MASK = (1 << 16) - 1; + private static final int WRITER_MASK = ~READER_MASK; + + private int readers() { + return getState() & READER_MASK; + } + + private int writers() { + return (getState() >>> 16) & READER_MASK; + } + + private int incrementReaders() { + return getState() + 1; + } + + private int decrementReaders() { + return getState() - 1; + } + + private int incrementWriters() { + return getState() + (1 << 16); + } + + private int decrementWriters() { + return getState() - (1 << 16); + } + + @Override + protected boolean tryAcquire(int arg) { + Thread current = Thread.currentThread(); + int state = getState(); + + // If no readers or writers, try to acquire write lock + if (state == 0) { + if (compareAndSetState(0, 1 << 16)) { + setExclusiveOwnerThread(current); + return true; +... truncated ... + } + + private static class WriteLock implements Lock { + private final Sync sync; + + WriteLock(Sync sync) { + this.sync = sync; + } + + @Override + public void lock() { + sync.acquire(1); + } + + @Override + public void lockInterruptibly() throws InterruptedException { + sync.acquireInterruptibly(1); + } + + @Override + public boolean tryLock() { + return sync.tryAcquire(1); + } + + @Override + public boolean tryLock(long time, TimeUnit unit) throws InterruptedException { + return sync.tryAcquireNanos(1, unit.toNanos(time)); + } + + @Override + public void unlock() { + sync.release(1); + } + + @Override + public Condition newCondition() { + return sync.newCondition(); + } + } + + @Override + public Lock readLock() { + return new ReadLock(sync); + } + + @Override + public Lock writeLock() { + return new WriteLock(sync); + } +}",203,101 +,"class Solution { + public int findMaxLength(int[] nums) { + // Map to store first occurrence of diff + HashMap map = new HashMap<>(); + + int zero = 0, one = 0; + int res = 0; + + for (int i = 0; i < nums.length; i++) { + + if (nums[i] == 0) + zero++; + else + one++; + + int diff = zero - one; + + // If diff == 0, subarray from 0 to i is valid + if (diff == 0) { + res = Math.max(res, i + 1); + } + + // If diff not seen before, store index + if (!map.containsKey(diff)) { + map.put(diff, i); + } + // If seen before, calculate length + else { + int idx = map.get(diff); + int len = i - idx; + res = Math.max(res, len); + } + } + + return res; + } +}",0.0,leetcode,,java,"class Solution { + public int findMaxLength(int[] nums) { + // Map to store first occurrence of diff + HashMap map = new HashMap<>(); + + int zero = 0, one = 0; + int res = 0; + + for (int i = 0; i < nums.length; i++) { + + if (nums[i] == 0) + zero++; + else + one++; + + int diff = zero - one; + + // If diff == 0, subarray from 0 to i is valid + if (diff == 0) { + res = Math.max(res, i + 1); + } + + // If diff not seen before, store index + if (!map.containsKey(diff)) { + map.put(diff, i); + } + // If seen before, calculate length + else { + int idx = map.get(diff); + int len = i - idx; + res = Math.max(res, len); + } + } + + return res; + } +}",37,37 +,"public class PalindromeChecker { + public static boolean isPalindrome(String s) { + s = s.toLowerCase().replaceAll(""[^a-z0-9]"", """"); + int left = 0, right = s.length() - 1; + while (left < right) { + if (s.charAt(left++) != s.charAt(right--)) return false; + } + return true; + } +} +",1.0,PERPLEXITY,"Write a Java static method to check if a string is a palindrome, ignoring case and non-alphanumeric chars.",java,"public class PalindromeChecker { + public static boolean isPalindrome(String s) { + s = s.toLowerCase().replaceAll(""[^a-z0-9]"", """"); + int left = 0, right = s.length() - 1; + while (left < right) { + if (s.charAt(left++) != s.charAt(right--)) return false; + } + return true; + } +}",10,10 +,"class Solution { + public int getImportance(List employees, int id) { + Map inputMap = new HashMap<>(); + // Construct HashMap as getting the employee from id is difficult in a list + for(Employee e : employees) { + inputMap.put(e.id, e); + } + return helper(inputMap, id); + } + + private static int helper(Map inputMap, int id) { + //Get the importance of the employee + int imp = inputMap.get(id).importance; + + //Add importance of subordinates to employee importance + for(int subId : inputMap.get(id).subordinates) { + imp += helper(inputMap, subId); + } + + return imp; + } +}",0.0,leetcode,,java,"class Solution { + public int getImportance(List employees, int id) { + Map inputMap = new HashMap<>(); + // Construct HashMap as getting the employee from id is difficult in a list + for(Employee e : employees) { + inputMap.put(e.id, e); + } + return helper(inputMap, id); + } + + private static int helper(Map inputMap, int id) { + //Get the importance of the employee + int imp = inputMap.get(id).importance; + + //Add importance of subordinates to employee importance + for(int subId : inputMap.get(id).subordinates) { + imp += helper(inputMap, subId); + } + + return imp; + } +}",22,22 +,"import heapq + +def swimInWater(grid): + n = len(grid) + heap = [(grid[0][0], 0, 0)] + visited = set() + + while heap: + time, r, c = heapq.heappop(heap) + if (r, c) in visited: + continue + visited.add((r, c)) + if r == n - 1 and c == n - 1: + return time + for dr, dc in [(1,0), (-1,0), (0,1), (0,-1)]: + nr, nc = r + dr, c + dc + if 0 <= nr < n and 0 <= nc < n: + heapq.heappush(heap, (max(time, grid[nr][nc]), nr, nc)) +",1.0,GPT,"Solve the problem ""Swim in Rising Water"". + +Given an n x n grid, +return the minimum time required to swim from top-left to bottom-right.",python,"import heapq + +def swimInWater(grid): + n = len(grid) + heap = [(grid[0][0], 0, 0)] + visited = set() + + while heap: + time, r, c = heapq.heappop(heap) + if (r, c) in visited: + continue + visited.add((r, c)) + if r == n - 1 and c == n - 1: + return time + for dr, dc in [(1,0), (-1,0), (0,1), (0,-1)]: + nr, nc = r + dr, c + dc + if 0 <= nr < n and 0 <= nc < n: + heapq.heappush(heap, (max(time, grid[nr][nc]), nr, nc))",18,18 +,"import java.util.*; + +class Solution { + public List subdomainVisits(String[] cpdomains) { + Map map = new HashMap<>(); + + for (String domainCount : cpdomains) { + int spaceIndex = domainCount.indexOf(' '); + int count = Integer.parseInt(domainCount.substring(0, spaceIndex)); + String domain = domainCount.substring(spaceIndex + 1); + + // Process each subdomain + while (true) { + map.merge(domain, count, Integer::sum); + int dotIndex = domain.indexOf('.'); + if (dotIndex == -1) break; + domain = domain.substring(dotIndex + 1); + } + } + + List result = new ArrayList<>(map.size()); + for (Map.Entry entry : map.entrySet()) { + result.add(entry.getValue() + "" "" + entry.getKey()); + } + + return result; + } +}",0.0,leetcode,,java,"import java.util.*; + +class Solution { + public List subdomainVisits(String[] cpdomains) { + Map map = new HashMap<>(); + + for (String domainCount : cpdomains) { + int spaceIndex = domainCount.indexOf(' '); + int count = Integer.parseInt(domainCount.substring(0, spaceIndex)); + String domain = domainCount.substring(spaceIndex + 1); + + // Process each subdomain + while (true) { + map.merge(domain, count, Integer::sum); + int dotIndex = domain.indexOf('.'); + if (dotIndex == -1) break; + domain = domain.substring(dotIndex + 1); + } + } + + List result = new ArrayList<>(map.size()); + for (Map.Entry entry : map.entrySet()) { + result.add(entry.getValue() + "" "" + entry.getKey()); + } + + return result; + } +}",28,28 +,"import hashlib + +class Bloom: + def __init__(s,n,k): + s.n,s.k,s.b=n,k,[0]*n + + def _h(s,x): + h1=int(hashlib.sha256(x.encode()).hexdigest(),16) + h2=int(hashlib.md5(x.encode()).hexdigest(),16) + return [(h1+i*h2)%s.n for i in range(s.k)] + + def add(s,x): + for i in s._h(x): s.b[i]=1 + + def check(s,x): + return all(s.b[i] for i in s._h(x)) +",1.0,GPT,"WRITE THE PYTHON CODE FOR Bloom Filter Implementation with i/o , let the code you provide be efficient and accurate for the results it provide",python,"import hashlib + +class Bloom: + def __init__(s,n,k): + s.n,s.k,s.b=n,k,[0]*n + + def _h(s,x): + h1=int(hashlib.sha256(x.encode()).hexdigest(),16) + h2=int(hashlib.md5(x.encode()).hexdigest(),16) + return [(h1+i*h2)%s.n for i in range(s.k)] + + def add(s,x): + for i in s._h(x): s.b[i]=1 + + def check(s,x): + return all(s.b[i] for i in s._h(x))",16,16 +,"import requests +from bs4 import BeautifulSoup + +url = 'https://www.wikipedia.org/' +soup = BeautifulSoup(requests.get(url).text, 'html.parser') + +langs = soup.find('ul', class_='languages').find_all('li') +for lang in langs: + name = lang.text.strip() + count = lang.a['title'].split(' ')[0].replace(',', '') + print(f""{name}: {count}"") ",1.0,PERPLEXITY,Write a Python program to list all language names and number of related articles in the order they appear in wikipedia.org.,python,"import requests +from bs4 import BeautifulSoup + +url = 'https://www.wikipedia.org/' +soup = BeautifulSoup(requests.get(url).text, 'html.parser') + +langs = soup.find('ul', class_='languages').find_all('li') +for lang in langs: + name = lang.text.strip() + count = lang.a['title'].split(' ')[0].replace(',', '') + print(f""{name}: {count}"")",11,11 +,"#https://bit.ly/2lVhlLX +# via: https://analytics.usa.gov/ +import requests +url = 'https://analytics.usa.gov/data/live/realtime.json' +j = requests.get(url).json() +print(""Number of people visiting a U.S. government website-"") +print(""Active Users Right Now:"") +print(j['data'][0]['active_visitors']) + ",0.0,WE3RESOURCE,,python,"#https://bit.ly/2lVhlLX +# via: https://analytics.usa.gov/ +import requests +url = 'https://analytics.usa.gov/data/live/realtime.json' +j = requests.get(url).json() +print(""Number of people visiting a U.S. government website-"") +print(""Active Users Right Now:"") +print(j['data'][0]['active_visitors'])",8,8 +,"def trap(height): + l, r = 0, len(height) - 1 + left_max = right_max = 0 + res = 0 + + while l < r: + if height[l] < height[r]: + left_max = max(left_max, height[l]) + res += left_max - height[l] + l += 1 + else: + right_max = max(right_max, height[r]) + res += right_max - height[r] + r -= 1 + + return res +",1.0,GPT,"Given an array height representing elevation map, +compute how much water it can trap after raining.",python,"def trap(height): + l, r = 0, len(height) - 1 + left_max = right_max = 0 + res = 0 + + while l < r: + if height[l] < height[r]: + left_max = max(left_max, height[l]) + res += left_max - height[l] + l += 1 + else: + right_max = max(right_max, height[r]) + res += right_max - height[r] + r -= 1 + + return res",16,16 +,"class Solution { + public boolean isPossible(int[] nums) { + // freq: counts how many of each number are available to be used + Map freq = new HashMap<>(); + // want: counts how many sequences are currently ending at (x-1) and need 'x' + Map want = new HashMap<>(); + + for (int i : nums) freq.put(i, freq.getOrDefault(i, 0) + 1); + + for (int i : nums) { + if (freq.get(i) == 0) continue; // Already consumed by a previous 'new sequence' check + + // Option 1: Try to extend an existing sequence + if (want.getOrDefault(i, 0) > 0) { + freq.put(i, freq.get(i) - 1); + want.put(i, want.get(i) - 1); + want.put(i + 1, want.getOrDefault(i + 1, 0) + 1); + } + // Option 2: Try to create a new sequence of length 3 + else if (freq.getOrDefault(i + 1, 0) > 0 && freq.getOrDefault(i + 2, 0) > 0) { + freq.put(i, freq.get(i) - 1); + freq.put(i + 1, freq.get(i + 1) - 1); + freq.put(i + 2, freq.get(i + 2) - 1); + // This sequence now ends at i+2, so it looks forward to i+3 + want.put(i + 3, want.getOrDefault(i + 3, 0) + 1); + } + // Option 3: Impossible to use 'i' validly + else { + return false; + } + } + return true; + } +}",0.0,leetcode,,java,"class Solution { + public boolean isPossible(int[] nums) { + // freq: counts how many of each number are available to be used + Map freq = new HashMap<>(); + // want: counts how many sequences are currently ending at (x-1) and need 'x' + Map want = new HashMap<>(); + + for (int i : nums) freq.put(i, freq.getOrDefault(i, 0) + 1); + + for (int i : nums) { + if (freq.get(i) == 0) continue; // Already consumed by a previous 'new sequence' check + + // Option 1: Try to extend an existing sequence + if (want.getOrDefault(i, 0) > 0) { + freq.put(i, freq.get(i) - 1); + want.put(i, want.get(i) - 1); + want.put(i + 1, want.getOrDefault(i + 1, 0) + 1); + } + // Option 2: Try to create a new sequence of length 3 + else if (freq.getOrDefault(i + 1, 0) > 0 && freq.getOrDefault(i + 2, 0) > 0) { + freq.put(i, freq.get(i) - 1); + freq.put(i + 1, freq.get(i + 1) - 1); + freq.put(i + 2, freq.get(i + 2) - 1); + // This sequence now ends at i+2, so it looks forward to i+3 + want.put(i + 3, want.getOrDefault(i + 3, 0) + 1); + } + // Option 3: Impossible to use 'i' validly + else { + return false; + } + } + return true; + } +}",34,34 +,"def maxProfit(prices): + min_price = float('inf') + max_profit = 0 + + for price in prices: + min_price = min(min_price, price) + max_profit = max(max_profit, price - min_price) + + return max_profit +",1.0,GPT,"You are given an array prices where prices[i] is the price of a stock on day i. +You may choose one day to buy and a later day to sell. +Return the maximum profit you can achieve. If no profit is possible, return 0. + +Provide: +- An optimal O(n) solution +- Explanation of the approach +- Python implementation",python,"def maxProfit(prices): + min_price = float('inf') + max_profit = 0 + + for price in prices: + min_price = min(min_price, price) + max_profit = max(max_profit, price - min_price) + + return max_profit",9,9 +,"# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, val=0, left=None, right=None): +# self.val = val +# self.left = left +# self.right = right + +class Solution: + def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: + if not root: + return None + stack = [root] + while stack: + node = stack.pop() + node.left, node.right = node.right, node.left + if node.left: + stack.append(node.left) + if node.right: + stack.append(node.right) + return root",0.0,GFG,,python,"# Definition for a binary tree node. +# class TreeNode: +# def __init__(self, val=0, left=None, right=None): +# self.val = val +# self.left = left +# self.right = right + +class Solution: + def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]: + if not root: + return None + stack = [root] + while stack: + node = stack.pop() + node.left, node.right = node.right, node.left + if node.left: + stack.append(node.left) + if node.right: + stack.append(node.right) + return root",20,20 +,"from bs4 import BeautifulSoup +import requests + +handle = input('Input your account name on Twitter: ') +temp = requests.get('https://twitter.com/'+handle) +bs = BeautifulSoup(temp.text,'lxml') + +try: + tweet_box = bs.find('li',{'class':'ProfileNav-item ProfileNav-item--tweets is-active'}) + tweets= tweet_box.find('a').find('span',{'class':'ProfileNav-value'}) + print(""{} tweets {} number of tweets."".format(handle,tweets.get('data-count'))) + +except: + print('Account name not found...') + ",0.0,WERESOURCE,,python,"from bs4 import BeautifulSoup +import requests + +handle = input('Input your account name on Twitter: ') +temp = requests.get('https://twitter.com/'+handle) +bs = BeautifulSoup(temp.text,'lxml') + +try: + tweet_box = bs.find('li',{'class':'ProfileNav-item ProfileNav-item--tweets is-active'}) + tweets= tweet_box.find('a').find('span',{'class':'ProfileNav-value'}) + print(""{} tweets {} number of tweets."".format(handle,tweets.get('data-count'))) + +except: + print('Account name not found...')",14,14 +,"class Solution { + public boolean wordPattern(String pattern, String s) { + + String[] words = s.split("" ""); + + if (pattern.length() != words.length) return false; + + Map charWord = new HashMap<>(); + Map wordChar = new HashMap<>(); + + for (int i = 0; i < pattern.length(); i++) { + char ch = pattern.charAt(i); + String word = words[i]; + + if (charWord.containsKey(ch)) { + if (!charWord.get(ch).equals(word)) { + return false; + } + } else if (wordChar.containsKey(word)) { + return false; + } else { + charWord.put(ch, word); + wordChar.put(word, ch); + } + } + + return true; + } +}",0.0,leetcode,,java,"class Solution { + public boolean wordPattern(String pattern, String s) { + + String[] words = s.split("" ""); + + if (pattern.length() != words.length) return false; + + Map charWord = new HashMap<>(); + Map wordChar = new HashMap<>(); + + for (int i = 0; i < pattern.length(); i++) { + char ch = pattern.charAt(i); + String word = words[i]; + + if (charWord.containsKey(ch)) { + if (!charWord.get(ch).equals(word)) { + return false; + } + } else if (wordChar.containsKey(word)) { + return false; + } else { + charWord.put(ch, word); + wordChar.put(word, ch); + } + } + + return true; + } +}",29,29 +,"import heapq + +# Define a class to represent a node in the graph +class Node: + def __init__(self, state, parent=None, action=None, cost=0, heuristic=0): + self.state = state # Current state + self.parent = parent # Parent node + self.action = action # Action taken to reach this node + self.cost = cost # Cost from start node to this node + self.heuristic = heuristic # Heuristic estimate of cost to goal + + # Compare nodes based on total cost (cost + heuristic) + def __lt__(self, other): + return (self.cost + self.heuristic) < (other.cost + other.heuristic) + +# Define the A* search function +def astar_search(start_state, goal_state, actions, transition_model, cost_fn, heuristic_fn): + # Initialize start node + start_node = Node(state=start_state, cost=0, heuristic=heuristic_fn(start_state)) + + # Priority queue for open nodes + open_nodes = [] + heapq.heappush(open_nodes, start_node) + + # Set of explored states + explored = set() + + while open_nodes: + # Pop node with lowest total cost from priority queue + current_node = heapq.heappop(open_nodes) + + # Check if goal state reached + if current_node.state == goal_state: + return get_solution(current_node) + + # Add current state to explored set + explored.add(current_node.state) + + # Generate successor states + for action in actions(current_node.state): # Fix: Call actions function with current state + next_state = transition_model(current_node.state, action) + if next_state not in explored: + cost = current_node.cost + cost_fn(current_node.state, action, next_state) + heuristic = heuristic_fn(next_state) + next_node = Node(state=next_state, parent=current_node, action=action, cost=cost, heuristic=heuristic) + heapq.heappush(open_nodes, next_node) + + return None # No solution found + +# Function to reconstruct the solution path +def get_solution(node): + path = [] + while node: + path.append((node.state, node.action)) + node = node.parent + return list(reversed(path)) + +# Example usage: +if __name__ == ""__main__"": + # Define example functions and parameters for pathfinding problem + def actions(state): + return ['up', 'down', 'left', 'right'] + + def transition_model(state, action): + if action == 'up': + return (state[0] - 1, state[1]) + elif action == 'down': + return (state[0] + 1, state[1]) + elif action == 'left': + return (state[0], state[1] - 1) + elif action == 'right': + return (state[0], state[1] + 1) + + def cost_fn(state, action, next_state): + return 1 + + def heuristic_fn(state): + return abs(state[0] - goal_state[0]) + abs(state[1] - goal_state[1]) + + # Define start and goal states + start_state = (0, 0) + goal_state = (3, 3) + + # Perform A* search + solution = astar_search(start_state, goal_state, actions, transition_model, cost_fn, heuristic_fn) + print(""Solution:"", solution) ",0.0,W3RESOURCE,,python,"import heapq + +# Define a class to represent a node in the graph +class Node: + def __init__(self, state, parent=None, action=None, cost=0, heuristic=0): + self.state = state # Current state + self.parent = parent # Parent node + self.action = action # Action taken to reach this node + self.cost = cost # Cost from start node to this node + self.heuristic = heuristic # Heuristic estimate of cost to goal + + # Compare nodes based on total cost (cost + heuristic) + def __lt__(self, other): + return (self.cost + self.heuristic) < (other.cost + other.heuristic) + +# Define the A* search function +def astar_search(start_state, goal_state, actions, transition_model, cost_fn, heuristic_fn): + # Initialize start node + start_node = Node(state=start_state, cost=0, heuristic=heuristic_fn(start_state)) + + # Priority queue for open nodes + open_nodes = [] + heapq.heappush(open_nodes, start_node) + + # Set of explored states + explored = set() + + while open_nodes: + # Pop node with lowest total cost from priority queue + current_node = heapq.heappop(open_nodes) + + # Check if goal state reached + if current_node.state == goal_state: + return get_solution(current_node) + + # Add current state to explored set + explored.add(current_node.state) + + # Generate successor states + for action in actions(current_node.state): # Fix: Call actions function with current state + next_state = transition_model(current_node.state, action) + if next_state not in explored: + cost = current_node.cost + cost_fn(current_node.state, action, next_state) + heuristic = heuristic_fn(next_state) + next_node = Node(state=next_state, parent=current_node, action=action, cost=cost, heuristic=heuristic) + heapq.heappush(open_nodes, next_node) + + return None # No solution found + +# Function to reconstruct the solution path +def get_solution(node): + path = [] + while node: + path.append((node.state, node.action)) + node = node.parent + return list(reversed(path)) + +# Example usage: +if __name__ == ""__main__"": + # Define example functions and parameters for pathfinding problem + def actions(state): + return ['up', 'down', 'left', 'right'] + + def transition_model(state, action): + if action == 'up': + return (state[0] - 1, state[1]) + elif action == 'down': + return (state[0] + 1, state[1]) + elif action == 'left': + return (state[0], state[1] - 1) + elif action == 'right': + return (state[0], state[1] + 1) + + def cost_fn(state, action, next_state): + return 1 + + def heuristic_fn(state): + return abs(state[0] - goal_state[0]) + abs(state[1] - goal_state[1]) + + # Define start and goal states + start_state = (0, 0) + goal_state = (3, 3) + + # Perform A* search + solution = astar_search(start_state, goal_state, actions, transition_model, cost_fn, heuristic_fn) + print(""Solution:"", solution)",86,86 +,"class Solution: + def numIslands(self, grid: List[List[str]]) -> int: + directions = [[1, 0], [-1, 0], [0, 1], [0, -1]] + ROWS, COLS = len(grid), len(grid[0]) + islands = 0 + + def bfs(r, c): + q = deque() + grid[r][c] = ""0"" + q.append((r, c)) + + while q: + row, col = q.popleft() + for dr, dc in directions: + nr, nc = dr + row, dc + col + if (nr < 0 or nc < 0 or nr >= ROWS or + nc >= COLS or grid[nr][nc] == ""0"" + ): + continue + q.append((nr, nc)) + grid[nr][nc] = ""0"" + + for r in range(ROWS): + for c in range(COLS): + if grid[r][c] == ""1"": + bfs(r, c) + islands += 1 + + return islands",0.0,GFG,,python,"class Solution: + def numIslands(self, grid: List[List[str]]) -> int: + directions = [[1, 0], [-1, 0], [0, 1], [0, -1]] + ROWS, COLS = len(grid), len(grid[0]) + islands = 0 + + def bfs(r, c): + q = deque() + grid[r][c] = ""0"" + q.append((r, c)) + + while q: + row, col = q.popleft() + for dr, dc in directions: + nr, nc = dr + row, dc + col + if (nr < 0 or nc < 0 or nr >= ROWS or + nc >= COLS or grid[nr][nc] == ""0"" + ): + continue + q.append((nr, nc)) + grid[nr][nc] = ""0"" + + for r in range(ROWS): + for c in range(COLS): + if grid[r][c] == ""1"": + bfs(r, c) + islands += 1 + + return islands",29,29 +,"import requests +from requests.exceptions import SSLError, RequestException + +url = ""https://www.google.com"" # valid SSL certificate + +try: + # By default, verify=True, so SSL certificates are checked + response = requests.get(url, timeout=10) + print(""Status Code:"", response.status_code) + print(""SSL certificate verified successfully."") + +except SSLError as ssl_err: + print(""SSL Certificate verification failed!"") + print(ssl_err) + +except RequestException as req_err: + print(""Request failed:"") + print(req_err) ",1.0,GPT," Write a Python program to verifiy SSL certificates for HTTPS requests using requests module. +Note: Requests verifies SSL certificates for HTTPS requests, just like a web browser. By default, SSL verification is enabled, and Requests will throw a SSLError if it's unable to verify the certificate",python,"import requests +from requests.exceptions import SSLError, RequestException + +url = ""https://www.google.com"" # valid SSL certificate + +try: + # By default, verify=True, so SSL certificates are checked + response = requests.get(url, timeout=10) + print(""Status Code:"", response.status_code) + print(""SSL certificate verified successfully."") + +except SSLError as ssl_err: + print(""SSL Certificate verification failed!"") + print(ssl_err) + +except RequestException as req_err: + print(""Request failed:"") + print(req_err)",18,18 +,"public class MergeArrays { + public static int[] merge(int[] a, int[] b) { + int[] result = new int[a.length + b.length]; + int i = 0, j = 0, k = 0; + while (i < a.length && j < b.length) { + if (a[i] <= b[j]) result[k++] = a[i++]; + else result[k++] = b[j++]; + } + while (i < a.length) result[k++] = a[i++]; + while (j < b.length) result[k++] = b[j++]; + return result; + } +} +",1.0,PERPLEXITY,Create a Java method that merges two sorted integer arrays into one sorted array without extra space if possible.,java,"public class MergeArrays { + public static int[] merge(int[] a, int[] b) { + int[] result = new int[a.length + b.length]; + int i = 0, j = 0, k = 0; + while (i < a.length && j < b.length) { + if (a[i] <= b[j]) result[k++] = a[i++]; + else result[k++] = b[j++]; + } + while (i < a.length) result[k++] = a[i++]; + while (j < b.length) result[k++] = b[j++]; + return result; + } +}",13,13 +,"class Solution { + public int nthUglyNumber(int n) { + int[] primes = {2, 3, 5}; + PriorityQueue uglyHeap = new PriorityQueue<>(); + HashSet visited = new HashSet<>(); + + uglyHeap.add(1L); + visited.add(1L); + + long curr = 1L; + for (int i = 0; i < n; i++) { + curr = uglyHeap.poll(); + for (int prime : primes) { + long new_ugly = curr * prime; + if (!visited.contains(new_ugly)) { + uglyHeap.add(new_ugly); + visited.add(new_ugly); + } + } + } + return (int)curr; + } +}",0.0,leetcode,,java,"class Solution { + public int nthUglyNumber(int n) { + int[] primes = {2, 3, 5}; + PriorityQueue uglyHeap = new PriorityQueue<>(); + HashSet visited = new HashSet<>(); + + uglyHeap.add(1L); + visited.add(1L); + + long curr = 1L; + for (int i = 0; i < n; i++) { + curr = uglyHeap.poll(); + for (int prime : primes) { + long new_ugly = curr * prime; + if (!visited.contains(new_ugly)) { + uglyHeap.add(new_ugly); + visited.add(new_ugly); + } + } + } + return (int)curr; + } +}",23,23 +,"public class QuickSort { + public static void sort(int[] arr, int low, int high) { + if (low < high) { + int pi = partition(arr, low, high); + sort(arr, low, pi - 1); + sort(arr, pi + 1, high); + } + } + private static int partition(int[] arr, int low, int high) { + int pivot = arr[high]; + int i = low - 1; + for (int j = low; j < high; j++) { + if (arr[j] <= pivot) { + i++; + int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; + } + } + int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; + return i + 1; + } +} +",1.0,PERPLEXITY,Write a Java quicksort algorithm to sort an integer array in-place using the Lomuto partition scheme,java,"public class QuickSort { + public static void sort(int[] arr, int low, int high) { + if (low < high) { + int pi = partition(arr, low, high); + sort(arr, low, pi - 1); + sort(arr, pi + 1, high); + } + } + private static int partition(int[] arr, int low, int high) { + int pivot = arr[high]; + int i = low - 1; + for (int j = low; j < high; j++) { + if (arr[j] <= pivot) { + i++; + int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; + } + } + int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; + return i + 1; + } +}",21,21 +,"import java.util.*; + +class Solution { + public int openLock(String[] deadends, String target) { + Set deadendSet = new HashSet<>(Arrays.asList(deadends)); + if (deadendSet.contains(""0000"")) { + return -1; + } + + Queue> queue = new LinkedList<>(); + queue.offer(new Pair<>(""0000"", 0)); + Set visited = new HashSet<>(); + visited.add(""0000""); + + while (!queue.isEmpty()) { + Pair current = queue.poll(); + String currentCombination = current.getKey(); + int moves = current.getValue(); + + if (currentCombination.equals(target)) { + return moves; + } + + for (int i = 0; i < 4; i++) { + for (int delta : new int[]{-1, 1}) { + int newDigit = (currentCombination.charAt(i) - '0' + delta + 10) % 10; + String newCombination = currentCombination.substring(0, i) + + newDigit + + currentCombination.substring(i + 1); + + if (!visited.contains(newCombination) && !deadendSet.contains(newCombination)) { + visited.add(newCombination); + queue.offer(new Pair<>(newCombination, moves + 1)); + } + } + } + } + + return -1; // Target is not reachable + } +}",0.0,leetcode,,java,"import java.util.*; + +class Solution { + public int openLock(String[] deadends, String target) { + Set deadendSet = new HashSet<>(Arrays.asList(deadends)); + if (deadendSet.contains(""0000"")) { + return -1; + } + + Queue> queue = new LinkedList<>(); + queue.offer(new Pair<>(""0000"", 0)); + Set visited = new HashSet<>(); + visited.add(""0000""); + + while (!queue.isEmpty()) { + Pair current = queue.poll(); + String currentCombination = current.getKey(); + int moves = current.getValue(); + + if (currentCombination.equals(target)) { + return moves; + } + + for (int i = 0; i < 4; i++) { + for (int delta : new int[]{-1, 1}) { + int newDigit = (currentCombination.charAt(i) - '0' + delta + 10) % 10; + String newCombination = currentCombination.substring(0, i) + + newDigit + + currentCombination.substring(i + 1); + + if (!visited.contains(newCombination) && !deadendSet.contains(newCombination)) { + visited.add(newCombination); + queue.offer(new Pair<>(newCombination, moves + 1)); + } + } + } + } + + return -1; // Target is not reachable + } +}",41,41 +,"class TreeNode { + int val; TreeNode left, right; + TreeNode(int val) { this.val = val; } +} +public class TreeTraversal { + public void inorder(TreeNode root, List result) { + if (root == null) return; + inorder(root.left, result); + result.add(root.val); + inorder(root.right, result); + } +} +",1.0,PERPLEXITY,"Create a Java method for inorder traversal of a binary tree, collecting values in a List",java,"class TreeNode { + int val; TreeNode left, right; + TreeNode(int val) { this.val = val; } +} +public class TreeTraversal { + public void inorder(TreeNode root, List result) { + if (root == null) return; + inorder(root.left, result); + result.add(root.val); + inorder(root.right, result); + } +}",12,12 +,"import requests +from bs4 import BeautifulSoup +res = requests.get('https://hackevents.co/hackathons') +bs = BeautifulSoup(res.text, 'lxml') +hacks_data = bs.find_all('div',{'class':'hackathon '}) +for i,f in enumerate(hacks_data,1): + hacks_month = f.find('div',{'class':'date'}).find('div',{'class':'date-month'}).text.strip() + hacks_date = f.find('div',{'class':'date'}).find('div',{'class':'date-day-number'}).text.strip() + hacks_days = f.find('div',{'class':'date'}).find('div',{'class':'date-week-days'}).text.strip() + hacks_final_date = ""{} {}, {} "".format(hacks_date, hacks_month, hacks_days ) + hacks_name = f.find('div',{'class':'info'}).find('h2').text.strip() + hacks_city = f.find('div',{'class':'info'}).find('p').find('span',{'class':'city'}).text.strip() + hacks_country = f.find('div',{'class':'info'}).find('p').find('span',{'class':'country'}).text.strip() + print(""{:<5}{:<15}: {:<90}: {}, {}\n "".format(str(i)+')',hacks_final_date, hacks_name.title(), hacks_city, hacks_country)) + ",0.0,WERESOURCE,,python,"import requests +from bs4 import BeautifulSoup +res = requests.get('https://hackevents.co/hackathons') +bs = BeautifulSoup(res.text, 'lxml') +hacks_data = bs.find_all('div',{'class':'hackathon '}) +for i,f in enumerate(hacks_data,1): + hacks_month = f.find('div',{'class':'date'}).find('div',{'class':'date-month'}).text.strip() + hacks_date = f.find('div',{'class':'date'}).find('div',{'class':'date-day-number'}).text.strip() + hacks_days = f.find('div',{'class':'date'}).find('div',{'class':'date-week-days'}).text.strip() + hacks_final_date = ""{} {}, {} "".format(hacks_date, hacks_month, hacks_days ) + hacks_name = f.find('div',{'class':'info'}).find('h2').text.strip() + hacks_city = f.find('div',{'class':'info'}).find('p').find('span',{'class':'city'}).text.strip() + hacks_country = f.find('div',{'class':'info'}).find('p').find('span',{'class':'country'}).text.strip() + print(""{:<5}{:<15}: {:<90}: {}, {}\n "".format(str(i)+')',hacks_final_date, hacks_name.title(), hacks_city, hacks_country))",14,14 +,"class Solution: + def solve(self, board: List[List[str]]) -> None: + ROWS, COLS = len(board), len(board[0]) + directions = [(1, 0), (-1, 0), (0, 1), (0, -1)] + + def capture(): + q = deque() + for r in range(ROWS): + for c in range(COLS): + if (r == 0 or r == ROWS - 1 or + c == 0 or c == COLS - 1 and + board[r][c] == ""O"" + ): + q.append((r, c)) + while q: + r, c = q.popleft() + if board[r][c] == ""O"": + board[r][c] = ""T"" + for dr, dc in directions: + nr, nc = r + dr, c + dc + if 0 <= nr < ROWS and 0 <= nc < COLS: + q.append((nr, nc)) + + capture() + for r in range(ROWS): + for c in range(COLS): + if board[r][c] == ""O"": + board[r][c] = ""X"" + elif board[r][c] == ""T"": + board[r][c] = ""O""",0.0,GFG,,python,"class Solution: + def solve(self, board: List[List[str]]) -> None: + ROWS, COLS = len(board), len(board[0]) + directions = [(1, 0), (-1, 0), (0, 1), (0, -1)] + + def capture(): + q = deque() + for r in range(ROWS): + for c in range(COLS): + if (r == 0 or r == ROWS - 1 or + c == 0 or c == COLS - 1 and + board[r][c] == ""O"" + ): + q.append((r, c)) + while q: + r, c = q.popleft() + if board[r][c] == ""O"": + board[r][c] = ""T"" + for dr, dc in directions: + nr, nc = r + dr, c + dc + if 0 <= nr < ROWS and 0 <= nc < COLS: + q.append((nr, nc)) + + capture() + for r in range(ROWS): + for c in range(COLS): + if board[r][c] == ""O"": + board[r][c] = ""X"" + elif board[r][c] == ""T"": + board[r][c] = ""O""",30,30 +,"import heapq + +def minMeetingRooms(intervals): + if not intervals: + return 0 + + intervals.sort(key=lambda x: x[0]) + heap = [] + + for start, end in intervals: + if heap and heap[0] <= start: + heapq.heappop(heap) + heapq.heappush(heap, end) + + return len(heap) +",1.0,GPT,"Solve the problem ""Meeting Rooms II"". + +Given an array of meeting time intervals where intervals[i] = [start, end], +return the minimum number of conference rooms required.",python,"import heapq + +def minMeetingRooms(intervals): + if not intervals: + return 0 + + intervals.sort(key=lambda x: x[0]) + heap = [] + + for start, end in intervals: + if heap and heap[0] <= start: + heapq.heappop(heap) + heapq.heappush(heap, end) + + return len(heap)",15,15 +,"import org.apache.maven.plugin.AbstractMojo; +import org.apache.maven.plugin.MojoExecutionException; +import org.apache.maven.plugins.annotations.*; +@Mojo(name = ""generate-props"", defaultPhase = LifecyclePhase.GENERATE_RESOURCES) +public class PropertiesGeneratorMojo extends AbstractMojo { + @Parameter(defaultValue = ""${project.build.directory}"") + private String outputDirectory; + + public void execute() throws MojoExecutionException { + getLog().info(""Generating properties file...""); + // Generate properties logic here + getLog().info(""Properties file generated successfully""); + } +} +",1.0,PERPLEXITY,Write a basic Maven plugin MOJO class that generates a properties file.,java,"import org.apache.maven.plugin.AbstractMojo; +import org.apache.maven.plugin.MojoExecutionException; +import org.apache.maven.plugins.annotations.*; +@Mojo(name = ""generate-props"", defaultPhase = LifecyclePhase.GENERATE_RESOURCES) +public class PropertiesGeneratorMojo extends AbstractMojo { + @Parameter(defaultValue = ""${project.build.directory}"") + private String outputDirectory; + + public void execute() throws MojoExecutionException { + getLog().info(""Generating properties file...""); + // Generate properties logic here + getLog().info(""Properties file generated successfully""); + } +}",14,14 +,"class Solution { + int maxF=0; + List maxSumArr = new ArrayList<>(); + Map f = new HashMap<>(); + + public int[] findFrequentTreeSum(TreeNode root) { + solve(root); + + int[] arr = new int[maxSumArr.size()]; + for(int i=0; i maxF){ + maxSumArr.clear(); + maxSumArr.add(sum); + maxF = f.get(sum); + }else if(f.get(sum) == maxF){ + maxSumArr.add(sum); + } + + return sum; + } +}",0.0,leetcode,,java,"class Solution { + int maxF=0; + List maxSumArr = new ArrayList<>(); + Map f = new HashMap<>(); + + public int[] findFrequentTreeSum(TreeNode root) { + solve(root); + + int[] arr = new int[maxSumArr.size()]; + for(int i=0; i maxF){ + maxSumArr.clear(); + maxSumArr.add(sum); + maxF = f.get(sum); + }else if(f.get(sum) == maxF){ + maxSumArr.add(sum); + } + + return sum; + } +}",32,32 +,"import numpy as np +x = [1., 2., 3., 4.] +print(""Original array:"") +print(x) +print(""Largest integer smaller or equal to the division of the inputs:"") +print(np.floor_divide(x, 1.5)) +",0.0,W3RESOURCE,,python,"import numpy as np +x = [1., 2., 3., 4.] +print(""Original array:"") +print(x) +print(""Largest integer smaller or equal to the division of the inputs:"") +print(np.floor_divide(x, 1.5))",6,6 +,"import json + +with open('states.json') as f: + state_data= json.load(f) + +for state in state_data['states']: + del state['area_codes'] + +with open('new_states.json', 'w') as f: + json.dump(state_data, f, indent=2) ",0.0,WE3RESOURCE,,python,"import json + +with open('states.json') as f: + state_data= json.load(f) + +for state in state_data['states']: + del state['area_codes'] + +with open('new_states.json', 'w') as f: + json.dump(state_data, f, indent=2)",10,10 +,"import java.util.Arrays; +public class AnagramDetector { + public static boolean areAnagrams(String s1, String s2) { + s1 = s1.toLowerCase().replaceAll(""\\s"", """"); + s2 = s2.toLowerCase().replaceAll(""\\s"", """"); + if (s1.length() != s2.length()) return false; + char[] a1 = s1.toCharArray(); char[] a2 = s2.toCharArray(); + Arrays.sort(a1); Arrays.sort(a2); + return Arrays.equals(a1, a2); + } +} +",1.0,PERPLEXITY,"Create a Java function to detect if two strings are anagrams, ignoring case and spaces.",java,"import java.util.Arrays; +public class AnagramDetector { + public static boolean areAnagrams(String s1, String s2) { + s1 = s1.toLowerCase().replaceAll(""\\s"", """"); + s2 = s2.toLowerCase().replaceAll(""\\s"", """"); + if (s1.length() != s2.length()) return false; + char[] a1 = s1.toCharArray(); char[] a2 = s2.toCharArray(); + Arrays.sort(a1); Arrays.sort(a2); + return Arrays.equals(a1, a2); + } +}",11,11 +,"public class Solution { + public ListNode detectCycle(ListNode head) { + ListNode slow = head; + ListNode fast = head; + + while(fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + + if(slow == fast) { + slow = head; + + while(slow != fast) { + slow = slow.next; + fast = fast.next; + } + return slow; + } + } + return null; + } +}",0.0,leetcode,,java,"public class Solution { + public ListNode detectCycle(ListNode head) { + ListNode slow = head; + ListNode fast = head; + + while(fast != null && fast.next != null) { + slow = slow.next; + fast = fast.next.next; + + if(slow == fast) { + slow = head; + + while(slow != fast) { + slow = slow.next; + fast = fast.next; + } + return slow; + } + } + return null; + } +}",22,22 +,"class Solution: + def minEatingSpeed(self, piles: List[int], h: int) -> int: + l, r = 1, max(piles) + res = r + + while l <= r: + k = (l + r) // 2 + + totalTime = 0 + for p in piles: + totalTime += math.ceil(float(p) / k) + if totalTime <= h: + res = k + r = k - 1 + else: + l = k + 1 + return res",0.0,GFG,,python,"class Solution: + def minEatingSpeed(self, piles: List[int], h: int) -> int: + l, r = 1, max(piles) + res = r + + while l <= r: + k = (l + r) // 2 + + totalTime = 0 + for p in piles: + totalTime += math.ceil(float(p) / k) + if totalTime <= h: + res = k + r = k - 1 + else: + l = k + 1 + return res",17,17 +,"import numpy as np + +dt = [('name', 'U20'), ('height', 'f4'), ('class', 'i4')] +data = np.array([('Alice', 165, 2), ('Bob', 170.5, 1), ('Charlie', 168.2, 2), ('David', 172, 1), ('Eve', 160.4, 3)], dtype=dt) +print(np.sort(data, order=['class', 'height']))",1.0,DEEPAI,"Write a NumPy program to create a structured array from given student name, height, class and their data types. Now sort by class, then height if class are equal.",python,"import numpy as np + +dt = [('name', 'U20'), ('height', 'f4'), ('class', 'i4')] +data = np.array([('Alice', 165, 2), ('Bob', 170.5, 1), ('Charlie', 168.2, 2), ('David', 172, 1), ('Eve', 160.4, 3)], dtype=dt) +print(np.sort(data, order=['class', 'height']))",5,5 +,"# Define a function named 'perfect_number' that checks if a number 'n' is a perfect number +def perfect_number(n): + # Initialize a variable 'sum' to store the sum of factors of 'n' + sum = 0 + + # Iterate through numbers from 1 to 'n-1' using 'x' as the iterator + for x in range(1, n): + # Check if 'x' is a factor of 'n' (divides 'n' without remainder) + if n % x == 0: + # If 'x' is a factor of 'n', add it to the 'sum' + sum += x + + # Check if the 'sum' of factors is equal to the original number 'n' + return sum == n + +# Print the result of checking if 6 is a perfect number by calling the 'perfect_number' function +print(perfect_number(6))",0.0,W3RESOURCE,,python,"# Define a function named 'perfect_number' that checks if a number 'n' is a perfect number +def perfect_number(n): + # Initialize a variable 'sum' to store the sum of factors of 'n' + sum = 0 + + # Iterate through numbers from 1 to 'n-1' using 'x' as the iterator + for x in range(1, n): + # Check if 'x' is a factor of 'n' (divides 'n' without remainder) + if n % x == 0: + # If 'x' is a factor of 'n', add it to the 'sum' + sum += x + + # Check if the 'sum' of factors is equal to the original number 'n' + return sum == n + +# Print the result of checking if 6 is a perfect number by calling the 'perfect_number' function +print(perfect_number(6))",17,17 +,"import java.time.Duration; +import java.util.concurrent.Callable; +import java.util.concurrent.ThreadLocalRandom; +import java.util.function.Predicate; + +public class RetryExecutor { + private final int maxAttempts; + private final Duration initialDelay; + private final Duration maxDelay; + private final double backoffMultiplier; + private final Predicate retryPredicate; + + private RetryExecutor(Builder builder) { + this.maxAttempts = builder.maxAttempts; + this.initialDelay = builder.initialDelay; + this.maxDelay = builder.maxDelay; + this.backoffMultiplier = builder.backoffMultiplier; + this.retryPredicate = builder.retryPredicate; + } + + public T execute(Callable task) throws Exception { + Exception lastException = null; + Duration currentDelay = initialDelay; + + for (int attempt = 1; attempt <= maxAttempts; attempt++) { + try { + return task.call(); + } catch (Exception e) { + lastException = e; + + if (attempt == maxAttempts || !shouldRetry(e)) { + throw e; + } + + if (attempt < maxAttempts) { + sleepWithJitter(currentDelay); + currentDelay = calculateNextDelay(currentDelay); + } + } + } + + throw lastException; + } + + private boolean shouldRetry(Exception e) { + return retryPredicate == null || retryPredicate.test(e); + } + + private void sleepWithJitter(Duration delay) { + try { + long jitter = ThreadLocalRandom.current().nextLong( + (long) (delay.toMillis() * 0.1) + ); + Thread.sleep(delay.toMillis() + jitter); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new RuntimeException(""Retry interrupted"", e); + } + } + + private Duration calculateNextDelay(Duration currentDelay) { + long nextDelayMillis = (long) (currentDelay.toMillis() * backoffMultiplier); + if (nextDelayMillis > maxDelay.toMillis()) { + nextDelayMillis = maxDelay.toMillis(); + } + return Duration.ofMillis(nextDelayMillis); + } + + public static class Builder { + private int maxAttempts = 3; + private Duration initialDelay = Duration.ofMillis(100); + private Duration maxDelay = Duration.ofSeconds(30); + private double backoffMultiplier = 2.0; + private Predicate retryPredicate; + + public Builder maxAttempts(int maxAttempts) { + this.maxAttempts = maxAttempts; + return this; + } + + public Builder initialDelay(Duration initialDelay) { + this.initialDelay = initialDelay; + return this; + } + + public Builder maxDelay(Duration maxDelay) { + this.maxDelay = maxDelay; + return this; + } + + public Builder backoffMultiplier(double backoffMultiplier) { + this.backoffMultiplier = backoffMultiplier; + return this; + } + + public Builder retryOn(Predicate retryPredicate) { + this.retryPredicate = retryPredicate; + return this; + } + + public RetryExecutor build() { + return new RetryExecutor(this); + } + } +}",1.0,DEEPSEEK,Create a retry mechanism that handles transient failures with exponential backoff.,java,"import java.time.Duration; +import java.util.concurrent.Callable; +import java.util.concurrent.ThreadLocalRandom; +import java.util.function.Predicate; + +public class RetryExecutor { + private final int maxAttempts; + private final Duration initialDelay; + private final Duration maxDelay; + private final double backoffMultiplier; + private final Predicate retryPredicate; + + private RetryExecutor(Builder builder) { + this.maxAttempts = builder.maxAttempts; + this.initialDelay = builder.initialDelay; + this.maxDelay = builder.maxDelay; + this.backoffMultiplier = builder.backoffMultiplier; + this.retryPredicate = builder.retryPredicate; + } + + public T execute(Callable task) throws Exception { + Exception lastException = null; + Duration currentDelay = initialDelay; + + for (int attempt = 1; attempt <= maxAttempts; attempt++) { + try { + return task.call(); + } catch (Exception e) { + lastException = e; + + if (attempt == maxAttempts || !shouldRetry(e)) { + throw e; + } + + if (attempt < maxAttempts) { + sleepWithJitter(currentDelay); + currentDelay = calculateNextDelay(currentDelay); + } + } + } + + throw lastException; + } + + private boolean shouldRetry(Exception e) { + return retryPredicate == null || retryPredicate.test(e); + } + + private void sleepWithJitter(Duration delay) { + try { +... truncated ... + Thread.currentThread().interrupt(); + throw new RuntimeException(""Retry interrupted"", e); + } + } + + private Duration calculateNextDelay(Duration currentDelay) { + long nextDelayMillis = (long) (currentDelay.toMillis() * backoffMultiplier); + if (nextDelayMillis > maxDelay.toMillis()) { + nextDelayMillis = maxDelay.toMillis(); + } + return Duration.ofMillis(nextDelayMillis); + } + + public static class Builder { + private int maxAttempts = 3; + private Duration initialDelay = Duration.ofMillis(100); + private Duration maxDelay = Duration.ofSeconds(30); + private double backoffMultiplier = 2.0; + private Predicate retryPredicate; + + public Builder maxAttempts(int maxAttempts) { + this.maxAttempts = maxAttempts; + return this; + } + + public Builder initialDelay(Duration initialDelay) { + this.initialDelay = initialDelay; + return this; + } + + public Builder maxDelay(Duration maxDelay) { + this.maxDelay = maxDelay; + return this; + } + + public Builder backoffMultiplier(double backoffMultiplier) { + this.backoffMultiplier = backoffMultiplier; + return this; + } + + public Builder retryOn(Predicate retryPredicate) { + this.retryPredicate = retryPredicate; + return this; + } + + public RetryExecutor build() { + return new RetryExecutor(this); + } + } +}",105,101 +,"def sum_numbers(numbers): + return sum(numbers) + +print(sum_numbers([8, 2, 3, 0, 7])) # Output: 20 ",1.0,PERPLEXITY,"Write a Python function to sum all the numbers in a list. +Sample List : (8, 2, 3, 0, 7) +Expected Output : 20",python,"def sum_numbers(numbers): + return sum(numbers) + +print(sum_numbers([8, 2, 3, 0, 7])) # Output: 20",4,4 +,"static boolean match(String s,String p){ + boolean[][] d=new boolean[s.length()+1][p.length()+1]; + d[0][0]=true; + for(int j=2;j<=p.length();j++) + if(p.charAt(j-1)=='*') d[0][j]=d[0][j-2]; + for(int i=1;i<=s.length();i++) + for(int j=1;j<=p.length();j++) + if(p.charAt(j-1)=='*') + d[i][j]=d[i][j-2]||(d[i-1][j]&&(p.charAt(j-2)=='.'||p.charAt(j-2)==s.charAt(i-1))); + else + d[i][j]=d[i-1][j-1]&&(p.charAt(j-1)=='.'||p.charAt(j-1)==s.charAt(i-1)); + return d[s.length()][p.length()]; +} +",1.0,GPT,write a java program to Implement regex matcher with . and *. ,java,"static boolean match(String s,String p){ + boolean[][] d=new boolean[s.length()+1][p.length()+1]; + d[0][0]=true; + for(int j=2;j<=p.length();j++) + if(p.charAt(j-1)=='*') d[0][j]=d[0][j-2]; + for(int i=1;i<=s.length();i++) + for(int j=1;j<=p.length();j++) + if(p.charAt(j-1)=='*') + d[i][j]=d[i][j-2]||(d[i-1][j]&&(p.charAt(j-2)=='.'||p.charAt(j-2)==s.charAt(i-1))); + else + d[i][j]=d[i-1][j-1]&&(p.charAt(j-1)=='.'||p.charAt(j-1)==s.charAt(i-1)); + return d[s.length()][p.length()]; +}",13,13 +,"import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; + +public class SlidingWindowRateLimiter { + private final int maxRequests; + private final long windowMillis; + private final ConcurrentHashMap userWindows; + + private static class Window { + final ConcurrentLinkedQueue timestamps; + final AtomicInteger currentRequests; + + Window() { + this.timestamps = new ConcurrentLinkedQueue<>(); + this.currentRequests = new AtomicInteger(0); + } + } + + public SlidingWindowRateLimiter(int maxRequests, long windowDuration, TimeUnit timeUnit) { + this.maxRequests = maxRequests; + this.windowMillis = timeUnit.toMillis(windowDuration); + this.userWindows = new ConcurrentHashMap<>(); + } + + public boolean allowRequest(String userId) { + Window window = userWindows.computeIfAbsent(userId, k -> new Window()); + long currentTime = System.currentTimeMillis(); + long cutoffTime = currentTime - windowMillis; + + // Clean old timestamps + while (!window.timestamps.isEmpty() && + window.timestamps.peek() < cutoffTime) { + window.timestamps.poll(); + window.currentRequests.decrementAndGet(); + } + + // Check if under limit + if (window.currentRequests.get() >= maxRequests) { + return false; + } + + // Add new request + window.timestamps.offer(currentTime); + window.currentRequests.incrementAndGet(); + return true; + } + + public void reset(String userId) { + userWindows.remove(userId); + } +}",1.0,DEEPSEEK,Create a rate limiter that allows N requests per minute with sliding window algorithm.,java,"import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicInteger; + +public class SlidingWindowRateLimiter { + private final int maxRequests; + private final long windowMillis; + private final ConcurrentHashMap userWindows; + + private static class Window { + final ConcurrentLinkedQueue timestamps; + final AtomicInteger currentRequests; + + Window() { + this.timestamps = new ConcurrentLinkedQueue<>(); + this.currentRequests = new AtomicInteger(0); + } + } + + public SlidingWindowRateLimiter(int maxRequests, long windowDuration, TimeUnit timeUnit) { + this.maxRequests = maxRequests; + this.windowMillis = timeUnit.toMillis(windowDuration); + this.userWindows = new ConcurrentHashMap<>(); + } + + public boolean allowRequest(String userId) { + Window window = userWindows.computeIfAbsent(userId, k -> new Window()); + long currentTime = System.currentTimeMillis(); + long cutoffTime = currentTime - windowMillis; + + // Clean old timestamps + while (!window.timestamps.isEmpty() && + window.timestamps.peek() < cutoffTime) { + window.timestamps.poll(); + window.currentRequests.decrementAndGet(); + } + + // Check if under limit + if (window.currentRequests.get() >= maxRequests) { + return false; + } + + // Add new request + window.timestamps.offer(currentTime); + window.currentRequests.incrementAndGet(); + return true; + } + + public void reset(String userId) { + userWindows.remove(userId); + } +}",53,53 +,"# Define a function named 'test' that takes a parameter 'a' +def test(a): + # Define a nested function 'add' that takes a parameter 'b' + def add(b): + # Declare 'a' from the outer scope as nonlocal to modify its value + nonlocal a + + # Increment the value of 'a' by 1 + a += 1 + + # Return the sum of 'a' (modified by the nonlocal statement) and 'b' + return a + b + + # Return the inner function 'add' and its scope is retained due to closure + return add + +# Call the 'test' function with an argument '4' and assign the returned function to 'func' +func = test(4) + +# Call the function 'func' with argument '4' and print the result +print(func(4)) ",0.0,W3RESOURCE,,python,"# Define a function named 'test' that takes a parameter 'a' +def test(a): + # Define a nested function 'add' that takes a parameter 'b' + def add(b): + # Declare 'a' from the outer scope as nonlocal to modify its value + nonlocal a + + # Increment the value of 'a' by 1 + a += 1 + + # Return the sum of 'a' (modified by the nonlocal statement) and 'b' + return a + b + + # Return the inner function 'add' and its scope is retained due to closure + return add + +# Call the 'test' function with an argument '4' and assign the returned function to 'func' +func = test(4) + +# Call the function 'func' with argument '4' and print the result +print(func(4)) ",21,21 +,"class Solution: + + def findKthLargest(self, nums: List[int], k: int) -> int: + k = len(nums) - k + + def quickSelect(l, r): + pivot, p = nums[r], l + for i in range(l, r): + if nums[i] <= pivot: + nums[p], nums[i] = nums[i], nums[p] + p += 1 + nums[p], nums[r] = nums[r], nums[p] + + if p > k: + return quickSelect(l, p - 1) + elif p < k: + return quickSelect(p + 1, r) + else: + return nums[p] + + return quickSelect(0, len(nums) - 1)",0.0,GFG,,python,"class Solution: + + def findKthLargest(self, nums: List[int], k: int) -> int: + k = len(nums) - k + + def quickSelect(l, r): + pivot, p = nums[r], l + for i in range(l, r): + if nums[i] <= pivot: + nums[p], nums[i] = nums[i], nums[p] + p += 1 + nums[p], nums[r] = nums[r], nums[p] + + if p > k: + return quickSelect(l, p - 1) + elif p < k: + return quickSelect(p + 1, r) + else: + return nums[p] + + return quickSelect(0, len(nums) - 1)",21,21 +,"def canJump(nums): + max_reach = 0 + for i, n in enumerate(nums): + if i > max_reach: + return False + max_reach = max(max_reach, i + n) + return True +",1.0,GPT,"Solve the problem ""Jump Game"". + +Given an array nums where nums[i] represents maximum jump length, +return true if you can reach the last index.",python,"def canJump(nums): + max_reach = 0 + for i, n in enumerate(nums): + if i > max_reach: + return False + max_reach = max(max_reach, i + n) + return True",7,7 +,"class Solution { + public Node cloneGraph(Node node) { + if (node == null) return null; + Map copiedMap = new HashMap<>(); + bfs(node, copiedMap); + return copiedMap.get(node); + } + + private void bfs(Node startNode, Map copiedMap) { + Queue queue = new ArrayDeque<>(); // include nodes that have been visited (copied) only + + // check & copy node at Generation + copiedMap.put(startNode, new Node(startNode.val)); + queue.offer(startNode); + + while (!queue.isEmpty()) { + Node node = queue.poll(); + + // copy & link, add neighbors to Queue + for (Node neighbor: node.neighbors) { + // check & copy node at Generation + if (copiedMap.containsKey(neighbor)) { // neighbor is already visited (copied), just link + // IMPORTANT: DON'T JUST CONTINUE! + copiedMap.get(node).neighbors.add(copiedMap.get(neighbor)); + } else { // copy, link, add neighbor to queue to be visited + copiedMap.put(neighbor, new Node(neighbor.val)); + queue.offer(neighbor); + copiedMap.get(node).neighbors.add(copiedMap.get(neighbor)); + } + + } + } + } +}",0.0,leetcode,,java,"class Solution { + public Node cloneGraph(Node node) { + if (node == null) return null; + Map copiedMap = new HashMap<>(); + bfs(node, copiedMap); + return copiedMap.get(node); + } + + private void bfs(Node startNode, Map copiedMap) { + Queue queue = new ArrayDeque<>(); // include nodes that have been visited (copied) only + + // check & copy node at Generation + copiedMap.put(startNode, new Node(startNode.val)); + queue.offer(startNode); + + while (!queue.isEmpty()) { + Node node = queue.poll(); + + // copy & link, add neighbors to Queue + for (Node neighbor: node.neighbors) { + // check & copy node at Generation + if (copiedMap.containsKey(neighbor)) { // neighbor is already visited (copied), just link + // IMPORTANT: DON'T JUST CONTINUE! + copiedMap.get(node).neighbors.add(copiedMap.get(neighbor)); + } else { // copy, link, add neighbor to queue to be visited + copiedMap.put(neighbor, new Node(neighbor.val)); + queue.offer(neighbor); + copiedMap.get(node).neighbors.add(copiedMap.get(neighbor)); + } + + } + } + } +}",34,34