jugaadcode 0.1.0__tar.gz

jugaadcode-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: jugaadcode
+Version: 0.1.0
+Summary: A Python library for common programming logic and algorithms
+Author: Mohamed Faraazman Bin Farooq S
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# codinglogic
+
+A Python library containing common coding logic, algorithms, and
+programming utilities.
+
+## Installation
+
+```bash
+pip install codinglogic

jugaadcode-0.1.0/README.md

@@ -0,0 +1,9 @@
+# codinglogic
+
+A Python library containing common coding logic, algorithms, and
+programming utilities.
+
+## Installation
+
+```bash
+pip install codinglogic

jugaadcode-0.1.0/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "jugaadcode"
+version = "0.1.0"
+description = "A Python library for common programming logic and algorithms"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+    {name = "Mohamed Faraazman Bin Farooq S"}
+]

jugaadcode-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jugaadcode-0.1.0/src/jugaadcode/__init__.py

@@ -0,0 +1,51 @@
+from .prime import is_prime
+from .factorial import factorial
+from .fibonacci import fibonacci
+from .palindrome import is_palindrome
+from .armstrong import is_armstrong
+from .reverse_number import reverse_number
+from .sum_of_digits import sum_of_digits
+from .perfect_number import is_perfect_number
+from .strong_number import is_strong_number
+from .harshad_number import is_harshad_number
+from .gcd import gcd
+from .lcm import lcm
+from .even_odd import is_even
+from .reverse_string import reverse_string
+from .count_vowels import count_vowels
+from .character_frequency import character_frequency
+from .anagram import is_anagram
+from .remove_duplicates_string import remove_duplicate_characters
+from .first_non_repeating import first_non_repeating
+from .word_count import word_count
+from .capitalize_words import capitalize_words
+from .longest_word import longest_word
+from .subsequence import is_subsequence
+from .find_max import find_max
+from .find_min import find_min
+from .second_largest import second_largest
+from .remove_duplicates_array import remove_duplicates
+from .duplicate_number import find_duplicate
+from .two_sum import two_sum
+from .move_zeros import move_zeros
+from .linear_search import linear_search
+from .binary_search import binary_search
+from .bubble_sort import bubble_sort
+from .selection_sort import selection_sort
+from .insertion_sort import insertion_sort
+from .merge_sort import merge_sort
+from .quick_sort import quick_sort
+from .counting_sort import counting_sort
+from .kth_largest import kth_largest
+from .power import power
+from .maximum_subarray import maximum_subarray
+from .climbing_stairs import climbing_stairs
+from .coin_change import coin_change
+from .valid_parentheses import valid_parentheses
+from .matrix_transpose import matrix_transpose
+from .reverse_linked_list import reverse_linked_list
+from .longest_consecutive import longest_consecutive
+from .pair_with_difference import pair_with_difference
+from .trailing_zeros import trailing_zeros
+from .factorial_with_trailing_zeros import factorial_with_trailing_zeros
+from .factorial_trailing_zeros_direct import factorial_trailing_zeros_direct

jugaadcode-0.1.0/src/jugaadcode/anagram.py

@@ -0,0 +1,12 @@
+def is_anagram(first=None, second=None):
+
+    if first is None:
+        first = input("Enter first string to check if it is an anagram: ")
+
+    if second is None:
+        second = input("Enter second string to check if it is an anagram: ")
+
+    first = first.replace(" ", "").lower()
+    second = second.replace(" ", "").lower()
+
+    return sorted(first) == sorted(second)

jugaadcode-0.1.0/src/jugaadcode/armstrong.py

