Add files via upload

Author: 3LENDERMAN

02/__pycache__/ib111.cpython-311.pyc

@@ -0,0 +1,89 @@
+from ib111 import week_02  # noqa
+
+# Predicte ‹is_visa›, is True, when parameter number is valid VISA card number
+# It starts with 4, and has 13, 16, or 19 numerals and is valid number from <credit> file
+
+def is_visa(number):
+    length = get_length(number)
+    if number // 10 ** (length - 1) != 4:
+        return False
+    if length != 13 and length != 16 and length != 19:
+        return False
+    if not is_valid_card(number):
+        return False
+    
+    return True
+    
+def is_valid_card(number):
+    control = number % 10
+    number //= 10
+    index = 2
+    sumVal = 0
+    while number > 0:
+        if index % 2 == 0:
+            value = number % 10
+            if (value * 2) > 9:
+                value = (value * 2) - 9
+                sumVal += value
+            else:
+                sumVal += value * 2
+        else:
+            sumVal += number % 10
+        index += 1
+        number //= 10
+    if (sumVal + control) % 10 == 0:
+        return True
+    return False
+
+def get_length(number):
+    count = 0
+    while number > 0:
+        number //= 10
+        count += 1
+    return count
+
+# Predicate <is_mastercard> is True, when number is valid Mastercard number
+# Thats: starts with 50–55, or 22100–27209, has 16 numerals and is valid credit card number
+
+def is_mastercard(number):
+    length = get_length(number)
+    if length != 16:
+        return False
+    value = number // 10 ** (length - 2)
+    if value >= 50 and value <= 55:
+        return True
+    value = number // 10 ** (length - 5)
+    if value >= 22100 and value <= 27209:
+        return True
+    return False
+
+def main(): # run simple tests
+    assert is_visa(4111111111111111)
+    assert is_visa(4012888888881881)
+    assert is_visa(4988438843884305)
+    assert is_visa(4646464646464644)
+    assert is_visa(4199350000000002)
+    assert is_visa(4222222222222)
+    assert is_visa(4111111111111111110)
+
+    assert not is_visa(411111111111116)
+    assert not is_visa(5500000000000004)
+    assert not is_visa(4929300836739328)
+
+    assert is_mastercard(5500000000000004)
+    assert is_mastercard(5555555555554444)
+    assert is_mastercard(5105105105105100)
+    assert is_mastercard(5424000000000015)
+    assert is_mastercard(2223520443560010)
+    assert is_mastercard(5101180000000007)
+    assert is_mastercard(2222400070000005)
+
+    assert not is_mastercard(4012888888881881)
+    assert not is_mastercard(22004000700000003)
+    assert not is_mastercard(5624000000000013)
+    assert not is_mastercard(2721000030000016)
+    assert not is_mastercard(5101180000000000003)
+
+
+if __name__ == "__main__":
+    main()

02/cards.py

@@ -0,0 +1,49 @@
+from ib111 import week_02  # noqa
+from math import factorial
+
+
+# Consider combination numbers, defined like:
+#  ⟦ (n¦k) = n! / (k! ⋅ (n - k)!) ⟧
+
+# where ⟦k ≤ n⟧. Factorial is defined: ⟦ n! = ∏ᵢ₌₁ⁿi ⟧
+
+# That means:
+#  ⟦ n! / k! = ∏ᵢ₌₁ⁿ i / ∏ᵢ₌₁ᵏ i = ∏ᵢ₌ₖ₊₁ⁿ i ⟧
+
+def comb_for(n, k):
+    # Find smaller from ⟦k⟧ and ⟦n - k⟧ 
+    # where ⟦(n¦k) = (n¦n-k)⟧.
+    if k < n - k:
+        k = n - k
+
+    # Multiply all numbers between ⟦k⟧ and ⟦n⟧ excluding k and including n
+    numerator = 1
+    for i in range(k + 1, n + 1):
+        numerator *= i
+
+    return numerator // factorial(n - k)
+
+# Eqvivalent definition but using ‹while› cycle:
+def comb_while(n, k):
+    if k < n - k:
+        k = n - k
+
+    numerator = 1
+    i = k + 1
+
+    while i <= n:
+        numerator *= i
+        i += 1
+
+    return numerator // factorial(n - k)
+
+def main():  # run tests in cycle
+    for n in range(1, 50):
+        for k in range(1, n):
+            naive = factorial(n) // (factorial(k) * factorial(n - k))
+            assert comb_for(n, k) == naive
+            assert comb_while(n, k) == naive
+
+
+if __name__ == '__main__':
+    main()

