import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def array_maximal_adjacent_difference(arr):
""" A function that returns the max difference between any of the elements in the array
Arguments:
arr { number[] } -- An array of numbers
Returns:
number -- The max difference between any of its adjacent element
"""
length = len(arr) - 1
diffs = [abs(arr[i] - arr[i + 1]) for i in range(length)]
return max(diffs)
run_tests(array_maximal_adjacent_difference)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def count_jewels( jewels_and_stones ):
""" A function that counts the number of jewels, given a list of jewel types and the available stones
Arguments:
jewels_and_stones { string[] } -- An array of strings. First string represents the list of jewels, and the second string represents stones available
Returns:
number -- the number of available jewels
"""
[J, S] = jewels_and_stones
return sum( s in J for s in S )
run_tests( count_jewels )
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def max_product(nums):
""" A function that given the array of integers nums,
returns the maximum value that can be obtain for multiplying two different elements in the array
Args:
nums ( number[] )
Returns:
number
"""
n1 = max(nums)
nums.pop(nums.index(n1))
n2 = max(nums)
return (n1 - 1) * (n2 - 1)
run_tests(max_product)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
import re
def determine_if_number(str):
""" A function that scans a string to determine if it represents a valid number, which could be integer,
negative, floating, scientific notation, etc
Arguments:
str { string } -- The string to scan
Returns:
boolean -- A boolean determining if the string represents a valid number
"""
return re.search("^-?\d*\.?\d+[e?\d+]?\d*$", str) is not None
run_tests(determine_if_number)
Args:
strings ( string[] ): An array with two strings to calculate its editing distance
Returns:
number: The editing distance of the two given arrays
"""
s1 = strings[0]
s2 = strings[1]
s1_length = len(s1) + 1
s2_length = len(s2) + 1
matrix = [[0] * s2_length for x in range(s1_length)]
for i in range(s1_length):
for j in range(s2_length):
if i == 0:
matrix[i][j] = j
elif j == 0:
matrix[i][j] = i
elif s1[i - 1] == s2[j - 1]:
matrix[i][j] = matrix[i - 1][j - 1]
else:
matrix[i][j] = 1 + min(matrix[i][j - 1], matrix[i - 1][j],
matrix[i - 1][j - 1])
return matrix[s1_length - 1][s2_length - 1]
run_tests(editing_distance)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
FIRST_ASCII = 96
def decryptString(s):
msg = ""
i = 0
while i < len(s):
if i + 2 < len(s) and s[i + 2] == '#':
encrypted = s[i:i + 2]
i += 3
else:
encrypted = s[i]
i += 1
asciiValue = int(encrypted) + FIRST_ASCII
msg += chr(asciiValue)
return msg
run_tests(decryptString)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def kid_with_max_candies(arr):
""" A function that for each kid check if there is a way to distribute extraCandies among
the kids such that he or she can have the greatest number of candies among them
Args:
arr ( number[] ): An array representing the candies each kid has, and the last element being the amount of extra candies
Returns:
bool[]: An array determining if each could have the max number of candies, given some extra candies
"""
extra_candies = arr.pop()
max_candies = max(arr)
return [candy + extra_candies >= max_candies for candy in arr]
run_tests(kid_with_max_candies)
Returns:
number -- The square root of the given number, rounded to three decimals
"""
x = number
y = 1
precision = 0.0001
while (get_relative_error(x, y) > precision):
x = (x + y) / 2
y = number / x
return round(x, 3)
def get_relative_error(x, y):
"""
A function that calculates the relative margin of error between two numbers
Arguments:
x { number } -- The first number to get the margin of error
y { number } -- The second number to get the margin of error
Returns:
number -- The margin or error between the two numbers
"""
return (x - y) / x
run_tests(square_root)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def binary_reverse(string):
""" A function that receives a stringified positive integer and returns its binary reversal integer representation
Arguments:
string { str } -- The string representing a positive integer
Returns:
[integer] -- The integer which correspond to the binary reversal of the input
"""
n = bin(int(string))[2:]
missing_zeroes = 8 - (len(n) % 8) if len(n) % 8 != 0 else 0
k = (('0' * missing_zeroes) + n)[::-1]
return int(k, 2)
run_tests(binary_reverse)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
brackets = ['()', '[]', '{}']
def balanced_brackets(input_string):
"""
A function that checks if the brackets of a given string are balanced, using string replacement for each match
Arguments:
input_string { string } -- The string to validate
Returns:
boolean -- True or false if the string has balanced brackets
"""
sanitized_input = ''.join(input_string.split())
while any(match in sanitized_input for match in brackets):
for bracket in brackets:
sanitized_input = sanitized_input.replace(bracket, '')
return not sanitized_input
run_tests(balanced_brackets)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def maximum_69_number(num):
""" A function that returns the maximum number you can get by changing at most one digit of a given number consisting of 6 and 9
Args:
num ( number ): A number consisting only of 6 and 9
Returns:
number: The highest number that can be made given the input, just by changing one digit
"""
adjusted = str(num).replace('6', '9', 1)
return int(adjusted)
run_tests(maximum_69_number)
from run_test import run_tests
def is_number_palindrome( num ):
""" A function that checks if an integer is also a palindrome, without parsing it to string
Args:
num ( number ): An integer
Returns:
boolean: True or false if the given integer is a palindrome
"""
digits = number_to_array( num )
return digits == digits[::-1]
def number_to_array( num ):
""" Helper function that parses an integer number into an array of numbers
Args:
num ( number ): An integer
Returns:
number[]: The given integer, parsed into a list of digits
"""
digits = []
while num != 0:
num, digit = divmod( num, 10 )
digits.append( digit )
return digits
run_tests( is_number_palindrome )
def letter_changes(str):
""" A function that shifts all the letters of a string to its next letter in the alphabet, and then uppercase all the vowels
Arguments:
str { string } -- The string to convert
Returns:
[ string ] -- The converted string
"""
return ''.join(map(shift_and_parse, str))
def shift_and_parse(char):
""" A helper function to shift and capitalize a letter
Arguments:
char { chr } -- The letter to be shifted and capitalized
Returns:
[ chr ] -- The shifted and capitalized letter
"""
if char in ascii_lowercase:
char = ascii_lowercase[0] if char == ascii_lowercase[-1] else chr(
ord(char) + 1)
return char.upper() if char in vowels else char
run_tests(letter_changes)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def first_factorial(n):
""" A recursive function that calculates the factorial of a given number
Arguments:
n { number } -- The given number to calculate its factorial
Returns:
[ number ] -- The product of the current number times the previous number. Defaulted to 1 when n equals zero
"""
return 1 if n == 0 else n * first_factorial(n - 1)
run_tests(first_factorial)
def find_intersection(str_array):
""" A function that scans two stringified arrays and returns a new string with all the matches between the two arrays
Arguments:
str_array { string[] } -- An array of strings with two elements. Each element is a stringified array of numbers
Returns:
[ string ] -- A string with all the matching elements that the two arrays share
"""
array_1 = parse_string_array(str_array[0])
array_2 = parse_string_array(str_array[1])
matches = set(array_1) & set(array_2)
sorted_matches = repr(sorted(matches))
return sorted_matches.replace(' ', '').replace('[', '').replace(
']', '') if matches else False
def parse_string_array(string_array):
""" A function that receives a stringified array of numbers, and parses it into a proper number array
Arguments:
string_array { string } -- A stringified array of numbers
Returns:
[ nubmer[] -- An array of numbers
"""
return map(int, string_array.split(', '))
run_tests(find_intersection)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def array_plus_one(arr):
""" A function that receives an array of integers. Each element in the array represent a digit in a larger number.
The function returns an array representing the number after adding one
Arguments:
arr { int[] } -- An array of numbers that represent a larger integer
Returns:
int[] -- An array of numbers that represent the given large number after adding one
"""
number = int(''.join(map(str, arr))) + 1
return [int(i) for i in str(number)]
run_tests(array_plus_one)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def reverse_string(str):
""" A function that receives a string and reverses it
Arguments:
str { string } -- The string to reverse
Returns:
[string ] -- The reversed string
"""
return str[::-1]
run_tests(reverse_string)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
import math
def product_minus_sum(n):
""" A function that scans each digit of a number then sums then and also multiplies them, and finally returns the substraction of both
Args:
n ( number ): The number to process
Returns:
number: The substraction of the product minus the sum
"""
p = 1
s = 0
while n > 0:
c = n % 10
p = p * c
s = s + c
n = math.floor(n / 10)
return p - s
run_tests(product_minus_sum)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def array_xor(params):
""" A function which given an integer n and an integer start,
defines an array nums where nums[i] = start + 2*i (0-indexed) and n == nums.length,
and then returns the bitwise XOR of all elements of nums.
Args:
params ( number[]): An array of two elements, First element is the length of the array and the second is the start
Returns:
number: The resulting value after the operation
"""
n = params[0]
start = params[1]
res = 0
for i in range(n):
res ^= start + 2 * i
return res
run_tests(array_xor)
""" A function that calculates the product of all the elements in the array except itself and returns it an a new array
Args:
arr ( number[] ): A list of integers
Returns:
number[]: A list of integers
"""
N = len(arr)
res = [1] * N
left = [1] * N
right = [1] * N
product_left = 1
product_right = 1
for i in range( 0, N ):
j = N - 1 - i
left[i] = product_left
right[j] = product_right
product_left *= arr[i]
product_right *= arr[j]
for i in range( 0, N ):
res[i] = left[i] * right[i]
return res
run_tests( product_of_array )
import sys sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python') from run_test import run_tests def my_function(): # Fill this.. return run_tests( my_function )
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def defang_address(address):
""" A function that receives an ip address and returns its defanged version
Args:
address ( string ): An ip address
Returns:
string: The defanged ip address
"""
return address.replace('.', '[.]')
run_tests(defang_address)
removes the outermost parentheses of every primitive string in the primitive decomposition of S.
Args:
S (string ): a valid parentheses string
Returns:
string: the string S the outermost parentheses of every primitive string
"""
result_string = ""
current_primitive_string = ""
current_primitive_stack = []
for char in S:
last_char = current_primitive_stack[
-1] if current_primitive_stack else char
current_primitive_stack.append(
char) if last_char == char else current_primitive_stack.pop()
if current_primitive_stack:
current_primitive_string += char
else:
result_string += current_primitive_string[1:]
current_primitive_string = ""
return result_string
run_tests(removeOuterParenthesis)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def minTimeToVisitAllPoints( points ):
""" A function that finds the minimum time in seconds to visit all points in a given array of coordinates
Args:
points ( number[] ): An array of points in a plain
Returns:
number: The amount of seconds needed to go from the first point to the last
"""
seconds = 0
for i in range(1, len(points), 1):
diffX = abs( points[i][0] - points[i-1][0])
diffY = abs( points[i][1] - points[i-1][1])
seconds += max( diffX, diffY)
return seconds
run_tests( minTimeToVisitAllPoints )
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def decompress_encoded_list(nums):
""" A function that decompressed a run-length encoded lists and returns it
Args:
nums ( number[] ): A list compressed with run-length encoding
Returns:
number[]: The list after being decompressed
"""
decompressed = []
for i in range(0, len(nums), 2):
freq = nums[i]
val = nums[i + 1]
decompressed.extend([val] * freq)
return decompressed
run_tests(decompress_encoded_list)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def transpose_matrix(matrix):
"""
A function that transposes a matrix.
Transposing a matrix means the rows are now the column and vice-versa.
Arguments:
matrix { list[] } -- A list of lists, representing a matrix
Returns:
list[] -- A list of lists, representing the transpose of the given matrix
"""
return [list(a) for a in zip(*matrix)]
run_tests(transpose_matrix)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
from string import ascii_lowercase
def is_beautiful_string(input_string):
"""
Determine if a given string is beautiful
Arguments:
input_string {string} -- A string to analyze if its beautiful or not
Returns:
boolean -- Indicating if the string is beautiful or not
"""
for i, char in enumerate(ascii_lowercase[1:], 1):
if input_string.count(char) > input_string.count(
ascii_lowercase[i - 1]):
return False
return True
run_tests(is_beautiful_string)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def maximum_balanced_strings(s):
count = 0
maximum_strings = 0
for char in s:
count += 1 if char == 'L' else -1
if count == 0:
maximum_strings += 1
return maximum_strings
run_tests(maximum_balanced_strings)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
import itertools
def running_sum(numbers):
""" A function that given an array, returns the sum of each element until i
Args:
numbers ( number[] ): An array of integers
Returns:
number[]: An array of integers with the running sum of the given array
"""
return list(itertools.accumulate(numbers))
run_tests(running_sum)
import sys
sys.path.insert(1, sys.path[0] + '/../../../RunTests/Python')
from run_test import run_tests
def find_single(numbers):
""" A function that scans an array of numbers with duplicated items to find the one item without a duplicate value
Arguments:
numbers { num[]} -- An array of numbers
Returns:
num -- A number from the array that has no duplicate
"""
return [n for n in numbers if numbers.count(n) == 1][0]
run_tests(find_single)