@@ -0,0 +1,11 @@
+def is_armstrong(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to check if it is an Armstrong number: "))
+
+    digits = str(abs(n))
+    power = len(digits)
+
+    total = sum(int(digit) ** power for digit in digits)
+
+    return total == n

jugaadcode-0.1.0/src/jugaadcode/binary_search.py

@@ -0,0 +1,27 @@
+def binary_search(numbers=None, target=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter SORTED numbers separated by spaces: ").split())
+        )
+
+    if target is None:
+        target = int(input("Enter target: "))
+
+    left = 0
+    right = len(numbers) - 1
+
+    while left <= right:
+
+        middle = (left + right) // 2
+
+        if numbers[middle] == target:
+            return middle
+
+        if numbers[middle] < target:
+            left = middle + 1
+
+        else:
+            right = middle - 1
+
+    return -1

jugaadcode-0.1.0/src/jugaadcode/bubble_sort.py

@@ -0,0 +1,21 @@
+def bubble_sort(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    numbers = numbers.copy()
+
+    for i in range(len(numbers)):
+
+        for j in range(len(numbers) - i - 1):
+
+            if numbers[j] > numbers[j + 1]:
+
+                numbers[j], numbers[j + 1] = (
+                    numbers[j + 1],
+                    numbers[j]
+                )
+
+    return numbers

jugaadcode-0.1.0/src/jugaadcode/capitalize_words.py

@@ -0,0 +1,6 @@
+def capitalize_words(text=None):
+
+    if text is None:
+        text = input("Enter a sentence to capitalize words in: ")
+
+    return text.title()

jugaadcode-0.1.0/src/jugaadcode/character_frequency.py

@@ -0,0 +1,13 @@
+def character_frequency(text=None):
+
+    if text is None:
+        text = input("Enter a string to analyze character frequency: ")
+
+    frequency = {}
+
+    for character in text:
+
+        if character != " ":
+            frequency[character] = frequency.get(character, 0) + 1
+
+    return frequency

jugaadcode-0.1.0/src/jugaadcode/climbing_stairs.py

@@ -0,0 +1,16 @@
+def climbing_stairs(n=None):
+
+    if n is None:
+        n = int(input("Enter number of stairs: "))
+
+    if n <= 2:
+        return n
+
+    first = 1
+    second = 2
+
+    for _ in range(3, n + 1):
+
+        first, second = second, first + second
+
+    return second

jugaadcode-0.1.0/src/jugaadcode/coin_change.py

@@ -0,0 +1,29 @@
+def coin_change(coins=None, amount=None):
+
+    if coins is None:
+        coins = list(
+            map(int, input("Enter coin values separated by spaces: ").split())
+        )
+
+    if amount is None:
+        amount = int(input("Enter amount: "))
+
+    dp = [float("inf")] * (amount + 1)
+
+    dp[0] = 0
+
+    for current in range(1, amount + 1):
+
+        for coin in coins:
+
+            if coin <= current:
+
+                dp[current] = min(
+                    dp[current],
+                    dp[current - coin] + 1
+                )
+
+    if dp[amount] == float("inf"):
+        return -1
+
+    return dp[amount]

jugaadcode-0.1.0/src/jugaadcode/count_vowels.py

@@ -0,0 +1,15 @@
+def count_vowels(text=None):
+
+    if text is None:
+        text = input("Enter a string to count vowels in: ")
+
+    vowels = "aeiouAEIOU"
+
+    count = 0
+
+    for character in text:
+
+        if character in vowels:
+            count += 1
+
+    return count

jugaadcode-0.1.0/src/jugaadcode/counting_sort.py

@@ -0,0 +1,26 @@
+def counting_sort(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter non-negative numbers: ").split())
+        )
+
+    if not numbers:
+        return []
+
+    if min(numbers) < 0:
+        raise ValueError("Only non-negative numbers are supported")
+
+    count = [0] * (max(numbers) + 1)
+
+    for number in numbers:
+        count[number] += 1
+
+    result = []
+
+    for number in range(len(count)):
+
+        for _ in range(count[number]):
+            result.append(number)
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/duplicate_number.py

@@ -0,0 +1,17 @@
+def find_duplicate(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    seen = set()
+
+    for number in numbers:
+
+        if number in seen:
+            return number
+
+        seen.add(number)
+
+    return None

jugaadcode-0.1.0/src/jugaadcode/even_odd.py

@@ -0,0 +1,6 @@
+def is_even(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to check if it is even: "))
+
+    return n % 2 == 0

jugaadcode-0.1.0/src/jugaadcode/factorial.py

@@ -0,0 +1,14 @@
+def factorial(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to calculate its factorial: "))
+
+    if n < 0:
+        raise ValueError("Number must be non-negative")
+
+    result = 1
+
+    for i in range(1, n + 1):
+        result *= i
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/factorial_trailing_zeros_direct.py

@@ -0,0 +1,20 @@
+def factorial_trailing_zeros_direct(n=None):
+    if n is None:
+        n = int(input("Enter a number: "))
+
+    if n < 0:
+        raise ValueError("Number must be non-negative")
+
+    factorial = 1
+
+    for i in range(1, n + 1):
+        factorial *= i
+
+    number = factorial
+    count = 0
+
+    while number > 0 and number % 10 == 0:
+        count += 1
+        number //= 10
+
+    return factorial, count

jugaadcode-0.1.0/src/jugaadcode/factorial_with_trailing_zeros.py

@@ -0,0 +1,29 @@
+def trailing_zeros(n):
+    count = 0
+
+    while n > 0:
+        n //= 5
+        count += n
+
+    return count
+
+
+def factorial_with_trailing_zeros(zeros=None):
+    if zeros is None:
+        zeros = int(input("Enter required number of trailing zeros: "))
+
+    if zeros < 0:
+        raise ValueError("Number of trailing zeros must be non-negative")
+
+    n = 1
+
+    while True:
+        count = trailing_zeros(n)
+
+        if count == zeros:
+            return n
+
+        if count > zeros:
+            return None
+
+        n += 1

jugaadcode-0.1.0/src/jugaadcode/fibonacci.py

@@ -0,0 +1,20 @@
+def fibonacci(n=None):
+
+    if n is None:
+        n = int(input("How many Fibonacci numbers? "))
+
+    if n < 0:
+        raise ValueError("Number must be non-negative")
+
+    result = []
+
+    a = 0
+    b = 1
+
+    for _ in range(n):
+
+        result.append(a)
+
+        a, b = b, a + b
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/find_max.py

@@ -0,0 +1,15 @@
+def find_max(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    maximum = numbers[0]
+
+    for number in numbers:
+
+        if number > maximum:
+            maximum = number
+
+    return maximum

jugaadcode-0.1.0/src/jugaadcode/find_min.py

@@ -0,0 +1,15 @@
+def find_min(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    minimum = numbers[0]
+
+    for number in numbers:
+
+        if number < minimum:
+            minimum = number
+
+    return minimum

jugaadcode-0.1.0/src/jugaadcode/first_non_repeating.py

@@ -0,0 +1,18 @@
+def first_non_repeating(text=None):
+
+    if text is None:
+        text = input("Enter a string to find the first non-repeating character: ")
+
+    frequency = {}
+
+    for character in text:
+
+        if character != " ":
+            frequency[character] = frequency.get(character, 0) + 1
+
+    for character in text:
+
+        if character != " " and frequency[character] == 1:
+            return character
+
+    return None

jugaadcode-0.1.0/src/jugaadcode/gcd.py

@@ -0,0 +1,12 @@
+def gcd(a=None, b=None):
+
+    if a is None:
+        a = int(input("Enter first number of GCD: "))
+
+    if b is None:
+        b = int(input("Enter second number of GCD: "))
+
+    while b != 0:
+        a, b = b, a % b
+
+    return abs(a)

jugaadcode-0.1.0/src/jugaadcode/harshad_number.py

@@ -0,0 +1,11 @@
+def is_harshad_number(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to check if it is a harshad number: "))
+
+    if n == 0:
+        return False
+
+    digit_sum = sum(int(digit) for digit in str(abs(n)))
+
+    return n % digit_sum == 0

jugaadcode-0.1.0/src/jugaadcode/input_utils.py

@@ -0,0 +1,50 @@
+def get_number(message="Enter a number: "):
+    return int(input(message))
+
+
+def get_numbers(message="Enter numbers separated by spaces: "):
+    return list(map(int, input(message).split()))
+
+
+def get_text(message="Enter text: "):
+    return input(message)
+
+
+def get_target(message="Enter target: "):
+    return int(input(message))
+
+
+def get_k(message="Enter k: "):
+    return int(input(message))
+
+
+def get_difference(message="Enter difference: "):
+    return int(input(message))
+
+
+def get_amount(message="Enter amount: "):
+    return int(input(message))
+
+
+def get_rows(message="Enter number of rows: "):
+    return int(input(message))
+
+
+def get_columns(message="Enter number of columns: "):
+    return int(input(message))
+
+
+def get_first_number(message="Enter first number: "):
+    return int(input(message))
+
+
+def get_second_number(message="Enter second number: "):
+    return int(input(message))
+
+
+def get_first_text(message="Enter first string: "):
+    return input(message)
+
+
+def get_second_text(message="Enter second string: "):
+    return input(message)

jugaadcode-0.1.0/src/jugaadcode/insertion_sort.py

@@ -0,0 +1,24 @@
+def insertion_sort(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    numbers = numbers.copy()
+
+    for i in range(1, len(numbers)):
+
+        current = numbers[i]
+
+        j = i - 1
+
+        while j >= 0 and numbers[j] > current:
+
+            numbers[j + 1] = numbers[j]
+
+            j -= 1
+
+        numbers[j + 1] = current
+
+    return numbers

jugaadcode-0.1.0/src/jugaadcode/kth_largest.py

@@ -0,0 +1,16 @@
+def kth_largest(numbers=None, k=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    if k is None:
+        k = int(input("Enter k: "))
+
+    if k < 1 or k > len(numbers):
+        raise ValueError("Invalid k")
+
+    sorted_numbers = sorted(numbers, reverse=True)
+
+    return sorted_numbers[k - 1]

jugaadcode-0.1.0/src/jugaadcode/lcm.py

@@ -0,0 +1,18 @@
+def lcm(a=None, b=None):
+
+    if a is None:
+        a = int(input("Enter first number of LCM: "))
+
+    if b is None:
+        b = int(input("Enter second number of LCM: "))
+
+    if a == 0 or b == 0:
+        return 0
+
+    x = abs(a)
+    y = abs(b)
+
+    while y:
+        x, y = y, x % y
+
+    return abs(a * b) // x

jugaadcode-0.1.0/src/jugaadcode/linear_search.py

@@ -0,0 +1,16 @@
+def linear_search(numbers=None, target=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    if target is None:
+        target = int(input("Enter target: "))
+
+    for index, number in enumerate(numbers):
+
+        if number == target:
+            return index
+
+    return -1

jugaadcode-0.1.0/src/jugaadcode/longest_consecutive.py

@@ -0,0 +1,22 @@
+def longest_consecutive(numbers=None):
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    numbers = set(numbers)
+    longest = 0
+
+    for number in numbers:
+
+        if number - 1 not in numbers:
+            current = number
+            length = 1
+
+            while current + 1 in numbers:
+                current += 1
+                length += 1
+
+            longest = max(longest, length)
+
+    return longest

jugaadcode-0.1.0/src/jugaadcode/longest_word.py

@@ -0,0 +1,18 @@
+def longest_word(text=None):
+
+    if text is None:
+        text = input("Enter a sentence to find the longest word in: ")
+
+    words = text.split()
+
+    if not words:
+        return ""
+
+    longest = words[0]
+
+    for word in words:
+
+        if len(word) > len(longest):
+            longest = word
+
+    return longest

jugaadcode-0.1.0/src/jugaadcode/matrix_transpose.py

@@ -0,0 +1,42 @@
+def matrix_transpose(matrix=None):
+
+    if matrix is None:
+
+        rows = int(input("Enter number of rows: "))
+
+        columns = int(input("Enter number of columns: "))
+
+        matrix = []
+
+        for i in range(rows):
+
+            row = list(
+                map(
+                    int,
+                    input(f"Enter row {i + 1}: ").split()
+                )
+            )
+
+            if len(row) != columns:
+                raise ValueError(
+                    "Number of values does not match columns"
+                )
+
+            matrix.append(row)
+
+    if not matrix:
+        return []
+
+    result = []
+
+    for column in range(len(matrix[0])):
+
+        new_row = []
+
+        for row in range(len(matrix)):
+
+            new_row.append(matrix[row][column])
+
+        result.append(new_row)
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/maximum_subarray.py

@@ -0,0 +1,26 @@
+def maximum_subarray(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    if not numbers:
+        return 0
+
+    current_sum = numbers[0]
+    maximum_sum = numbers[0]
+
+    for number in numbers[1:]:
+
+        current_sum = max(
+            number,
+            current_sum + number
+        )
+
+        maximum_sum = max(
+            maximum_sum,
+            current_sum
+        )
+
+    return maximum_sum

jugaadcode-0.1.0/src/jugaadcode/merge_sort.py

@@ -0,0 +1,36 @@
+def merge_sort(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    if len(numbers) <= 1:
+        return numbers
+
+    middle = len(numbers) // 2
+
+    left = merge_sort(numbers[:middle])
+    right = merge_sort(numbers[middle:])
+
+    result = []
+
+    i = 0
+    j = 0
+
+    while i < len(left) and j < len(right):
+
+        if left[i] <= right[j]:
+
+            result.append(left[i])
+            i += 1
+
+        else:
+
+            result.append(right[j])
+            j += 1
+
+    result.extend(left[i:])
+    result.extend(right[j:])
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/move_zeros.py

@@ -0,0 +1,21 @@
+def move_zeros(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    result = []
+
+    zero_count = 0
+
+    for number in numbers:
+
+        if number == 0:
+            zero_count += 1
+        else:
+            result.append(number)
+
+    result.extend([0] * zero_count)
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/pair_with_difference.py

@@ -0,0 +1,21 @@
+def pair_with_difference(numbers=None, difference=None):
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    if difference is None:
+        difference = int(input("Enter difference: "))
+
+    seen = set()
+
+    for number in numbers:
+        if number - difference in seen:
+            return [number - difference, number]
+
+        if number + difference in seen:
+            return [number, number + difference]
+
+        seen.add(number)
+
+    return []

jugaadcode-0.1.0/src/jugaadcode/palindrome.py

@@ -0,0 +1,8 @@
+def is_palindrome(value=None):
+
+    if value is None:
+        value = input("Enter a word or number to check if it is a palindrome: ")
+
+    value = str(value)
+
+    return value == value[::-1]

jugaadcode-0.1.0/src/jugaadcode/perfect_number.py

@@ -0,0 +1,19 @@
+def is_perfect_number(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to check if it is a perfect number: "))
+
+    if n <= 1:
+        return False
+
+    total = 1
+
+    for i in range(2, int(n ** 0.5) + 1):
+
+        if n % i == 0:
+            total += i
+
+            if i != n // i:
+                total += n // i
+
+    return total == n

jugaadcode-0.1.0/src/jugaadcode/power.py

@@ -0,0 +1,15 @@
+def power(base=None, exponent=None):
+
+    if base is None:
+        base = int(input("Enter base: "))
+
+    if exponent is None:
+        exponent = int(input("Enter exponent: "))
+
+    if exponent == 0:
+        return 1
+
+    if exponent < 0:
+        return 1 / power(base, -exponent)
+
+    return base * power(base, exponent - 1)

jugaadcode-0.1.0/src/jugaadcode/prime.py

@@ -0,0 +1,14 @@
+def is_prime(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to check if it is prime: "))
+
+    if n < 2:
+        return False
+
+    for i in range(2, int(n ** 0.5) + 1):
+
+        if n % i == 0:
+            return False
+
+    return True

jugaadcode-0.1.0/src/jugaadcode/quick_sort.py

@@ -0,0 +1,29 @@
+def quick_sort(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    if len(numbers) <= 1:
+        return numbers
+
+    pivot = numbers[-1]
+
+    smaller = []
+
+    greater = []
+
+    for number in numbers[:-1]:
+
+        if number <= pivot:
+            smaller.append(number)
+
+        else:
+            greater.append(number)
+
+    return (
+        quick_sort(smaller)
+        + [pivot]
+        + quick_sort(greater)
+    )

jugaadcode-0.1.0/src/jugaadcode/remove_duplicates_array.py

@@ -0,0 +1,15 @@
+def remove_duplicates(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    result = []
+
+    for number in numbers:
+
+        if number not in result:
+            result.append(number)
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/remove_duplicates_string.py

@@ -0,0 +1,13 @@
+def remove_duplicate_characters(text=None):
+
+    if text is None:
+        text = input("Enter a string to remove duplicate characters from: ")
+
+    result = ""
+
+    for character in text:
+
+        if character not in result:
+            result += character
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/reverse_linked_list.py

@@ -0,0 +1,38 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
+
+def reverse_linked_list(values=None):
+    if values is None:
+        values = list(
+            map(int, input("Enter linked list values separated by spaces: ").split())
+        )
+
+    if not values:
+        return []
+
+    head = Node(values[0])
+    current = head
+
+    for value in values[1:]:
+        current.next = Node(value)
+        current = current.next
+
+    previous = None
+    current = head
+
+    while current:
+        next_node = current.next
+        current.next = previous
+        previous = current
+        current = next_node
+
+    result = []
+
+    while previous:
+        result.append(previous.value)
+        previous = previous.next
+
+    return result

jugaadcode-0.1.0/src/jugaadcode/reverse_number.py

@@ -0,0 +1,8 @@
+def reverse_number(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to reverse: "))
+
+    sign = -1 if n < 0 else 1
+
+    return sign * int(str(abs(n))[::-1])

jugaadcode-0.1.0/src/jugaadcode/reverse_string.py

@@ -0,0 +1,6 @@
+def reverse_string(text=None):
+
+    if text is None:
+        text = input("Enter a string to reverse: ")
+
+    return text[::-1]

jugaadcode-0.1.0/src/jugaadcode/second_largest.py

@@ -0,0 +1,25 @@
+def second_largest(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    unique_numbers = list(set(numbers))
+
+    if len(unique_numbers) < 2:
+        raise ValueError("Need at least two different numbers")
+
+    largest = unique_numbers[0]
+    second = None
+
+    for number in unique_numbers:
+
+        if number > largest:
+            second = largest
+            largest = number
+
+        elif second is None or number > second:
+            second = number
+
+    return second

jugaadcode-0.1.0/src/jugaadcode/selection_sort.py

@@ -0,0 +1,24 @@
+def selection_sort(numbers=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces : ").split())
+        )
+
+    numbers = numbers.copy()
+
+    for i in range(len(numbers)):
+
+        minimum = i
+
+        for j in range(i + 1, len(numbers)):
+
+            if numbers[j] < numbers[minimum]:
+                minimum = j
+
+        numbers[i], numbers[minimum] = (
+            numbers[minimum],
+            numbers[i]
+        )
+
+    return numbers

jugaadcode-0.1.0/src/jugaadcode/strong_number.py

@@ -0,0 +1,14 @@
+import math
+
+
+def is_strong_number(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to check if it is a strong number: "))
+
+    total = 0
+
+    for digit in str(abs(n)):
+        total += math.factorial(int(digit))
+
+    return total == n

jugaadcode-0.1.0/src/jugaadcode/subsequence.py

@@ -0,0 +1,16 @@
+def is_subsequence(text=None, sequence=None):
+
+    if text is None:
+        text = input("Enter main string to check for subsequence: ")
+
+    if sequence is None:
+        sequence = input("Enter sequence to check for: ")
+
+    index = 0
+
+    for character in text:
+
+        if index < len(sequence) and character == sequence[index]:
+            index += 1
+
+    return index == len(sequence)

jugaadcode-0.1.0/src/jugaadcode/sum_of_digits.py

@@ -0,0 +1,6 @@
+def sum_of_digits(n=None):
+
+    if n is None:
+        n = int(input("Enter a number to calculate the sum of its digits: "))
+
+    return sum(int(digit) for digit in str(abs(n)))

jugaadcode-0.1.0/src/jugaadcode/trailing_zeros.py

@@ -0,0 +1,14 @@
+def trailing_zeros(n=None):
+    if n is None:
+        n = int(input("Enter a number: "))
+
+    if n < 0:
+        raise ValueError("Number must be non-negative")
+
+    count = 0
+
+    while n > 0:
+        n //= 5
+        count += n
+
+    return count

jugaadcode-0.1.0/src/jugaadcode/two_sum.py

@@ -0,0 +1,22 @@
+def two_sum(numbers=None, target=None):
+
+    if numbers is None:
+        numbers = list(
+            map(int, input("Enter numbers separated by spaces: ").split())
+        )
+
+    if target is None:
+        target = int(input("Enter target: "))
+
+    seen = {}
+
+    for index, number in enumerate(numbers):
+
+        difference = target - number
+
+        if difference in seen:
+            return [seen[difference], index]
+
+        seen[number] = index
+
+    return []

jugaadcode-0.1.0/src/jugaadcode/valid_parentheses.py

@@ -0,0 +1,28 @@
+def valid_parentheses(text=None):
+
+    if text is None:
+        text = input("Enter brackets: ")
+
+    stack = []
+
+    pairs = {
+        ")": "(",
+        "]": "[",
+        "}": "{"
+    }
+
+    for character in text:
+
+        if character in "([{":
+
+            stack.append(character)
+
+        elif character in ")]}":
+
+            if not stack:
+                return False
+
+            if stack.pop() != pairs[character]:
+                return False
+
+    return len(stack) == 0

jugaadcode-0.1.0/src/jugaadcode/word_count.py

@@ -0,0 +1,6 @@
+def word_count(text=None):
+
+    if text is None:
+        text = input("Enter a sentence to count words in: ")
+
+    return len(text.split())

jugaadcode-0.1.0/src/jugaadcode.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: jugaadcode
+Version: 0.1.0
+Summary: A Python library for common programming logic and algorithms
+Author: Mohamed Faraazman Bin Farooq S
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# codinglogic
+
+A Python library containing common coding logic, algorithms, and
+programming utilities.
+
+## Installation
+
+```bash
+pip install codinglogic

jugaadcode-0.1.0/src/jugaadcode.egg-info/SOURCES.txt

@@ -0,0 +1,59 @@
+README.md
+pyproject.toml
+src/jugaadcode/__init__.py
+src/jugaadcode/anagram.py
+src/jugaadcode/armstrong.py
+src/jugaadcode/binary_search.py
+src/jugaadcode/bubble_sort.py
+src/jugaadcode/capitalize_words.py
+src/jugaadcode/character_frequency.py
+src/jugaadcode/climbing_stairs.py
+src/jugaadcode/coin_change.py
+src/jugaadcode/count_vowels.py
+src/jugaadcode/counting_sort.py
+src/jugaadcode/duplicate_number.py
+src/jugaadcode/even_odd.py
+src/jugaadcode/factorial.py
+src/jugaadcode/factorial_trailing_zeros_direct.py
+src/jugaadcode/factorial_with_trailing_zeros.py
+src/jugaadcode/fibonacci.py
+src/jugaadcode/find_max.py
+src/jugaadcode/find_min.py
+src/jugaadcode/first_non_repeating.py
+src/jugaadcode/gcd.py
+src/jugaadcode/harshad_number.py
+src/jugaadcode/input_utils.py
+src/jugaadcode/insertion_sort.py
+src/jugaadcode/kth_largest.py
+src/jugaadcode/lcm.py
+src/jugaadcode/linear_search.py
+src/jugaadcode/longest_consecutive.py
+src/jugaadcode/longest_word.py
+src/jugaadcode/matrix_transpose.py
+src/jugaadcode/maximum_subarray.py
+src/jugaadcode/merge_sort.py
+src/jugaadcode/move_zeros.py
+src/jugaadcode/pair_with_difference.py
+src/jugaadcode/palindrome.py
+src/jugaadcode/perfect_number.py
+src/jugaadcode/power.py
+src/jugaadcode/prime.py
+src/jugaadcode/quick_sort.py
+src/jugaadcode/remove_duplicates_array.py
+src/jugaadcode/remove_duplicates_string.py
+src/jugaadcode/reverse_linked_list.py
+src/jugaadcode/reverse_number.py
+src/jugaadcode/reverse_string.py
+src/jugaadcode/second_largest.py
+src/jugaadcode/selection_sort.py
+src/jugaadcode/strong_number.py
+src/jugaadcode/subsequence.py
+src/jugaadcode/sum_of_digits.py
+src/jugaadcode/trailing_zeros.py
+src/jugaadcode/two_sum.py
+src/jugaadcode/valid_parentheses.py
+src/jugaadcode/word_count.py
+src/jugaadcode.egg-info/PKG-INFO
+src/jugaadcode.egg-info/SOURCES.txt
+src/jugaadcode.egg-info/dependency_links.txt
+src/jugaadcode.egg-info/top_level.txt

jugaadcode-0.1.0/src/jugaadcode.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jugaadcode-0.1.0/src/jugaadcode.egg-info/top_level.txt

@@ -0,0 +1 @@
+jugaadcode