02/comb.py

@@ -0,0 +1,49 @@
+from ib111 import week_02  # noqa
+
+# Predicate checks valid credit card number using Luhn algorithm:
+#  1. Double every second value from right side; if value >9 deduct 9
+#  2. Sum all numbers from 1. and on odd indexes excluding first from right
+#  3. NUmber is valid if sum of all numbers is divisible by 10.
+
+# For 28316 control number is 6 and sum: 
+# ⟦2 + (2⋅8 - 9) + 3 + 2⋅1 = 2 + 7 + 3 + 2 = 14⟧.
+# After adding control number, sum is 20 which is divisible with 10 
+# and number is thus valid.
+
+def is_valid_card(number):
+    control = number % 10
+    number //= 10
+    index = 2
+    sumVal = 0
+    while number > 0:
+        if index % 2 == 0:
+            value = number % 10
+            if (value * 2) > 9:
+                value = (value * 2) - 9
+                sumVal += value
+            else:
+                sumVal += value * 2
+        else:
+            sumVal += number % 10
+        index += 1
+        number //= 10
+    if (sumVal + control) % 10 == 0:
+        return True
+    return False
+
+def main():
+    assert is_valid_card(28316)
+    assert is_valid_card(4556737586899855)
+    assert is_valid_card(4929599116478604)
+    assert is_valid_card(4929300836739668)
+    assert not is_valid_card(4929300835539668)
+    assert not is_valid_card(4929300836739328)
+    assert not is_valid_card(5101180000000000007)
+
+    assert is_valid_card(5294967072531977)
+    assert is_valid_card(5354598557505686)
+    assert is_valid_card(2720993849498580)
+
+
+if __name__ == "__main__":
+    main()

02/credit.py

@@ -0,0 +1,55 @@
+from ib111 import week_02  # noqa
+
+# Function ‹delete_to_maximal› for ‹number› returns biggest
+# value by deleting one decimal digit in number.
+
+def delete_to_maximal(number):
+    original_number = number
+    current_power_of_ten = 1
+    max_number = float('-inf')  # Initialize to smallest number
+
+    while current_power_of_ten <= original_number:
+        left_part = number // (current_power_of_ten * 10) 
+        right_part = number % current_power_of_ten  
+        new_number = left_part * current_power_of_ten + right_part
+        max_number = max(max_number, new_number)
+        current_power_of_ten *= 10
+
+    return max_number
+
+def get_length(num):
+    count = 0
+    while num > 0:
+        num //= 10
+        count += 1
+    return count
+
+# Function ‹delete_k_to_maximal› returns biggest number created by deleting <k> digits:
+
+def delete_k_to_maximal(number, k):
+    result = number
+    for i in range(k):
+        result = delete_to_maximal(result)
+
+    return result
+
+def main():
+    assert delete_to_maximal(54) == 5
+    assert delete_to_maximal(45) == 5
+    assert delete_to_maximal(100) == 10
+    assert delete_to_maximal(123) == 23
+    assert delete_to_maximal(4312) == 432
+    assert delete_to_maximal(1231) == 231
+    assert delete_to_maximal(2331) == 331
+
+    assert delete_k_to_maximal(2331, 2) == 33
+    assert delete_k_to_maximal(22331, 2) == 331
+    assert delete_k_to_maximal(12345, 4) == 5
+    assert delete_k_to_maximal(1234554321, 8) == 55
+    assert delete_k_to_maximal(123123123123, 4) == 33123123
+    assert delete_k_to_maximal(123321123321, 4) == 33223321
+    assert delete_k_to_maximal(11181118111, 9) == 88
+
+
+if __name__ == "__main__":
+    main()

02/delete.py

