30-seconds-of-python-code

Python implementation of 30-seconds-of-code.

Note:- This is in no way affiliated with the original 30-seconds-of-code.

chunk

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)))))

chunk([1,2,3,4,5],2) # [[1,2],[3,4],5]

compact

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))

compact([0, 1, False, 2, '', 3, 'a', 's', 34]); // [ 1, 2, 3, 'a', 's', 34 ]

count_occurences

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)

count_occurrences([1, 1, 2, 1, 2, 3], 1) # 3

count_vowels

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)))

count_vowels('foobar') # 3
count_vowels('gym') # 0

deep_flatten

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

deep_flatten([1, [2], [[3], 4], 5]) # [1,2,3,4,5]

difference

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]

difference([1, 2, 3], [1, 2, 4]) # [3]

gcd

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)

gcd(8,36) # 4

lcm

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)

lcm(12, 7) # 84
lcm([1, 3, 4], 5) # 60

max_n

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]

max_n([1, 2, 3]) # [3]
max_n([1, 2, 3], 2) # [3,2]

min_n

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]

min_n([1, 2, 3]) # [1]
min_n([1, 2, 3], 2) # [1,2]

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

foo = [1,2,3]
shuffle(foo) # [2,3,1] , foo = [1,2,3]

spread

Implements javascript's spread syntax as a function. 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

spread([1,2,3,[4,5,6],[7],8,9]) # [1,2,3,4,5,6,7,8,9]

Credits

Icons made by Smashicons from www.flaticon.com is licensed by CC 3.0 BY.