jugaadcode 0.1.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,57 @@
+jugaadcode/__init__.py,sha256=IYXM0UbXDBGbk6gUACQYlGI4ZjX0Cqzuh28fdUgrNDg,2182
+jugaadcode/anagram.py,sha256=lmT7PCQIZ6S8PWEv3bBSiQ_SvNc87nXkll8dzUKz3YM,383
+jugaadcode/armstrong.py,sha256=4qcbwpR-tlWoOwZFHcM37_Us2xdx79vR4Nz6fryRQVo,266
+jugaadcode/binary_search.py,sha256=VEMrAgw1erxFqnhns2JUk179jkPlgSnwt-CbewoLRdU,583
+jugaadcode/bubble_sort.py,sha256=4whLgaTF1mA3jqFwLl0XJfyQC-lI9HUFQ2KKMPXJ5yo,494
+jugaadcode/capitalize_words.py,sha256=DaIECPgH9ip90O9CgEYyYDV9fFW3w02L2FEus_TmBlw,152
+jugaadcode/character_frequency.py,sha256=6VzZ0At_AzW4xkIXJn3DVJf37UUG7lmVyWmtFstj7WI,308
+jugaadcode/climbing_stairs.py,sha256=D67flCjk3uTDUBx7Teb7LJ28XKfXh5XReRpp8d79Rqo,274
+jugaadcode/coin_change.py,sha256=fmuTy-JPShNYY3Jvw2eaKQLynJrUe4jFi5ZFTzH5KhM,638
+jugaadcode/count_vowels.py,sha256=o450xlVBGV643RLbNk4HevRiqL0udwOWx8jVzPKTmAE,268
+jugaadcode/counting_sort.py,sha256=HgY9PdX64WL_LPc-3Z7DC-T_4lI5tl5AbHrLIbmG-Yo,558
+jugaadcode/duplicate_number.py,sha256=aaKsCyDmg1P8YdZWWhM18LtD9H7gQ6k6J-algTtLz9c,326
+jugaadcode/even_odd.py,sha256=gW3lUXF8BwuASm2KVi9bZm_j7Kk105zi0kK2z-Tvyc8,133
+jugaadcode/factorial.py,sha256=3TYzmknbhvkcwJ2S6W3z8FoUeScwW61zPfb3ISui48o,281
+jugaadcode/factorial_trailing_zeros_direct.py,sha256=_0yJjln2bMNkByKMLfYJ_S-ZcqEn9u3kqiSwDB8px4o,420
+jugaadcode/factorial_with_trailing_zeros.py,sha256=KMlmnYoACzSBt8jkrD4jEt4O4T0i8Jlo8oaMQcQGmAs,549
+jugaadcode/fibonacci.py,sha256=--yO48uw6Zz8Fbzc5y4W0UnD9qIHgO1mYogDF3P9q44,318
+jugaadcode/find_max.py,sha256=Ga9uyua-jcK2ApJLmpAbRv9M2CdrkcBuhVXAQ3rCagk,308
+jugaadcode/find_min.py,sha256=WazePtm5ypP1zrxSs08WlNFfasIRPyUdHnc11z0rw1E,308
+jugaadcode/first_non_repeating.py,sha256=PpUTALLIqN0GTMTbonAl8uHk5Hjbgi4PbhIZzuGBrQw,436
+jugaadcode/gcd.py,sha256=9Bl9an_BfJ_-9GV4wkDY7zQ1nN5NcD0mR6J-ytF_KOM,244
+jugaadcode/harshad_number.py,sha256=FSR9eR5rySaN1RWPFPmGr4CeetXc9wIC3LddMlGAAyA,263
+jugaadcode/input_utils.py,sha256=tsqBoPXnVlR0oce18bthVXa6Bqh8Ux6fZMf2mQrIQcI,1109
+jugaadcode/insertion_sort.py,sha256=tiycgtt9p2w533VY9h3zcizbAqNYfXrSGwkWpKRsABQ,470
+jugaadcode/kth_largest.py,sha256=1aPTTO9J-pafz_B8stNy3TNR0qNWjRR_GocRDFvgI-w,401
+jugaadcode/lcm.py,sha256=lkhIVwhTMwoEVDoJ4MlVnrmKGAsxHDthd0mQE-OFAbk,328
+jugaadcode/linear_search.py,sha256=2A6yf_NN0Q-4eIJcGB_Dg20AKCCvu1uB1UAMVsADKUI,380
+jugaadcode/longest_consecutive.py,sha256=OWazmdH5OAdSiANWa4gPJGP6d_TbwiG0-XMw2bNQcDw,519
+jugaadcode/longest_word.py,sha256=yPJuOqNhKZyi1zdg9PdE_o6TWmUqcVp-wCn6Iro2EKU,334
+jugaadcode/matrix_transpose.py,sha256=R38kpJzBflRqQ8Zq444-2zCYpT-mo6P_8N-jiq04Zpg,866
+jugaadcode/maximum_subarray.py,sha256=LQTO6CE7HpaRpUiWA7EvLIXc2b9yFkl01yiqea9cyTI,525
+jugaadcode/merge_sort.py,sha256=SZUCsV8miXkmIH5rCjX5YNczQJuJCASFpwxuRx-07ao,681
+jugaadcode/move_zeros.py,sha256=BKN4vOu6_oEWeSroFPwWEnBG7JvphWcRMceGHwx08EU,405
+jugaadcode/pair_with_difference.py,sha256=EwvSnDbbdWGso8Uj_-8pEwDisM4QypNgA-3HypGkbFA,557
+jugaadcode/palindrome.py,sha256=-EcNGf0xMgX82YKSlr2h6bdIOxl8qWw3NmouSqY-aLQ,198
+jugaadcode/perfect_number.py,sha256=5oBtVOzjShTGbvFnNuPVx2Wma8GDyqW5RvrJcZfMaDM,371
+jugaadcode/power.py,sha256=lostOgLGCEky0_xPAbZViCfSDyLBy542-F8tp4_wnEQ,339
+jugaadcode/prime.py,sha256=orxYVpbVbbKuuvrEuIiy4wJxqjGyJiONtAYpbrmWK1w,265
+jugaadcode/quick_sort.py,sha256=vRrPqxNEB9eMy0Q3OLGlpWwULCE2spa1qKJJaepZMfo,545
+jugaadcode/remove_duplicates_array.py,sha256=RYkzQMVZisziiGtJsBK4EMv7cTTYzkKORCiKNwYYRFo,316
+jugaadcode/remove_duplicates_string.py,sha256=kt7k-8EMi9s2EWspG1L6cqjgcQxgMdqyyvj9cZkaodo,287
+jugaadcode/reverse_linked_list.py,sha256=gppKEqvAJO_VkHBziTTJl6bCUMEbqQgMCgF1GnuAzWc,802
+jugaadcode/reverse_number.py,sha256=GjLpy5-f5SzK6q52F1TIG1HVKkQm4w8GGgS4svbJ3DU,180
+jugaadcode/reverse_string.py,sha256=jtFa4Vn10FKBDIcmJWkYuHuPdQgl5ucqUHAEr1zQFBg,132
+jugaadcode/second_largest.py,sha256=Zf-cJmLgUBOL3YCvBCOdSoLube3mXBpO7VYXn611XRo,599
+jugaadcode/selection_sort.py,sha256=f8dOcYhlWVI9Y3yz_1-7KFMVu-28_Qtk1m7a3CWGoBY,523
+jugaadcode/strong_number.py,sha256=rd9ut2wVqNawu7rk9MeA0NSUo5xAdWjxJrJiaiArU-Y,265
+jugaadcode/subsequence.py,sha256=viddNeuducpo2YGbNCCbQKGOyRtwumQP3Nk3IyWSXYs,404
+jugaadcode/sum_of_digits.py,sha256=PqMzKNVRgbsAvtvgcaPjwlPvU6N0oMxZe2dGovUWN6s,181
+jugaadcode/trailing_zeros.py,sha256=uPrtifh7gTyXVBrLyAFj7hwxWeTJJq85Y9yApNp_N3A,258
+jugaadcode/two_sum.py,sha256=gNMy1at4BAbq4YX56c8UcV6BXKAv8uHzcV8ySnjCbEM,485
+jugaadcode/valid_parentheses.py,sha256=ywUHhFO-vfC4QfaPgAytGc1GwWEovuTI0xszep-Ny1Y,506
+jugaadcode/word_count.py,sha256=eQ7O-XV3WpARl7hypOTxtZ2iT7yZYM0VcH9qWCYX5AQ,144
+jugaadcode-0.1.0.dist-info/METADATA,sha256=f4Ql2d5L0eYRFdP1gTqNeuAshGGaY5A-FPoQGXa51Po,397
+jugaadcode-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+jugaadcode-0.1.0.dist-info/top_level.txt,sha256=tZAqQKzT4GRpJ3majHjIOElT5YbnzmSMv-VRM8ajQlY,11
+jugaadcode-0.1.0.dist-info/RECORD,,

jugaadcode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jugaadcode-0.1.0.dist-info/top_level.txt

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