Datasets:

LLMLover

/

trainset_and_valid_benchmark

like 0

Write a function to find if the given number is a keith number or not.

def is_num_keith(x): terms = [] temp = x n = 0 while (temp > 0): terms.append(temp % 10) temp = int(temp / 10) n+=1 terms.reverse() next_term = 0 i = n while (next_term < x): next_term = 0 for j in range(1,n+1): next_term += terms[i - j] terms.append(next_term) i+=1 return (next_term == x)

Write a python function to count set bits of a given number.

def count_Set_Bits(n): count = 0 while (n): count += n & 1 n >>= 1 return count

Write a python function to merge the first and last elements separately in a list of lists.

def merge(lst): return [list(ele) for ele in list(zip(*lst))]

Write a function to find the n-th power of individual elements in a list using lambda function.

def nth_nums(nums,n): nth_nums = list(map(lambda x: x ** n, nums)) return nth_nums

Write a function to calculate the sum of perrin numbers.

def cal_sum(n): a = 3 b = 0 c = 2 if (n == 0): return 3 if (n == 1): return 3 if (n == 2): return 5 sum = 5 while (n > 2): d = a + b sum = sum + d a = b b = c c = d n = n-1 return sum

Write a function to find the list of lists with maximum length.

def max_length(list1): max_length = max(len(x) for x in list1 ) max_list = max((x) for x in list1) return(max_length, max_list)

Write a function to find nth centered hexagonal number.

def centered_hexagonal_number(n): return 3 * n * (n - 1) + 1

Write a python function to find the difference between sum of even and odd digits.

def is_Diff(n): return (n % 11 == 0)

Write a function to find the longest common prefix in the given set of strings.

def common_prefix_util(str1, str2): result = ""; n1 = len(str1) n2 = len(str2) i = 0 j = 0 while i <= n1 - 1 and j <= n2 - 1: if (str1[i] != str2[j]): break result += str1[i] i += 1 j += 1 return (result) def common_prefix (arr, n): prefix = arr[0] for i in range (1, n): prefix = common_prefix_util(prefix, arr[i]) return (prefix)

Write a python function to find the next perfect square greater than a given number.

import math def next_Perfect_Square(N): nextN = math.floor(math.sqrt(N)) + 1 return nextN * nextN

Write a python function to find the number of divisors of a given integer.

def divisor(n): for i in range(n): x = len([i for i in range(1,n+1) if not n % i]) return x

Write a python function to find the sum of fifth power of n natural numbers.

def fifth_Power_Sum(n) : sm = 0 for i in range(1,n+1) : sm = sm + (i*i*i*i*i) return sm

Write a function to find the n'th perrin number using recursion.

def get_perrin(n): if (n == 0): return 3 if (n == 1): return 0 if (n == 2): return 2 return get_perrin(n - 2) + get_perrin(n - 3)

Write a function to find the n'th lucas number.

def find_lucas(n): if (n == 0): return 2 if (n == 1): return 1 return find_lucas(n - 1) + find_lucas(n - 2)

Write a function to find sequences of lowercase letters joined with an underscore using regex.

import re def text_match(text): patterns = '^[a-z]+_[a-z]+$' if re.search(patterns, text): return ('Found a match!') else: return ('Not matched!')

Write a function to find the ration of positive numbers in an array of integers.

from array import array def positive_count(nums): n = len(nums) n1 = 0 for x in nums: if x > 0: n1 += 1 else: None return round(n1/n,2)

Write a function to find the ration of zeroes in an array of integers.

from array import array def zero_count(nums): n = len(nums) n1 = 0 for x in nums: if x == 0: n1 += 1 else: None return round(n1/n,2)

Write a python function to find the sum of all odd natural numbers within the range l and r.

def sum_Odd(n): terms = (n + 1)//2 sum1 = terms * terms return sum1 def sum_in_Range(l,r): return sum_Odd(r) - sum_Odd(l - 1)

Write a function to multiply the adjacent elements of the given tuple.

def multiply_elements(test_tup): res = tuple(i * j for i, j in zip(test_tup, test_tup[1:])) return (res)

Write a python function to check whether the given string is a binary string or not.

def check(string) : p = set(string) s = {'0', '1'} if s == p or p == {'0'} or p == {'1'}: return ("Yes") else : return ("No")

Write a function to find the item with maximum occurrences in a given list.

def max_occurrences(list1): max_val = 0 result = list1[0] for i in list1: occu = list1.count(i) if occu > max_val: max_val = occu result = i return result

Write a python function to check whether every even index contains even numbers of a given list.