@@ -0,0 +1,37 @@
+from ib111 import week_02  # noqa
+
+# Function that checks if digits in number are descending in value.
+# For example "321" or "775" is True but "123" is False
+
+# ‹get_digit› gets digit value on k-index:
+def get_digit(number, k):
+    return (number // 10 ** k) % 10
+
+# Each division by 10 "removes" one digit, thus in counter remains number of digits:
+def count_digits(number):
+    count = 0
+    while number > 0:
+        count += 1
+        number = number // 10
+    return count
+
+# Main function that calls helper functions:
+def is_descending(number):
+    for k in range(count_digits(number) - 1):
+        if get_digit(number, k + 1) < get_digit(number, k):
+            return False
+
+    return True
+
+def main():  # Run simple tests
+    assert is_descending(7)
+    assert is_descending(321)
+    assert is_descending(33222111)
+    assert is_descending(9999)
+    assert is_descending(7741)
+    assert not is_descending(123)
+    assert not is_descending(332233)
+    assert not is_descending(774101)
+
+if __name__ == "__main__":
+    main()

02/descending.py

@@ -0,0 +1,55 @@
+from ib111 import week_02  # noqa
+
+# ‹power_digit_sum›, returns special digit sum of ‹number›
+# Each number exponentiate to the value of the index 
+# Numbering from left where index of first digit has value 1
+# ‹power_digit_sum› calculation will be done in seven-base.
+
+# Example: number ⟦1234⟧ is seven base is: ⟦(3412)₇⟧ – ⟦3⋅7³ + 4⋅7² + 1⋅7¹ + 2⋅7⁰ = 1029 
+# + 196 + 7 + 2 = 1234⟧. ‹power_digit_sum(1234)› gets us ⟦3¹ + 4² + 1³ + 2⁴ = 36⟧.
+
+def power_digit_sum(number):
+    value = to_seven_base(number)
+    sum_val = 0
+    length = get_length(value)
+    for i in range(1, length + 1):
+        digit = get_digit(value, i)
+        sum_val += digit ** (length - i + 1)
+    return sum_val
+
+# Convert decimal number to seven-base number
+def to_seven_base(number):
+    if number == 0:
+        return 0
+    value = 0
+    power = 1
+    while number > 0:
+        value += number % 7 * power
+        number //= 7
+        power *= 10
+
+    return value
+
+def get_length(number):
+    count = 0
+    while number > 0:
+        number //= 10  # Count digits in decimal numbre
+        count += 1
+    return count
+
+def get_digit(number, index):
+    digit = 0
+    for _ in range(1, index + 1):
+        digit = number % 10  # Get digit in decimal number
+        number //= 10
+    return digit
+
+def main() -> None: # run tests
+    assert power_digit_sum(7) == 1
+    assert power_digit_sum(1234) == 36
+    assert power_digit_sum(333) == 95
+    assert power_digit_sum(52891) == 46693
+
+
+if __name__ == "__main__":
+    main()

02/digit_sum.py

@@ -0,0 +1,43 @@
+from ib111 import week_02  # noqa
+
+# ‹count_digit_in_sequence›, returns how many times ‹digit› 
+# occurs in numbers in interval from <low> to <hight> including.
+
+def count_digit_in_sequence(digit, low, high):
+    counter = 0
+    for i in range(low, high + 1):
+        for x in range(1, count_digits(i) + 1):
+            if get_digit(i, x) == digit:
+                counter += 1
+    
+    return counter
+
+def count_digits(number):
+    counter = 0
+    if number == 0:
+        return 1
+    while number > 0:
+        number //= 10
+        counter += 1
+    return counter
+
+def get_digit(number, index):
+    digit = 0
+    while index > 0:
+        digit = number % 10
+        number //= 10
+        index -= 1
+    return digit 
+
+def main(): # run tests
+    assert count_digit_in_sequence(1, 0, 13) == 6
+    assert count_digit_in_sequence(0, 10, 20) == 2
+    assert count_digit_in_sequence(0, 0, 10) == 2
+    assert count_digit_in_sequence(4, 15, 23) == 0
+    assert count_digit_in_sequence(5, 20, 120) == 20
+    assert count_digit_in_sequence(0, 10, 100) == 11
+    assert count_digit_in_sequence(2, 111, 1000) == 279
+
+
+if __name__ == "__main__":
+    main()