Python implementation of 30-seconds-of-code.
Note:- This is in no way affiliated with the original 30-seconds-of-code.
View contents
View contents
ℹ️ Already implemented via statistics.mean
. statistics.mean
takes an array as an argument whereas this function takes variadic arguments.
Returns the average of two or more numbers.
Takes the sum of all the args
and divides it by len(args)
. The secind argument 0.0
in sum is to handle floating point division in python2
.
def average(*args):
return sum(args, 0.0) / len(args)
View Examples
average(*[1, 2, 3]) # 2.0
average(1, 2, 3) # 2.0
Calculates the factorial of a number.
Use recursion. If num
is less than or equal to 1
, return 1
. Otherwise, return the product of num
and the factorial of num - 1
. Throws an exception if num
is a negative or a floating point number.
def factorial(num):
if not ((num >= 0) & (num % 1 == 0)):
raise Exception(
f"Number( {num} ) can't be floating point or negative ")
return 1 if num == 0 else num * factorial(num - 1)
View Examples
factorial(6) # 720
ℹ️ math.gcd
works with only two numbers
Calculates the greatest common divisor between two or more numbers/lists.
The helperGcdfunction
uses recursion. Base case is when y
equals 0
. In this case, return x
. Otherwise, return the GCD of y
and the remainder of the division x/y
.
Uses the reduce function from the inbuilt module functools
. Also defines a method spread
for javascript like spreading of lists.
from functools import reduce
def spread(arg):
ret = []
for i in arg:
if isinstance(i, list):
ret.extend(i)
else:
ret.append(i)
return ret
def gcd(*args):
numbers = []
numbers.extend(spread(list(args)))
def _gcd(x, y):
return x if not y else gcd(y, x % y)
return reduce((lambda x, y: _gcd(x, y)), numbers)
View Examples
gcd(8,36) # 4
Returns the least common multiple of two or more numbers.
Use the greatest common divisor (GCD)
formula and the fact that lcm(x,y) = x * y / gcd(x,y)
to determine the least common multiple. The GCD formula uses recursion.
Uses reduce
function from the inbuilt module functools
. Also defines a method spread
for javascript like spreading of lists.
from functools import reduce
def spread(arg):
ret = []
for i in arg:
if isinstance(i, list):
ret.extend(i)
else:
ret.append(i)
return ret
def lcm(*args):
numbers = []
numbers.extend(spread(list(args)))
def _gcd(x, y):
return x if not y else gcd(y, x % y)
def _lcm(x, y):
return x * y / _gcd(x, y)
return reduce((lambda x, y: _lcm(x, y)), numbers)
View Examples
lcm(12, 7) # 84
lcm([1, 3, 4], 5) # 60
Returns the n
maximum elements from the provided list. If n
is greater than or equal to the provided list's length, then return the original list(sorted in descending order).
Use list.sort()
combined with the deepcopy
function from the inbuilt copy
module to create a shallow clone of the list and sort it in ascending order and then use list.reverse()
reverse it to make it descending order. Use [:n]
to get the specified number of elements. Omit the second argument, n
, to get a one-element array
from copy import deepcopy
def max_n(arr, n=1):
numbers = deepcopy(arr)
numbers.sort()
numbers.reverse()
return numbers[:n]
View Examples
max_n([1, 2, 3]) # [3]
max_n([1, 2, 3], 2) # [3,2]
Returns the n
minimum elements from the provided list. If n
is greater than or equal to the provided list's length, then return the original list(sorted in ascending order).
Use list.sort()
combined with the deepcopy
function from the inbuilt copy
module to create a shallow clone of the list and sort it in ascending order. Use [:n]
to get the specified number of elements. Omit the second argument, n
, to get a one-element array
from copy import deepcopy
def min_n(arr, n=1):
numbers = deepcopy(arr)
numbers.sort()
return numbers[:n]
View Examples
min_n([1, 2, 3]) # [1]
min_n([1, 2, 3], 2) # [1,2]
Chunks an array into smaller lists of a specified size.
Uses range
to create a list of desired size. Then use map
on this list and fill it with splices of arr
.
from math import ceil
def chunk(arr, size):
return list(
map(lambda x: arr[x * size:x * size + size],
list(range(0, ceil(len(arr) / size)))))
View Examples
chunk([1,2,3,4,5],2) # [[1,2],[3,4],5]
Removes falsey values from a list.
Use filter()
to filter out falsey values (False, None, 0, and "").
def compact(arr):
return list(filter(lambda x: bool(x), arr))
View Examples
compact([0, 1, False, 2, '', 3, 'a', 's', 34]) # [ 1, 2, 3, 'a', 's', 34 ]
ℹ️ Already implemented via collections.Counter
Groups the elements of a list based on the given function and returns the count of elements in each group.
Use map()
to map the values of the list using the given function. Iterate over the map and increase the the elements count each time it occurs.
def count_by(arr, fn=lambda x: x):
key = {}
for el in map(fn, arr):
key[el] = 0 if not el in key else key[el]
key[el] += 1
return key
View Examples
from math import floor
count_by([6.1, 4.2, 6.3], floor) # {4: 1, 6: 2}
count_by(['one', 'two', 'three'], len) # {3: 2, 5: 1}
ℹ️ Already implemented via list.count()
.
Counts the occurrences of a value in an list.
Uses the reduce
functin from built-in module functools
to increment a counter each time you encounter the specific value inside the list.
def count_occurences(arr, val):
return reduce(
(lambda x, y: x + 1 if y == val and type(y) == type(val) else x + 0),
arr)
View Examples
count_occurrences([1, 1, 2, 1, 2, 3], 1) # 3
Deep flattens a list.
Use recursion. Use list.extend()
with an empty array (result
) and the spread function to flatten a list. Recursively flatten each element that is a list.
def spread(arg):
ret = []
for i in arg:
if isinstance(i, list):
ret.extend(i)
else:
ret.append(i)
return ret
def deep_flatten(arr):
result = []
result.extend(
spread(list(map(lambda x: deep(x) if type(x) == list else x, arr))))
return result
View Examples
deep_flatten([1, [2], [[3], 4], 5]) # [1,2,3,4,5]
Returns the difference between two arrays.
Create a set
from b
, then use list comprehension to only keep values not contained in b
def difference(a, b):
b = set(b)
return [item for item in a if item not in b]
View Examples
difference([1, 2, 3], [1, 2, 4]) # [3]
Returns the difference between two list, after applying the provided function to each list element of both.
Create a set
by applying fn
to each element in b
, then use list comprehension in combination with fn on a to only keep values not contained in the previously created set
.
def difference_by(a, b, fn):
b = set(map(fn, b))
return [item for item in a if fn(item) not in b]
View Examples
from math import floor
difference_by([2.1, 1.2], [2.3, 3.4],floor) # [1.2]
difference_by([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], lambda v : v['x']) # [ { x: 2 } ]
On a very basic level, an insertion sort algorithm contains the logic of shifting around and inserting elements in order to sort an unordered list of any size. The way that it goes about inserting elements, however, is what makes insertion sort so very interesting!
def insertionsort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key
View Examples
arr = [7,4,9,2,6,3]
insertionsort(arr)
print('Sorted %s' %arr) # sorted [2, 3, 4, 6, 7, 9]
ℹ️ The same algorithm is already implemented via random.shuffle
.
Randomizes the order of the values of an list, returning a new list.
Uses the Fisher-Yates algorithm to reorder the elements of the list.
from copy import deepcopy
from random import randint
def shuffle(arr):
temp_arr = deepcopy(arr)
m = len(temp_arr)
while (m):
m -= 1
i = randint(0, m)
temp_arr[m], temp_arr[i] = temp_arr[i], temp_arr[m]
return temp_arr
View Examples
foo = [1,2,3]
shuffle(foo) # [2,3,1] , foo = [1,2,3]
Implements javascript's [].concat(...arr)
. Flattens the list(non-deep) and returns an list.
def spread(arg):
ret = []
for i in arg:
if isinstance(i, list):
ret.extend(i)
else:
ret.append(i)
return ret
View Examples
spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]
ℹ️ Already implemented via itertools.zip_longest()
Creates a list of elements, grouped based on the position in the original lists.
Use max
combined with list comprehension
to get the length of the longest list in the arguments. Loops for max_length
times grouping elements. If lengths of lists
vary fill_value
is used. By default fill_value
is None
.
def zip(*args, fillvalue=None):
max_length = max([len(arr) for arr in args])
result = []
for i in range(max_length):
result.append([
args[k][i] if i < len(args[k]) else None for k in range(len(args))
])
return result
View Examples
zip(['a', 'b'], [1, 2], [True, False]) # [['a', 1, True], ['b', 2, False]]
zip(['a'], [1, 2], [True, False]) # [['a', 1, True], [None, 2, False]]
zip(['a'], [1, 2], [True, False], fill_value = '_') # [['a', 1, True], ['_', 2, False]]
Returns the length of a string in bytes.
utf-8
encodes a given string and find its length.
def byte_size(string):
return(len(string.encode('utf-8')))
View Examples
byte_size('😀') # 4
byte_size('Hello World') # 11
Capitalizes the first letter of a string.
Capitalizes the fist letter of the sring and then adds it with rest of the string. Omit the lower_rest
parameter to keep the rest of the string intact, or set it to true
to convert to lowercase.
def capitalize(string, lower_rest=False):
return string[:1].upper() + (string[1:].lower() if lower_rest else string[1:])
View Examples
capitalize('fooBar') # 'FooBar'
capitalize('fooBar', True) # 'Foobar'
Capitalizes the first letter of every word in a string.
Uses str.title
to capitalize first letter of evry word in the string.
def capitalize_every_word(string):
return string.title()
View Examples
capitalize_every_word('hello world!') # 'Hello World!'
Retuns number
of vowels in provided string
.
Use a regular expression to count the number of vowels (A, E, I, O, U)
in a string.
import re
def count_vowels(str):
return len(len(re.findall(r'[aeiou]', str, re.IGNORECASE)))
View Examples
count_vowels('foobar') # 3
count_vowels('gym') # 0
Decapitalizes the first letter of a string.
Decapitalizes the fist letter of the sring and then adds it with rest of the string. Omit the upper_rest
parameter to keep the rest of the string intact, or set it to true
to convert to uppercase.
def decapitalize(string, upper_rest=False):
return str[:1].lower() + (str[1:].upper() if upper_rest else str[1:])
View Examples
decapitalize('FooBar') # 'fooBar'
decapitalize('FooBar', True) # 'fOOBAR'
Checks if a string is lower case.
Convert the given string to lower case, using str.lower()
method and compare it to the original.
def is_lower_case(str):
return str == str.lower()
View Examples
is_lower_case('abc') # True
is_lower_case('a3@$') # True
is_lower_case('Ab4') # False
Checks if a string is upper case.
Convert the given string to upper case, using str.upper()
method and compare it to the original.
def is_upper_case(str):
return str == str.upper()
View Examples
is_upper_case('ABC') # True
is_upper_case('a3@$') # True
is_upper_case('aB4') # False
Returns True
if the given string is a palindrome, False
otherwise.
Convert string str.lower()
and use re.sub
to remove non-alphanumeric characters from it. Then compare the new string to the reversed.
def palindrome(string):
from re import sub
s = sub('[\W_]', '', string.lower())
return s == s[::-1]
View Examples
palindrome('taco cat') # True
Icons made by Smashicons from www.flaticon.com is licensed by CC 3.0 BY.