def even_position(nums): return all(nums[i]%2==i%2 for i in range(len(nums)))

Write a python function to check whether the two numbers differ at one bit position only or not.

def is_Power_Of_Two (x): return x and (not(x & (x - 1))) def differ_At_One_Bit_Pos(a,b): return is_Power_Of_Two(a ^ b)

Write a python function to split a string into characters.

def split(word): return [char for char in word]

Write a function to find the n - expensive price items from a given dataset using heap queue algorithm.

import heapq def expensive_items(items,n): expensive_items = heapq.nlargest(n, items, key=lambda s: s['price']) return expensive_items

Write a function to assign with each element, its pair elements from other similar pairs in the given tuple.

def assign_elements(test_list): res = dict() for key, val in test_list: res.setdefault(val, []) res.setdefault(key, []).append(val) return (res)

Write a python function to determine whether all the numbers are different from each other are not.

def test_distinct(data): if len(data) == len(set(data)): return True else: return False;

Write a function to find nth polite number.

import math def is_polite(n): n = n + 1 return (int)(n+(math.log((n + math.log(n, 2)), 2)))

Write a function to find the maximum difference between the number of 0s and number of 1s in any sub-string of the given binary string.

def find_length(string, n): current_sum = 0 max_sum = 0 for i in range(n): current_sum += (1 if string[i] == '0' else -1) if current_sum < 0: current_sum = 0 max_sum = max(current_sum, max_sum) return max_sum if max_sum else 0

Write a python function to count the occurence of all elements of list in a tuple.

from collections import Counter def count_Occurrence(tup, lst): count = 0 for item in tup: if item in lst: count+= 1 return count

Write a function to find the demlo number for the given number.

def find_demlo(s): l = len(s) res = "" for i in range(1,l+1): res = res + str(i) for i in range(l-1,0,-1): res = res + str(i) return res

Write a function to find maximum possible sum of disjoint pairs for the given array of integers and a number k.

def max_sum_pair_diff_lessthan_K(arr, N, K): arr.sort() dp = [0] * N dp[0] = 0 for i in range(1, N): dp[i] = dp[i-1] if (arr[i] - arr[i-1] < K): if (i >= 2): dp[i] = max(dp[i], dp[i-2] + arr[i] + arr[i-1]); else: dp[i] = max(dp[i], arr[i] + arr[i-1]); return dp[N - 1]

Write a function to count the number of inversions in the given array.

def get_inv_count(arr, n): inv_count = 0 for i in range(n): for j in range(i + 1, n): if (arr[i] > arr[j]): inv_count += 1 return inv_count

Write a function to find the lcm of the given array elements.

def find_lcm(num1, num2): if(num1>num2): num = num1 den = num2 else: num = num2 den = num1 rem = num % den while (rem != 0): num = den den = rem rem = num % den gcd = den lcm = int(int(num1 * num2)/int(gcd)) return lcm def get_lcm(l): num1 = l[0] num2 = l[1] lcm = find_lcm(num1, num2) for i in range(2, len(l)): lcm = find_lcm(lcm, l[i]) return lcm

Write a python function to remove first and last occurrence of a given character from the string.

def remove_Occ(s,ch): for i in range(len(s)): if (s[i] == ch): s = s[0 : i] + s[i + 1:] break for i in range(len(s) - 1,-1,-1): if (s[i] == ch): s = s[0 : i] + s[i + 1:] break return s

Write a python function to find the sum of the largest and smallest value in a given array.

def big_sum(nums): sum= max(nums)+min(nums) return sum

Write a function to count alphabets,digits and special charactes in a given string.

def count_alpha_dig_spl(string): alphabets=digits = special = 0 for i in range(len(string)): if(string[i].isalpha()): alphabets = alphabets + 1 elif(string[i].isdigit()): digits = digits + 1 else: special = special + 1 return (alphabets,digits,special)

Write a function to count number of unique lists within a list.

def unique_sublists(list1): result ={} for l in list1: result.setdefault(tuple(l), list()).append(1) for a, b in result.items(): result[a] = sum(b) return result

Write a function to replace the last element of the list with another list.

def replace_list(list1,list2): list1[-1:] = list2 replace_list=list1 return replace_list

Write a function to remove specific words from a given list.

def remove_words(list1, removewords): for word in list(list1): if word in removewords: list1.remove(word) return list1

Write a function to find the circumference of a circle.

def circle_circumference(r): perimeter=2*3.1415*r return perimeter

Write a python function to find the sum of squares of binomial co-efficients.

def factorial(start,end): res = 1 for i in range(start,end + 1): res *= i return res def sum_of_square(n): return int(factorial(n + 1, 2 * n) /factorial(1, n))

