⬆️ Update files names

Author: joseguilhermefmoura

01_Elementary/01.py

@@ -0,0 +1,2 @@
+def mult_two(a: int, b: int) -> int:
+    return a * b

01_Elementary/02.py

@@ -0,0 +1,2 @@
+def easy_unpack(tpl: tuple) -> tuple:
+    return (tpl[0], tpl[2], tpl[-2])

01_Elementary/03.py

@@ -0,0 +1,2 @@
+def first_word(line: str) -> str:
+    return line.split()[0]

01_Elementary/04.py

@@ -0,0 +1,2 @@
+def is_acceptable_password(password:str) -> bool:
+    return (lambda password : len(password) > 6)(password)

01_Elementary/05.py

@@ -0,0 +1,2 @@
+def number_length(a: int) -> int:
+    return len(str(a))

01_Elementary/06.py

@@ -0,0 +1,10 @@
+def end_zeros(num: int) -> int:
+
+    sum = 0
+    
+    for number in list(reversed(str(num))):
+        if int(number) == 0:
+            sum += 1
+        else:
+            return sum
+    return sum

01_Elementary/07.py

@@ -0,0 +1,12 @@
+"""
+    # Backward String
+
+    ## You should return a given string in reverse order.
+
+    - Input: A string.
+
+    - Output: A string.
+"""
+
+def backward_string(val: str) -> str:
+    return val [::-1]

01_Elementary/08.py

@@ -0,0 +1,31 @@
+"""
+    # Remove All Before
+
+    ## Not all of the elements are important.
+    ## What you need to do here is to remove from the list all of the elements before the given one.
+    ## For the illustration we have a list [1, 2, 3, 4, 5] and we need to remove all elements
+    ## that go before 3 - which is 1 and 2.
+
+    ## We have two edge cases here: (1) if a cutting element cannot be found,
+    ## then the list shoudn't be changed. (2) if the list is empty, then it should remain empty.
+    
+    - Input: List and the border element.
+
+    - Output: Iterable (tuple, list, iterator ...).
+"""
+
+
+def remove_all_before(items: list, border: int) -> list:
+    if border not in items:
+        return items
+    else:
+        return items[items.index(border):]
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert list(remove_all_before([1, 2, 3, 4, 5], 3)) == [3, 4, 5]
+assert list(remove_all_before([1, 1, 2, 2, 3, 3], 2)) == [2, 2, 3, 3]
+assert list(remove_all_before([1, 1, 2, 4, 2, 3, 4], 2)) == [2, 4, 2, 3, 4]
+assert list(remove_all_before([1, 1, 5, 6, 7], 2)) == [1, 1, 5, 6, 7]
+assert list(remove_all_before([], 0)) == []
+assert list(remove_all_before([7, 7, 7, 7, 7, 7, 7, 7, 7], 7)) == [7, 7, 7, 7, 7, 7, 7, 7, 7]

01_Elementary/09.py

@@ -0,0 +1,21 @@
+"""
+    # All Upper I
+
+    ## Check if a given string has all symbols in upper case.
+    ## If the string is empty or doesn't have any letter in it - function should return True.
+    
+    - Input: A string.
+
+    - Output: a boolean.
+"""
+
+
+def is_all_upper(text: str) -> bool:
+    return (lambda text : text.upper() == text)(text)
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert is_all_upper('ALL UPPER') == True
+assert is_all_upper('all lower') == False
+assert is_all_upper('mixed UPPER and lower') == False
+assert is_all_upper('') == True

01_Elementary/10.py

@@ -0,0 +1,23 @@
+"""
+    # Replace First
+
+    ## In a given list the first element should become the last one.
+    ## An empty list or list with only one element should stay the same.
+    
+    - Input: List.
+
+    - Output: Iterable.
+"""
+
+
+def replace_first(items: list) -> list:
+    if not items:
+        return []
+    else:
+        items.append(items[0])
+        return items[1:]
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert list(replace_first([1, 2, 3, 4])) == [2, 3, 4, 1]
+assert list(replace_first([1])) == [1]
+assert list(replace_first([])) == []

01_Elementary/11.py

@@ -0,0 +1,21 @@
+"""
+    # Max Digit
+
+    ## You have a number and you need to determine which digit in this number is the biggest.
+    
+    - Input: A positive int.
+
+    - Output: An Int (0-9).
+"""
+
+
+def max_digit(numbers: int) -> int:
+    return sorted([int(number) for number in str(numbers)])[-1]
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert max_digit(0) == 0
+assert max_digit(52) == 5
+assert max_digit(634) == 6
+assert max_digit(1) == 1
+assert max_digit(10000) == 1

01_Elementary/12.py

@@ -0,0 +1,27 @@
+"""
+    # Split Pairs
+
+    ## Split the string into pairs of two characters.
+    ## If the string contains an odd number of characters, then the missing second
+    ## character of the final pair should be replaced with an underscore ('_').
+
+    - Input: A string.
+
+    - Output: An iterable of strings.
+"""
+
+
+def split_pairs(a):
+    if len(a) % 2 == 0:
+        return [a[i : i + 2] for i in range(0, len(a), 2)]
+    else:
+        a = a + '_'
+        return split_pairs(a)
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert list(split_pairs('abcd')) == ['ab', 'cd']
+assert list(split_pairs('abc')) == ['ab', 'c_']
+assert list(split_pairs('abcdf')) == ['ab', 'cd', 'f_']
+assert list(split_pairs('a')) == ['a_']
+assert list(split_pairs('')) == []

01_Elementary/13.py

