text
stringlengths 41
125
| code
stringlengths 30
189
|
|---|---|
Write a python function to find the first repeated character in a given string.
|
def first_repeated_char(str1):
for index,c in enumerate(str1):
if str1[:index+1].count(c) > 1:
return c
return "None"
|
Write a function to reverse words in a given string.
|
def reverse_words(s):
return ' '.join(reversed(s.split()))
|
Write a function to convert degrees to radians.
|
import math
def radian_degree(degree):
radian = degree*(math.pi/180)
return radian
|
Write a python function to find minimum possible value for the given periodic function.
|
def floor_Min(A,B,N):
x = max(B - 1,N)
return (A*x) // B
|
Write a python function to remove the k'th element from a given list.
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
Write a function to find the maximum of nth column from the given tuple list.
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
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 maximum value in record list as tuple attribute in the given tuple list.
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return (res)
|
Write a function to find the cumulative sum of all the values that are present in the given tuple list.
|
def cummulative_sum(test_list):
res = sum(map(sum, test_list))
return (res)
|
Write a function to find average value of the numbers in a given tuple of tuples.
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
Write a function to perfom the modulo of tuple elements in the given two tuples.
|
def tuple_modulo(test_tup1, test_tup2):
res = tuple(ele1 % ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
Write a function to divide two lists using map and lambda function.
|
def div_list(nums1,nums2):
result = map(lambda x, y: x / y, nums1, nums2)
return list(result)
|
Write a function to move all the numbers in it to the given string.
|
def move_num(test_str):
res = ''
dig = ''
for ele in test_str:
if ele.isdigit():
dig += ele
else:
res += ele
res += dig
return (res)
|
Write a function to increment the numeric values in the given strings by k.
|
def increment_numerics(test_list, K):
res = [str(int(ele) + K) if ele.isdigit() else ele for ele in test_list]
return res
|
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 python function to convert the given string to upper case.
|
def is_upper(string):
return (string.upper())
|
Write a python function to interchange first and last elements in a given list.
|
def swap_List(newList):
size = len(newList)
temp = newList[0]
newList[0] = newList[size - 1]
newList[size - 1] = temp
return newList
|
Write a python function to find the largest triangle that can be inscribed in the semicircle.
|
def triangle_area(r) :
if r < 0 :
return -1
return r * r
|
Write a python function to find even numbers from a mixed list.
|
def Split(list):
ev_li = []
for i in list:
if (i % 2 == 0):
ev_li.append(i)
return ev_li
|
Write a python function to move all zeroes to the end of the given list.
|
def move_zero(num_list):
a = [0 for i in range(num_list.count(0))]
x = [ i for i in num_list if i != 0]
x.extend(a)
return (x)
|
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 python function to check if roots of a quadratic equation are reciprocal of each other or not.
|
def Check_Solution(a,b,c):
if (a == c):
return ("Yes");
else:
return ("No");
|
Write a function to check whether the given amount has no profit and no loss
|
def noprofit_noloss(actual_cost,sale_amount):
if(sale_amount == actual_cost):
return True
else:
return False
|
Write a function to calculate wind chill index.
|
import math
def wind_chill(v,t):
windchill = 13.12 + 0.6215*t - 11.37*math.pow(v, 0.16) + 0.3965*t*math.pow(v, 0.16)
return int(round(windchill, 0))
|
Write a function to remove the parenthesis area in a string.
|
import re
def remove_parenthesis(items):
for item in items:
return (re.sub(r" ?\([^)]+\)", "", item))
|
Write a function to find the nth nonagonal number.
|
def is_nonagonal(n):
return int(n * (7 * n - 5) / 2)
|
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 python function to reverse an array upto a given position.
|
def reverse_Array_Upto_K(input, k):
return (input[k-1::-1] + input[k:])
|
Write a python function to count number of cubes of size k in a cube of size n.
|
def No_of_cubes(N,K):
No = 0
No = (N - K + 1)
No = pow(No, 3)
return No
|
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 check if one tuple is a subset of another tuple.
|
def check_subset(test_tup1, test_tup2):
res = set(test_tup2).issubset(test_tup1)
return (res)
|
Write a function to flatten the given tuple matrix into the tuple list with each tuple representing each column.
|
def matrix_to_list(test_list):
temp = [ele for sub in test_list for ele in sub]
res = list(zip(*temp))
return (str(res))
|
Write a function to find the perimeter of a rectangle.
|
def rectangle_perimeter(l,b):
perimeter=2*(l+b)
return perimeter
|
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 python function to find the minimum sum of absolute differences of two arrays.
|
def find_Min_Sum(a,b,n):
a.sort()
b.sort()
sum = 0
for i in range(n):
sum = sum + abs(a[i] - b[i])
return sum
|
Write a python function to choose points from two ranges such that no point lies in both the ranges.
|
def find_Points(l1,r1,l2,r2):
x = min(l1,l2) if (l1 != l2) else -1
y = max(r1,r2) if (r1 != r2) else -1
return (x,y)
|
Write a function to sort a list in a dictionary.
|
def sorted_dict(dict1):
sorted_dict = {x: sorted(y) for x, y in dict1.items()}
return sorted_dict
|
Write a python function to shift first element to the end of given list.
|
def move_last(num_list):
a = [num_list[0] for i in range(num_list.count(num_list[0]))]
x = [ i for i in num_list if i != num_list[0]]
x.extend(a)
return (x)
|
Write a function to count occurrence of a character in a string.
|
def count_char(string,char):
count = 0
for i in range(len(string)):
if(string[i] == char):
count = count + 1
return count
|
Write a python function to count number of vowels in the string.
|
def Check_Vow(string, vowels):
final = [each for each in string if each in vowels]
return(len(final))
|
Write a python function to replace multiple occurence of character by single.
|
import re
def replace(string, char):
pattern = char + '{2,}'
string = re.sub(pattern, char, string)
return string
|
Write a python function to check whether a sequence of numbers has a decreasing trend or not.
|
def decreasing_trend(nums):
if (sorted(nums)== nums):
return True
else:
return False
|
Write a python function to convert a list of multiple integers into a single integer.
|
def convert(list):
s = [str(i) for i in list]
res = int("".join(s))
return (res)
|
Write a function to remove duplicate words from a given string using collections module.
|
from collections import OrderedDict
def remove_duplicate(string):
result = ' '.join(OrderedDict((w,w) for w in string.split()).keys())
return result
|
Write a function to add two integers. however, if the sum is between the given range it will return 20.
|
def sum_nums(x, y,m,n):
sum_nums= x + y
if sum_nums in range(m, n):
return 20
else:
return sum_nums
|
Write a function to remove everything except alphanumeric characters from the given string by using regex.
|
import re
def remove_extra_char(text1):
pattern = re.compile('[\W_]+')
return (pattern.sub('', text1))
|
Write a function to check if the triangle is valid or not.
|
def validity_triangle(a,b,c):
total = a + b + c
if total == 180:
return True
else:
return False
|
Write a python function to remove spaces from a given string.
|
def remove_spaces(str1):
str1 = str1.replace(' ','')
return str1
|
Write a function to access dictionary key’s element by index.
|
def access_key(ditionary,key):
return list(ditionary)[key]
|
Write a python function to check whether a sequence of numbers has an increasing trend or not.
|
def increasing_trend(nums):
if (sorted(nums)== nums):
return True
else:
return False
|
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 frequency of each element in the given list.
|
from collections import defaultdict
def freq_element(test_tup):
res = defaultdict(int)
for ele in test_tup:
res[ele] += 1
return (str(dict(res)))
|
Write a function to get the length of a complex number.
|
import cmath
def len_complex(a,b):
cn=complex(a,b)
length=abs(cn)
return length
|
Write a function to multiply consecutive numbers of a given list.
|
def mul_consecutive_nums(nums):
result = [b*a for a, b in zip(nums[:-1], nums[1:])]
return result
|
Write a python function to find the last two digits in factorial of a given number.
|
def last_Two_Digits(N):
if (N >= 10):
return
fac = 1
for i in range(1,N + 1):
fac = (fac * i) % 100
return (fac)
|
Write a function to remove multiple spaces in a string by using regex.
|
import re
def remove_multiple_spaces(text1):
return (re.sub(' +',' ',text1))
|
Write a function to extract unique values from the given dictionary values.
|
def extract_unique(test_dict):
res = list(sorted({ele for val in test_dict.values() for ele in val}))
return res
|
Write a function to check if each element of the second tuple is greater than its corresponding index in the first tuple.
|
def check_greater(test_tup1, test_tup2):
res = all(x < y for x, y in zip(test_tup1, test_tup2))
return (res)
|
Write a function to zip two given lists of lists.
|
def zip_list(list1,list2):
result = list(map(list.__add__, list1, list2))
return result
|
Write a function to find number of even elements in the given list using lambda function.
|
def count_even(array_nums):
count_even = len(list(filter(lambda x: (x%2 == 0) , array_nums)))
return count_even
|
Write a function to count the number of elements in a list which are within a specific range.
|
def count_range_in_list(li, min, max):
ctr = 0
for x in li:
if min <= x <= max:
ctr += 1
return ctr
|
Write a function to check whether the given key is present in the dictionary or not.
|
def is_key_present(d,x):
if x in d:
return True
else:
return False
|
Write a function to calculate the harmonic sum of n-1.
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
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 python function to convert a string to a list.
|
def Convert(string):
li = list(string.split(" "))
return li
|
Write a function to access the initial and last data of the given tuple record.
|
def front_and_rear(test_tup):
res = (test_tup[0], test_tup[-1])
return (res)
|
Write a function to remove duplicates from a list of lists.
|
import itertools
def remove_duplicate(list1):
list.sort(list1)
remove_duplicate = list(list1 for list1,_ in itertools.groupby(list1))
return remove_duplicate
|
Write a function to check if the given tuple contains all valid values or not.
|
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return (res)
|
Write a function to convert the given string of integers into a tuple.
|
def str_to_tuple(test_str):
res = tuple(map(int, test_str.split(', ')))
return (res)
|
Write a function to find the perimeter of a rombus.
|
def rombus_perimeter(a):
perimeter=4*a
return perimeter
|
Write a function to create a list taking alternate elements from another given list.
|
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result
|
Write a function to add a dictionary to the tuple.
|
def add_dict_to_tuple(test_tup, test_dict):
test_tup = list(test_tup)
test_tup.append(test_dict)
test_tup = tuple(test_tup)
return (test_tup)
|
Write a function to filter the height and width of students which are stored in a dictionary.
|
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result
|
Write a function to count the same pair in two given lists using map function.
|
from operator import eq
def count_same_pair(nums1, nums2):
result = sum(map(eq, nums1, nums2))
return result
|
Write a function to calculate the sum of all digits of the base to the specified power.
|
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))])
|
Write a function to extract values between quotation marks of the given string by using regex.
|
import re
def extract_quotation(text1):
return (re.findall(r'"(.*?)"', text1))
|
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 function to remove all characters except letters and numbers using regex
|
import re
def remove_char(S):
result = re.sub('[\W_]+', '', S)
return result
|
Write a function to sum elements in two lists.
|
def sum_list(lst1,lst2):
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
return res_list
|
Write a function to add two lists using map and lambda function.
|
def add_list(nums1,nums2):
result = map(lambda x, y: x + y, nums1, nums2)
return list(result)
|
Write a function to remove consecutive duplicates of a given list.
|
from itertools import groupby
def consecutive_duplicates(nums):
return [key for key, group in groupby(nums)]
|
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 function to replace all occurrences of spaces, commas, or dots with a colon.
|
import re
def replace_specialchar(text):
return (re.sub("[ ,.]", ":", text))
|
Write a function to locate the left insertion point for a specified value in sorted order.
|
import bisect
def left_insertion(a, x):
i = bisect.bisect_left(a, x)
return i
|
Write a function to calculate the geometric sum of n-1.
|
def geometric_sum(n):
if n < 0:
return 0
else:
return 1 / (pow(2, n)) + geometric_sum(n - 1)
|
Write a python function to find the index of smallest triangular number with n digits.
|
import math
def find_Index(n):
x = math.sqrt(2 * math.pow(10,(n - 1)));
return round(x);
|
Write a function to convert the given tuple to a key-value dictionary using adjacent elements.
|
def tuple_to_dict(test_tup):
res = dict(test_tup[idx : idx + 2] for idx in range(0, len(test_tup), 2))
return (res)
|
Write a python function to check whether all the characters are same or not.
|
def all_Characters_Same(s) :
n = len(s)
for i in range(1,n) :
if s[i] != s[0] :
return False
return True
|
Write a function to caluclate the area of a tetrahedron.
|
import math
def area_tetrahedron(side):
area = math.sqrt(3)*(side*side)
return area
|
Write a function to rotate a given list by specified number of items to the right direction.
|
def rotate_right(list1,m,n):
result = list1[-(m):]+list1[:-(n)]
return result
|
Write a function to check if the given tuple has any none value or not.
|
def check_none(test_tup):
res = any(map(lambda ele: ele is None, test_tup))
return (res)
|
Write a function to find area of a sector.
|
def sector_area(r,a):
pi=22/7
if a >= 360:
return None
sectorarea = (pi*r**2) * (a/360)
return sectorarea
|
Write a function to put spaces between words starting with capital letters in a given string by using regex.
|
import re
def capital_words_spaces(str1):
return re.sub(r"(\w)([A-Z])", r"\1 \2", str1)
|
Write a function to sort a given list of strings of numbers numerically.
|
def sort_numeric_strings(nums_str):
result = [int(x) for x in nums_str]
result.sort()
return result
|
Write a function to add the given tuple to the given list.
|
def add_tuple(test_list, test_tup):
test_list += test_tup
return (test_list)
|
Write a function to find the nth jacobsthal number.
|
def jacobsthal_num(n):
dp = [0] * (n + 1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = dp[i - 1] + 2 * dp[i - 2]
return dp[n]
|
Write a function to find minimum k records from tuple list.
|
def min_k(test_list, K):
res = sorted(test_list, key = lambda x: x[1])[:K]
return (res)
|
Write a function to find common index elements from three lists.
|
def extract_index_list(l1, l2, l3):
result = []
for m, n, o in zip(l1, l2, l3):
if (m == n == o):
result.append(m)
return result
|
Write a function to check a decimal with a precision of 2.
|
def is_decimal(num):
import re
dnumre = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = dnumre.search(num)
return bool(result)
|
Write a python function to check whether an array contains only one distinct element or not.
|
def unique_Element(arr,n):
s = set(arr)
if (len(s) == 1):
return ('YES')
else:
return ('NO')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.