Write a function to find the surface area of a sphere.

import math def surfacearea_sphere(r): surfacearea=4*math.pi*r*r return surfacearea

Write a function to find the minimum difference in the tuple pairs of given tuples.

def min_difference(test_list): temp = [abs(b - a) for a, b in test_list] res = min(temp) return (res)

Write a function to find the minimum value in a given heterogeneous list.

def min_val(listval): min_val = min(i for i in listval if isinstance(i, int)) return min_val

Write a function to sort a list of lists by length and value.

def sort_sublists(list1): list1.sort() list1.sort(key=len) return list1

Write a function to find sum of the numbers in a list between the indices of a specified range.

def sum_range_list(list1, m, n): sum_range = 0 for i in range(m, n+1, 1): sum_range += list1[i] return sum_range

Write a python function to find the sum of squares of first n even natural numbers.

def square_Sum(n): return int(2*n*(n+1)*(2*n+1)/3)

Write a function to calculate the height of the given binary tree.

class Node: def __init__(self, data): self.data = data self.left = None self.right = None def max_height(node): if node is None: return 0 ; else : left_height = max_height(node.left) right_height = max_height(node.right) if (left_height > right_height): return left_height+1 else: return right_height+1

root = Node(1) root.left = Node(2) root.right = Node(3) root.left.left = Node(4) root.left.right = Node(5) root1 = Node(1); root1.left = Node(2); root1.right = Node(3); root1.left.left = Node(4); root1.right.left = Node(5); root1.right.right = Node(6); root1.right.right.right= Node(7); root1.right.right.right.right = Node(8) root2 = Node(1) root2.left = Node(2) root2.right = Node(3) root2.left.left = Node(4) root2.left.right = Node(5) root2.left.left.left = Node(6) root2.left.left.right = Node(7)

Write a function to find the difference between two consecutive numbers in a given list.

def diff_consecutivenums(nums): result = [b-a for a, b in zip(nums[:-1], nums[1:])] return result

Write a function to remove similar rows from the given tuple matrix.

def remove_similar_row(test_list): res = set(sorted([tuple(sorted(set(sub))) for sub in test_list])) return (res)

Write a function to replace characters in a string.

def replace_char(str1,ch,newch): str2 = str1.replace(ch, newch) return str2

Write a python function to count the total unset bits from 1 to n.

def count_Unset_Bits(n) : cnt = 0; for i in range(1,n + 1) : temp = i; while (temp) : if (temp % 2 == 0) : cnt += 1; temp = temp // 2; return cnt;

Write a function to find the maximum total path sum in the given triangle.

def max_path_sum(tri, m, n): for i in range(m-1, -1, -1): for j in range(i+1): if (tri[i+1][j] > tri[i+1][j+1]): tri[i][j] += tri[i+1][j] else: tri[i][j] += tri[i+1][j+1] return tri[0][0]

Write a python function to find the missing number in a sorted array.

def find_missing(ar,N): l = 0 r = N - 1 while (l <= r): mid = (l + r) / 2 mid= int (mid) if (ar[mid] != mid + 1 and ar[mid - 1] == mid): return (mid + 1) elif (ar[mid] != mid + 1): r = mid - 1 else: l = mid + 1 return (-1)

Write a python function to find the average of even numbers till a given even number.

def average_Even(n) : if (n% 2!= 0) : return ("Invalid Input") return -1 sm = 0 count = 0 while (n>= 2) : count = count+1 sm = sm+n n = n-2 return sm // count

Write a python function to find the sum of fourth power of first n even natural numbers.

def even_Power_Sum(n): sum = 0; for i in range(1,n + 1): j = 2*i; sum = sum + (j*j*j*j); return sum;

Write a function to find the directrix of a parabola.

def parabola_directrix(a, b, c): directrix=((int)(c - ((b * b) + 1) * 4 * a )) return directrix

Write a python function to check whether the given strings are rotations of each other or not.

def are_Rotations(string1,string2): size1 = len(string1) size2 = len(string2) temp = '' if size1 != size2: return False temp = string1 + string1 if (temp.count(string2)> 0): return True else: return False

Write a function to remove lowercase substrings from a given string.

import re def remove_lowercase(str1): remove_lower = lambda text: re.sub('[a-z]', '', text) result = remove_lower(str1) return result

Write a function to find the focus of a parabola.

def parabola_focus(a, b, c): focus= (((-b / (2 * a)),(((4 * a * c) - (b * b) + 1) / (4 * a)))) return focus

Write a function to find the product of it’s kth index in the given tuples.