@@ -0,0 +1,29 @@
+"""
+    # Beginning Zeros
+
+    ## You have a string that consist only of digits.
+    ## You need to find how many zero digits ("0") are at the beginning of the given string.
+
+    - Input: A string, that consist of digits.
+
+    - Output: An Int.
+"""
+
+def beginning_zeros(number: str) -> int:
+    sum = 0
+    
+    for number in list(str(number)):
+        if int(number) == 0:
+            sum += 1
+        else:
+            return sum
+    return sum
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert beginning_zeros('100') == 0
+assert beginning_zeros('001') == 2
+assert beginning_zeros('100100') == 0
+assert beginning_zeros('001001') == 2
+assert beginning_zeros('012345679') == 1
+assert beginning_zeros('0000') == 4

01_Elementary/14.py

@@ -0,0 +1,48 @@
+"""
+    # Nearest Value
+
+    ## Find the nearest value to the given one.
+    ## You are given a list of values as set form and a value for which you need to find the nearest one.
+    ## For example, we have the following set of numbers: 4, 7, 10, 11, 12, 17, 
+    ## and we need to find the nearest value to the number 9.
+    ## If we sort this set in the ascending order, then to the left of number 9 will be number 7 and
+    ## to the right - will be number 10.
+    ## But 10 is closer than 7, which means that the correct answer is 10.
+
+    ## A few clarifications:
+    ## -> If 2 numbers are at the same distance, you need to choose the smallest one;
+    ## -> The set of numbers is always non-empty, i.e. the size is >=1;
+    ## -> The given value can be in this set, which means that it’s the answer;
+    ## -> The set can contain both positive and negative numbers, but they are always integers;
+    ## -> The set isn’t sorted and consists of unique numbers.
+
+    - Input: Two arguments. A list of values in the set form. The sought value is an int.
+
+    - Output: Int.
+"""
+
+
+def nearest_value(values: set, one: int) -> int:
+    if one in values:
+        return one
+    
+    minor_distance = 1
+
+    while True:
+        if (one - minor_distance) in values:
+            return (one - minor_distance)
+        elif (one + minor_distance) in values:
+            return (one + minor_distance)
+        else:
+            minor_distance += 1
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert nearest_value({4, 7, 10, 11, 12, 17}, 9) == 10
+assert nearest_value({4, 7, 10, 11, 12, 17}, 8) == 7
+assert nearest_value({4, 8, 10, 11, 12, 17}, 9) == 8
+assert nearest_value({4, 9, 10, 11, 12, 17}, 9) == 9
+assert nearest_value({4, 7, 10, 11, 12, 17}, 0) == 4
+assert nearest_value({4, 7, 10, 11, 12, 17}, 100) == 17
+assert nearest_value({5, 10, 8, 12, 89, 100}, 7) == 8
+assert nearest_value({-1, 2, 3}, 0) == -1

01_Elementary/15.py

@@ -0,0 +1,27 @@
+"""
+    # Between Markers (simplified)
+
+    ## You are given a string and two markers (the initial one and final).
+    ## You have to find a substring enclosed between these two markers.
+   
+    ## But there are a few important conditions.
+    ## -> The initial and final markers are always different.
+    ## -> The initial and final markers are always 1 char size.
+    ## -> The initial and final markers always exist in a string and go one after another.
+
+    - Input: Three arguments. All of them are strings.
+             The second and third arguments are the initial and final markers.
+
+    - Output: A string.
+"""
+
+
+def between_markers(text: str, begin: str, end: str) -> str:
+    return text[text.find(begin) + 1:text.find(end)]
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert between_markers('What is >apple<', '>', '<') == "apple"
+assert between_markers('What is [apple]', '[', ']') == "apple"
+assert between_markers('What is ><', '>', '<') == ""
+assert between_markers('>apple<', '>', '<') == "apple"

01_Elementary/16.py

@@ -0,0 +1,37 @@
+"""
+    # Correct Sentence
+
+    ## For the input of your function, you will be given one sentence. 
+    ## You have to return a corrected version, that starts with a capital letter
+    ## and ends with a period (dot).
+   
+    ## Pay attention to the fact that not all of the fixes are necessary.
+    ## If a sentence already ends with a period (dot), then adding another one will be a mistake.
+
+    - Input: A string.
+    - Output: A string.
+
+    >> EXAMPLE:
+       
+        correct_sentence("greetings, friends") == "Greetings, friends."
+        correct_sentence("Greetings, friends") == "Greetings, friends."
+        correct_sentence("Greetings, friends.") == "Greetings, friends."
+    
+    <<
+"""
+
+
+def correct_sentence(text: str) -> str:
+    if text[-1] != '.':
+        text += '.'
+        return text[0].upper() + text[1:]
+    else:
+        return text[0].upper() + text[1:]
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert correct_sentence("greetings, friends") == "Greetings, friends."
+assert correct_sentence("Greetings, friends") == "Greetings, friends."
+assert correct_sentence("Greetings, friends.") == "Greetings, friends."
+assert correct_sentence("hi") == "Hi."
+assert correct_sentence("welcome to New York") == "Welcome to New York."

01_Elementary/17.py

@@ -0,0 +1,27 @@
+"""
+    # Is Even
+
+    ## Check if the given number is even or not.
+    ## Your function should return True if the number is even, and False if the number is odd. 
+   
+    - Input: An int.
+    - Output: A bool.
+
+    >> EXAMPLE:
+       
+        is_even(2) == True
+        is_even(5) == False
+        is_even(0) == True
+    
+    <<
+"""
+
+
+def is_even(num: int) -> bool:
+    return bool(num % 2 == 0)
+
+
+# These "asserts" are used for self-checking and not for an auto-testing
+assert is_even(2) == True
+assert is_even(5) == False
+assert is_even(0) == True