def get_product(val) : res = 1 for ele in val: res *= ele return res def find_k_product(test_list, K): res = get_product([sub[K] for sub in test_list]) return (res)

Write a python function to find the maximum element in a sorted and rotated array.

def find_Max(arr,low,high): if (high < low): return arr[0] if (high == low): return arr[low] mid = low + (high - low) // 2 if (mid < high and arr[mid + 1] < arr[mid]): return arr[mid] if (mid > low and arr[mid] < arr[mid - 1]): return arr[mid - 1] if (arr[low] > arr[mid]): return find_Max(arr,low,mid - 1) else: return find_Max(arr,mid + 1,high)

[link text](https:// [link text](https:// [link text](https://)))write a function to convert a string to a list.

def string_to_list(string): lst = list(string.split(" ")) return lst

Write a function to zip the two given tuples.

def zip_tuples(test_tup1, test_tup2): res = [] for i, j in enumerate(test_tup1): res.append((j, test_tup2[i % len(test_tup2)])) return (res)

Write a function to split a string at uppercase letters.

import re def split_upperstring(text): return (re.findall('[A-Z][^A-Z]*', text))

Write a function to replace whitespaces with an underscore and vice versa in a given string by using regex.

import re text = 'Python Exercises' def replace_spaces(text): text =text.replace (" ", "_") return (text) text =text.replace ("_", " ") return (text)

Write a function to search an element in the given array by using sequential search.

def sequential_search(dlist, item): pos = 0 found = False while pos < len(dlist) and not found: if dlist[pos] == item: found = True else: pos = pos + 1 return found, pos

Write a function to multiply two lists using map and lambda function.

def mul_list(nums1,nums2): result = map(lambda x, y: x * y, nums1, nums2) return list(result)

Write a function to find the combinations of sums with tuples in the given tuple list.

from itertools import combinations def find_combinations(test_list): res = [(b1 + a1, b2 + a2) for (a1, a2), (b1, b2) in combinations(test_list, 2)] return (res)

Write a function to calculate the difference between the squared sum of first n natural numbers and the sum of squared first n natural numbers.

def sum_difference(n): sumofsquares = 0 squareofsum = 0 for num in range(1, n+1): sumofsquares += num * num squareofsum += num squareofsum = squareofsum ** 2 return squareofsum - sumofsquares

Write a function to extract specified number of elements from a given list, which follow each other continuously.

from itertools import groupby def extract_elements(numbers, n): result = [i for i, j in groupby(numbers) if len(list(j)) == n] return result

Write a function to match two words from a list of words starting with letter 'p'.

import re def start_withp(words): for w in words: m = re.match("(P\w+)\W(P\w+)", w) if m: return m.groups()

Write a python function to minimize the length of the string by removing occurrence of only one character.

def minimum_Length(s) : maxOcc = 0 n = len(s) arr = [0]*26 for i in range(n) : arr[ord(s[i]) -ord('a')] += 1 for i in range(26) : if arr[i] > maxOcc : maxOcc = arr[i] return n - maxOcc

Write a function to find the nth decagonal number.

def is_num_decagonal(n): return 4 * n * n - 3 * n

Write a function to check whether the given number is undulating or not.

def is_undulating(n): if (len(n) <= 2): return False for i in range(2, len(n)): if (n[i - 2] != n[i]): return False return True

Write a function to find the element count that occurs before the record in the given tuple.

def count_first_elements(test_tup): for count, ele in enumerate(test_tup): if isinstance(ele, tuple): break return (count)

Write a python function to find element at a given index after number of rotations.

def find_Element(arr,ranges,rotations,index) : for i in range(rotations - 1,-1,-1 ) : left = ranges[i][0] right = ranges[i][1] if (left <= index and right >= index) : if (index == left) : index = right else : index = index - 1 return arr[index]

Write a function to find the maximum sum we can make by dividing number in three parts recursively and summing them up together for the given number.

MAX = 1000000 def breakSum(n): dp = [0]*(n+1) dp[0] = 0 dp[1] = 1 for i in range(2, n+1): dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i); return dp[n]

Write a function to check that the given string contains only a certain set of characters(in this case a-z, a-z and 0-9) by using regex.

import re def is_allowed_specific_char(string): get_char = re.compile(r'[^a-zA-Z0-9.]') string = get_char.search(string) return not bool(string)

Write a function to find common first element in given list of tuple.

def group_tuples(Input): out = {} for elem in Input: try: out[elem[0]].extend(elem[1:]) except KeyError: out[elem[0]] = list(elem) return [tuple(values) for values in out.values()]

Write a function to find the ration of negative numbers in an array of integers.

from array import array def negative_count(nums): n = len(nums) n1 = 0 for x in nums: if x < 0: n1 += 1 else: None return round(n1/n,2)

Write a function to find numbers within a given range where every number is divisible by every digit it contains.

def divisible_by_digits(startnum, endnum): return [n for n in range(startnum, endnum+1) \ if not any(map(lambda x: int(x) == 0 or n%int(x) != 0, str(n)))]

Write a function to find whether all the given tuples have equal length or not.

def find_equal_tuple(Input, k): flag = 1 for tuple in Input: if len(tuple) != k: flag = 0 break return flag def get_equal(Input, k): if find_equal_tuple(Input, k) == 1: return ("All tuples have same length") else: return ("All tuples do not have same length")

Write a python function to find the maximum difference between any two elements in a given array.

def max_Abs_Diff(arr,n): minEle = arr[0] maxEle = arr[0] for i in range(1, n): minEle = min(minEle,arr[i]) maxEle = max(maxEle,arr[i]) return (maxEle - minEle)

Write a python function to find the sum of squares of first n odd natural numbers.

def square_Sum(n): return int(n*(4*n*n-1)/3)

Write a function to extract maximum and minimum k elements in the given tuple.

def extract_min_max(test_tup, K): res = [] test_tup = list(test_tup) temp = sorted(test_tup) for idx, val in enumerate(temp): if idx < K or idx >= len(temp) - K: res.append(val) res = tuple(res) return (res)

Write a python function to check whether the given array is monotonic or not.

def is_Monotonic(A): return (all(A[i] <= A[i + 1] for i in range(len(A) - 1)) or all(A[i] >= A[i + 1] for i in range(len(A) - 1)))

Write a function to remove words from a given list of strings containing a character or string.

def remove_words(list1, charlist): new_list = [] for line in list1: new_words = ' '.join([word for word in line.split() if not any([phrase in word for phrase in charlist])]) new_list.append(new_words) return new_list

Write a function to find the maximum profit earned from a maximum of k stock transactions

def max_profit(price, k): n = len(price) final_profit = [[None for x in range(n)] for y in range(k + 1)] for i in range(k + 1): for j in range(n): if i == 0 or j == 0: final_profit[i][j] = 0 else: max_so_far = 0 for x in range(j): curr_price = price[j] - price[x] + final_profit[i-1][x] if max_so_far < curr_price: max_so_far = curr_price final_profit[i][j] = max(final_profit[i][j-1], max_so_far) return final_profit[k][n-1]

Write a python function to check whether all the bits are unset in the given range or not.

def all_Bits_Set_In_The_Given_Range(n,l,r): num = (((1 << r) - 1) ^ ((1 << (l - 1)) - 1)) new_num = n & num if (new_num == 0): return True return False

Write a python function to find the smallest missing number from the given array.

def find_First_Missing(array,start,end): if (start > end): return end + 1 if (start != array[start]): return start; mid = int((start + end) / 2) if (array[mid] == mid): return find_First_Missing(array,mid+1,end) return find_First_Missing(array,start,mid)

Write a python function to find sum of products of all possible subarrays.

def sum_Of_Subarray_Prod(arr,n): ans = 0 res = 0 i = n - 1 while (i >= 0): incr = arr[i]*(1 + res) ans += incr res = incr i -= 1 return (ans)

Write a function that matches a word containing 'z'.

import re def text_match_wordz(text): patterns = '\w*z.\w*' if re.search(patterns, text): return 'Found a match!' else: return('Not matched!')

Write a function to find the smallest integers from a given list of numbers using heap queue algorithm.

import heapq as hq def heap_queue_smallest(nums,n): smallest_nums = hq.nsmallest(n, nums) return smallest_nums

Write a function to find the division of first even and odd number of a given list.

def div_even_odd(list1): first_even = next((el for el in list1 if el%2==0),-1) first_odd = next((el for el in list1 if el%2!=0),-1) return (first_even/first_odd)

Write a function to find the lateral surface area of a cone.

import math def lateralsurface_cone(r,h): l = math.sqrt(r * r + h * h) LSA = math.pi * r * l return LSA

Write a python function to convert the given string to upper case.

def is_upper(string): return (string.upper())

Write a function to extract values between quotation marks of a string.

import re def extract_values(text): return (re.findall(r'"(.*?)"', text))

Write a function to convert camel case string to snake case string by using regex.

import re def camel_to_snake(text): str1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text) return re.sub('([a-z0-9])([A-Z])', r'\1_\2', str1).lower()