DEV Community: Peter Muthama

Advanced Array Manipulation Techniques in Python

Peter Muthama — Thu, 15 May 2025 13:35:38 +0000

In today’s blog, we will look at more advanced methods of manipulating arrays in Python without using any inbuilt functions or shortcuts like reversed() or slicing. These problems will help you understand the logic behind common operations and improve your problem-solving skills.

Problem One: Reverse an Array In-Place

Problem

You are given an array of n integers. Your task is to reverse the array without using any additional lists or the built-in reversed() function.

Amend the array in-place, which means you are not allowed to use any additional lists in your solution.

Breakdown

We are required to reverse the array in-place. This means we’ll need to use two pointers:

One starting from the left, and one from the right.
We swap the values at those positions.
As long as left is less than right, we continue swapping.
We do this until the array is fully reversed.

Code

def solution(arr):
    left = 0
    right = len(arr) - 1

    while left < right:
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1
    return arr

Example

print(solution([1, 2, 3, 4, 5]))  # Output: [5, 4, 3, 2, 1]

Problem Two: Rotate an Array Anti-Clockwise by `k` Steps

Problem

You are provided with an array of n integers and a number k. Your task is to perform an anti-clockwise rotation (towards the front) of the array by k positions. The rotation should be done in-place, which means you have to directly manipulate the input array without creating a new one.

Note: k might be bigger than the array length.

For example, if the input array is [1, 2, 3, 4, 5, 6, 7] and k = 3, then after the operation, the array should look like [4, 5, 6, 7, 1, 2, 3].

Breakdown

Since rotating the array by its length results in the same array, you can take k % n (modulo) to handle cases where k is greater than the array length.
To rotate the array anti-clockwise, we use reversal in three steps:

Reverse the entire array.
Reverse the first n - k elements.
Reverse the last k elements.

Code

def anti_rotate_array(nums, k):
    n = len(nums)
    k = k % n
    if k == 0:
        return nums

    def reverse(left, right):
        while left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1

    reverse(0, n - 1)
    reverse(0, n - k - 1)
    reverse(n - k, n - 1)
    return nums

Example

print(anti_rotate_array([1, 2, 3, 4, 5, 6, 7], 3))  
# Output: [4, 5, 6, 7, 1, 2, 3]

Finding the Row Containing a Target in a Sorted Matrix in Python

Peter Muthama — Mon, 12 May 2025 19:00:10 +0000

In this problem, you're given a matrix of integers where each row and each column is sorted in ascending order. The goal is to find the index of the row that contains a specific target value. If the target value is not found in the matrix, return None.

This is a common matrix problem that can be solved efficiently by taking advantage of the sorted structure. Instead of checking each cell (which would take O(n × m) time), you can reduce the complexity to O(n + m), where n is the number of rows and m is the number of columns.

Problem Approach

We make use of the matrix's properties—namely that values increase as we move right and down, and decrease as we move left and up.

Steps:

Start from the top-right corner of the matrix.
Use a loop to traverse the matrix:

If the current value equals the target, return the current row index.
If the current value is greater than the target, move left.
If the current value is less than the target, move down.
1. If the loop completes without finding the target, return None.

Python Implementation

def find_row_with_target(matrix, target):
    if not matrix or not matrix[0]:
        return None  # Matrix is empty

    n = len(matrix)       # Number of rows
    m = len(matrix[0])    # Number of columns

    # Start at the top-right corner
    row, col = 0, m - 1

    while row < n and col >= 0:
        if matrix[row][col] == target:
            return row  # Target found
        elif matrix[row][col] > target:
            col -= 1  # Move left
        else:
            row += 1  # Move down

    return None  # Target not found

Example Usage

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]

print(find_row_with_target(matrix, 7))   # Output: 1
print(find_row_with_target(matrix, 13))  # Output: None

Conclusion

This solution demonstrates how understanding data structure properties can lead to more efficient algorithms. Instead of brute-force search, a directional approach through the matrix takes full advantage of the sorted nature, resulting in a linear time complexity relative to the dimensions of the matrix.

Matrix Pattern Challenges in Python (With Optimized Solutions!)

Peter Muthama — Fri, 09 May 2025 18:23:54 +0000

Matrices can hide surprisingly elegant patterns—especially when paired with recursion-style thinking and efficient algorithms. In this post, we'll explore two fun matrix problems that test your logic and help you master matrix traversal techniques!

Problem One: Count Values Less Than Target

Problem

You’re given a matrix where:

Each row is sorted in ascending order
Each column is also sorted in ascending order

Your task? Write a function that counts how many elements are smaller than a given target. And yes—you need to do this in O(n + m) time.

Strategy

Start from the top-right corner.
If the current value is less than the target, everything to the left in that row is also smaller. So, count them all and move down.
If the current value is greater than or equal to the target, move left to find smaller numbers.
Keep doing this until you fall off the matrix.

Python Solution

def count_less_than(matrix, target):
    if not matrix or not matrix[0]:
        return 0

    n = len(matrix)
    m = len(matrix[0])
    count = 0

    row = 0
    col = m - 1

    while row < n and col >= 0:
        if matrix[row][col] < target:
            count += (col + 1)
            row += 1
        else:
            col -= 1

    return count

Test It!

matrix = [
    [1, 2, 3, 4],
    [2, 3, 4, 5],
    [3, 4, 5, 6],
    [4, 5, 6, 7]
]

print(count_less_than(matrix, 5))  # Output: 10

This counts all the values less than 5, giving you the result 10.

Problem Two: Min & Max of the Secondary Diagonal

Problem

Given a square matrix, find the minimum and maximum values along the secondary diagonal, which goes from the top-right to bottom-left.

Example:

Secondary Diagonal
→       3
    →   6
        → 9

Strategy

If the matrix is empty, return [None, None].
For each i from 0 to n-1, the secondary diagonal element is at index [i][n - 1 - i].
Track the min and max values as you traverse.

Python Solution

def solution(grid):
    if not grid:
        return [None, None]

    n = len(grid)
    if n == 0:
        return [None, None]

    min_value = float('inf')
    max_value = float('-inf')

    for i in range(n):
        secondary_diagonal_value = grid[i][n - 1 - i]
        min_value = min(min_value, secondary_diagonal_value)
        max_value = max(max_value, secondary_diagonal_value)

    return [min_value, max_value]

Test It!

grid = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(solution(grid))  # Output: [3, 7]

Recap

The first problem uses greedy scanning from the top-right to quickly count qualifying values.
The second one is a diagonal extraction that leverages fixed index logic for a fast O(n) solution.

These are great examples of how sorted structure + smart traversal leads to high-performance solutions.

Matrix in Python

Peter Muthama — Wed, 07 May 2025 17:49:55 +0000

Problem 1: Check for a Toeplitz Matrix

Problem:

You are given an n x n square matrix. Write a function is_toeplitz(matrix) that checks whether the matrix is a Toeplitz matrix.

A Toeplitz matrix is one where every descending diagonal from top-left to bottom-right (↘️) contains the same elements.

Example:

Consider this matrix:

6 7 8
4 6 7
1 4 6

The diagonals are:

[1],
[4, 4],
[6, 6, 6],
[7, 7],
[8]

All elements in each diagonal are equal — so this is a Toeplitz matrix ✅.

Breakdown:

To check if a matrix is Toeplitz:

Loop through each element in the matrix (excluding the last row and column).
For each element, compare it with the one diagonally down-right from it.
If any of those pairs don’t match, return False.
If the loop completes without mismatches, return True.

Python Solution:

from typing import List

def is_toeplitz(matrix: List[List[int]]) -> bool:
    n = len(matrix)

    for i in range(n):
        for j in range(n):
            if i + 1 < n and j + 1 < n:
                if matrix[i][j] != matrix[i + 1][j + 1]:
                    return False

    return True

Test It:

matrix = [
    [6, 7, 8],
    [4, 6, 7],
    [1, 4, 6]
]

print(is_toeplitz(matrix))  # Output: True

Understanding Recursion in Python: A Beginner-Friendly Guide Part 2

Peter Muthama — Tue, 06 May 2025 17:48:44 +0000

Today, we'll walk through some fun and practical examples of more recursion in Python, all without using any built-in shortcuts or helper functions.

Problem 1: Reverse a String Using Recursion

Problem:

Write a function reverse_string(s) that returns the reversed version of string s.

Breakdown:

If the string is empty or has one character, return it.
Otherwise, take the last character and append it to the reversed substring.

Solution:

def reverse_string(s):
    if len(s) <= 1:
        return s
    else:
        return s[-1] + reverse_string(s[:-1])

Example:

reverse_string("hello")  # Output: "olleh"

Problem 2: Fibonacci with Memoization (O(n) Time)

Problem:

Return the nth Fibonacci number using recursion with memoization to improve performance.

Breakdown:

Use a helper function with a memo dictionary.
Cache results to avoid redundant calculations.

Solution:

def fibonacci(n: int) -> int:
    memo = {}

    def fib_helper(n: int) -> int:
        if n in memo:
            return memo[n]
        if n == 0:
            return 0
        elif n == 1:
            return 1

        memo[n] = fib_helper(n - 1) + fib_helper(n - 2)
        return memo[n]

    return fib_helper(n)

Example:

fibonacci(7)  # Output: 13

Final Thoughts

Recursion teaches us to think differently, breaking down problems into smaller chunks until we reach a base case. While it's tempting to lean on built-in functions, solving problems recursively helps build a deeper understanding of logic and control flow.

Try these problems out yourself, tweak them, and challenge yourself to come up with variations. Recursion might just become your favorite problem-solving tool!

Understanding Recursion in Python — 3 Beginner-Friendly Problems

Peter Muthama — Mon, 05 May 2025 12:56:43 +0000

Recursion is a powerful technique where a function calls itself to solve smaller instances of a problem. Today, we'll explore three classic recursive problems, breaking each down step-by-step to build your confidence in using recursion effectively.

Problem One: Sum from `n` to `1`

Task: Create a function get_sum(n) that returns the sum of all integers from n to 1.

Example:
get_sum(5) ➝ 15 (because 5 + 4 + 3 + 2 + 1 = 15)
get_sum(1) ➝ 1

Breakdown:

Base case: If n == 1, return 1.
Recursive step: Return n + get_sum(n - 1) until n reaches 1.

def get_sum(n):
    if n == 1:
        return 1
    else:
        return n + get_sum(n - 1)

Problem Two: Countdown List using Recursion

Task: Write a recursive function solution(n) that returns a list of integers from n down to 1.

Example:
solution(5) ➝ [5, 4, 3, 2, 1]

🧠 Breakdown:

Base case: If n == 0, return an empty list.
Recursive step: Return [n] + solution(n - 1)

def solution(n):
    if n == 0:
        return []
    else:
        return [n] + solution(n - 1)

Problem Three: Sum of Digits Raised to Their Position

Task: Given a positive integer n, return the sum of each digit raised to the power of its position (starting from the right, 1-indexed). Use recursion.

Example:
solution(123) ➝ 3¹ + 2² + 1³ = 3 + 4 + 1 = 8

Breakdown:

Base case: If n == 0, return 0.
Step:
- Extract the last digit using n % 10.
- Remove the digit using n // 10.
- Add (last_digit ** position) to the recursive result.

def solution(n, pos=1):
    if n == 0:
        return 0

    last_digit = n % 10
    n //= 10

    return (last_digit ** pos) + solution(n, pos + 1)

Conclusion

Each of these examples shows how recursion breaks down complex problems into simpler sub-problems.

List Operations without in built formular's in Python

Peter Muthama — Sat, 03 May 2025 14:17:45 +0000

In today’s blog, we’ll walk through three common list operations that are often solved using Python’s built-in methods—but this time, we’ll solve them from scratch. This approach is especially useful for improving your algorithmic thinking and mastering the fundamentals.

Problem One: Reverse a List

You are given a list of n integers. Your task is to return a reversed list, without using any built-in Python functions or methods related to reversing.

Breakdown

Initialize an empty list to store the reversed elements.
Iterate over the original list in reverse order using index manipulation.
Append each element to the new list.
Return the new list.

def reverse_list(numbers):
    reversed_list = []

    for i in range(len(numbers) - 1, -1, -1):
        reversed_list.append(numbers[i])

    return reversed_list

Problem Two: Circular Shift Elements

Given a list of n integers and an integer shift, return the list after shifting each element right (positive shift) or left (negative shift), circularly.

Breakdown

Normalize the shift using shift = shift % n to keep it within bounds.
Initialize a new list with the same length.
Loop through the original list and compute the new index using (i + shift) % n.
Assign the value from the old list to its new position in the new list.
Return the shifted list.

def shift_list_elements(ls, shift):
    n = len(ls)
    if n == 0:
        return []

    shift = shift % n
    shifted_list = [0] * n

    for i in range(n):
        new_pos = (i + shift) % n
        shifted_list[new_pos] = ls[i]

    return shifted_list

Problem Three: Check for Contiguous Sublist

You are given two lists of integers, listA and listB. Determine if listB is a contiguous sublist of listA.

Breakdown

If listB is longer than listA, return False.
Loop through listA, only up to where listB can possibly fit.
For each start index, check if every element in listB matches the corresponding elements in listA.
Return True if a full match is found; otherwise, return False.

def is_contiguous_sublist(listA, listB):
    lenA = len(listA)
    lenB = len(listB)

    if lenB > lenA:
        return False

    for i in range(lenA - lenB + 1):
        match_found = True

        for j in range(lenB):
            if listA[i + j] != listB[j]:
                match_found = False
                break

        if match_found:
            return True

    return False

Each of these problems helps reinforce core concepts in indexing, iteration, and logic building, without depending on Python's built-ins. Try them out and consider how you might further optimize these for large datasets or edge cases!

How to Perform List Operations in Python Without Built-in Methods

Peter Muthama — Fri, 02 May 2025 09:47:01 +0000

In today’s blog, let’s explore how to perform common list operations in Python without using any built-in methods such as .index() or set(). These exercises are great for sharpening your understanding of how things work under the hood.

Problem One: Find the First Index of a Value

You are given a list of n integers. Your task is to find the zero-based index of the first occurrence of a specific value in the list. If the value isn’t found, return -1.

Constraint:

You cannot use the built-in .index() method.

Breakdown:

Loop through the list using indices (for i in range(len(lst))).
At each step, check if the current element equals the value.
If it does, return the current index.
If the loop ends without finding the value, return -1.

def find_first_index(lst, val):
    for i in range(len(lst)):  # we check every index manually
        if lst[i] == val:
            return i
    return -1

Example:

print(find_first_index([5, 3, 7, 3, 9], 3))  # Output: 1
print(find_first_index([1, 2, 3], 4))        # Output: -1

Problem Two: Count Unique Elements

You are given a list of integers. Return the number of elements that appear only once in the list.

Constraint:

No use of set(), collections.Counter(), or any built-in helper functions.

Breakdown:

Initialize a unique_count to keep track of how many unique elements we find.
Loop through each element i in the list.
For each i, run an inner loop j to count how many times lst[i] == lst[j].
If the count is exactly 1, increment unique_count.

def count_unique_elements(lst):
    unique_count = 0

    for i in range(len(lst)):
        count = 0
        for j in range(len(lst)):
            if lst[i] == lst[j]:
                count += 1
        if count == 1:
            unique_count += 1

    return unique_count

Example:

print(count_unique_elements([1, 2, 3, 2, 4]))  # Output: 3 (1, 3, 4 are unique)
print(count_unique_elements([1, 1, 1, 1]))     # Output: 0

Why This Matters:

Avoiding built-in methods helps you build stronger algorithmic thinking and gives you a deeper appreciation of what’s going on behind the scenes in Python.

More Math Algorithms in Python Without Libraries

Peter Muthama — Thu, 01 May 2025 15:48:39 +0000

In today's post, we're diving into two classic number theory problems that strengthen your grasp of math logic using plain Python—no math, numpy, or sympy.

Problem 1: Get All Unique Prime Factors of an Integer

Create a Python function called get_prime_factors(n) that returns all unique prime factors of an integer n in a sorted list. Do not use built-in libraries. Assume time complexity around O(n).

Breakdown:

If n <= 1, return an empty list (no factors).
First, handle the even number case (2) explicitly.
Then, check odd numbers up to the square root of n.
Any number remaining after that loop is a prime factor.
Use a custom sort (without sorted() or sort()) to return factors in ascending order.

Solution:

def get_prime_factors(n):
    if n <= 1:
        return []

    prime_factors = []

    if n % 2 == 0:
        prime_factors.append(2)
        while n % 2 == 0:
            n //= 2

    for i in range(3, int(n**0.5) + 1, 2):
        if n % i == 0:
            prime_factors.append(i)
            while n % i == 0:
                n //= i

    if n > 2:
        prime_factors.append(n)

    # Manual sorting (selection sort style)
    sorted_prime_factors = []
    while prime_factors:
        min_value = prime_factors[0]
        for value in prime_factors:
            if value < min_value:
                min_value = value
        sorted_prime_factors.append(min_value)
        prime_factors = [value for value in prime_factors if value != min_value]

    return sorted_prime_factors

    pass

Problem 2: Check If Two Numbers Are Co-Prime

You are given two integers a and b. Write a function are_coprime(a, b) that returns True if they are co-prime, i.e., their greatest common divisor (GCD) is 1. Do not use built-in libraries.

Breakdown:

Use the classic Euclidean algorithm to compute the GCD manually.
Two numbers are co-prime if gcd(a, b) == 1.
Handle edge cases like negative or zero inputs.

Solution:

def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

def are_coprime(a, b):
    if a <= 0 or b <= 0:
        return False
    return gcd(a, b) == 1

    pass

These examples show how to build up number-theoretic algorithms from scratch. Practicing such problems sharpens your algorithmic reasoning and boosts your confidence for interviews and real-world coding alike!

Maths Algorithms in Python Without Libraries (No math, pandas, or matplotlib)

Peter Muthama — Wed, 30 Apr 2025 13:57:55 +0000

In today's blog, we'll explore how to implement fundamental math algorithms in Python without using any external libraries like math, pandas, or matplotlib.

This kind of practice helps sharpen your core algorithmic thinking and improves your confidence when solving coding problems, especially in interviews or constrained environments.

Problem One: Check for Perfect Square

Task:

You are given an integer n. Your goal is to determine if n is a perfect square.

A perfect square is a number that is the product of an integer with itself. For example:

✅ 1 = 1 × 1

✅ 4 = 2 × 2

✅ 9 = 3 × 3

❌ 2, 3, 5 are not perfect squares

✅ Approach:

Handle edge cases:
- If n < 0, it's not a perfect square.
- If n is 0 or 1, it's automatically a perfect square.
Loop from 1 to n // 2 and check:
- If i * i == n, return True.
- If i * i > n, stop early and return False.

Code:

def is_perfect_square(n):
    if n < 0:
        return False
    if n == 0 or n == 1:
        return True

    for i in range(1, n // 2 + 1):
        if i * i == n:
            return True
        elif i * i > n:
            break

    return False

Problem Two: Find the Next Prime Number

Task:

Write a function next_prime(n) that returns the smallest prime number strictly greater than n.

A prime number is only divisible by 1 and itself (e.g., 2, 3, 5, 7, 11...).

Approach:

Create a helper function is_prime(num):
- Return False if num < 2.
- Check divisibility from 2 to √num.
In the next_prime function:
- Start from n + 1.
- Keep incrementing until you find a number where is_prime() returns True.

Code:

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def next_prime(n):
    next_p = n + 1
    while True:
        if is_prime(next_p):
            return next_p
        next_p += 1

Practicing these foundational problems without built-in tools builds your problem-solving muscles and makes you a more versatile developer.

Master Basic List Operations in Python Without Using Built-in Methods in Python (Part 2)

Peter Muthama — Tue, 29 Apr 2025 08:59:14 +0000

In this part of the series, we continue exploring how to work with lists in Python without relying on built-in functions. These kinds of exercises are great for building strong problem-solving skills and a deeper understanding of data structures and algorithms.

Problem One: Count the Frequency of the Smallest Element

Task: You are given an array of integers. Write a function that returns the number of times the smallest element appears in the array.

Note: Do not use min() or count(). Try to solve this with a single list traversal.

Breakdown:

If the list is empty, return 0.
Initialize the smallest value with float('inf') and set a counter to 0.
Traverse the list:
- If the current number is smaller than the smallest, update the smallest and reset the counter to 1.
- If it's equal to the smallest, increment the counter.

def count_min(numbers):
    if not numbers:
        return 0

    smallest = float('inf')
    count = 0

    for num in numbers:
        if num < smallest:
            smallest = num
            count = 1
        elif num == smallest:
            count += 1

    return count

Problem Two: Find the Second Largest Number

Task: You are given a list of integers. Write a function that returns the second-largest number.

If there are fewer than two unique numbers, return None.

Breakdown:

First, check if the list has at least two numbers. If not, return None.
Initialize largest and second_max to float('-inf').
Loop through the numbers:
- If the number is greater than largest, update second_max to largest, then update largest.
- If the number is greater than second_max and not equal to largest, update second_max.
If second_max is still -inf, return None.

def second_max(nums):
    if len(nums) < 2:
        return None

    largest = float('-inf')
    second_max = float('-inf')

    for num in nums:
        if num > largest:
            second_max = largest
            largest = num
        elif num > second_max and num != largest:
            second_max = num

    if second_max == float('-inf'):
        return None

    return second_max

Final Thoughts

Mastering these kinds of operations without relying on Python’s built-ins forces you to think like a computer and truly understand how things work under the hood. This knowledge becomes invaluable when working on more complex applications or preparing for coding interviews.

Master Basic List Operations in Python — Without Using Built-in Methods in Python (Part 1)

Peter Muthama — Mon, 28 Apr 2025 09:48:23 +0000

In today’s post, we dive into performing basic list operations without using built-in Python methods.

Exercises like these help build strong problem-solving skills and deepen your understanding of Data Structures and Algorithms (DSA).

Problem 1: Find the Minimum Value in a List

Problem

You are given a list of integers. Write a function find_min(nums) that returns the minimum number from the list without using Python’s built-in min() function.

If the list is empty, return None.

Breakdown:

First, we need a way to keep track of the minimum value. We initialize a variable to the first element:

  min_value = nums[0]

Then, loop through the list. For each number, if it is smaller than our current min_value, we update min_value.
If the list is empty, return None immediately.

Full Solution:

def find_min(nums):
    if not nums:
        return None

    min_value = nums[0]

    for num in nums:
        if num < min_value:
            min_value = num
    return min_value

Problem 2: Count Even and Odd Numbers

Problem

You are given a list of integers. Return a tuple (even_count, odd_count)

where even_count is the number of even integers, and odd_count is the number of odd integers.

Do not use any built-in Python methods like filter(), count(), etc.

Breakdown:

Initialize two counters:

  even_count = 0
  odd_count = 0

Loop through each number:
- If num % 2 == 0, it’s even → increment even_count.
- Otherwise, it’s odd → increment odd_count.
Finally, return a tuple (even_count, odd_count).

Full Solution:

def count_even_odd(nums):
    even_count = 0
    odd_count = 0

    for num in nums:
        if num % 2 == 0:
            even_count += 1
        else:
            odd_count += 1

    return (even_count, odd_count)

Final Thoughts

This marks the first part of practicing basic list operations without built-in functions.

Stay tuned and keep practicing — mastering these basics will give you a huge advantage in both coding interviews and real-world problem solving!

"If you enjoyed this, follow me for more posts on Python, DSA, and practical coding exercises!"

DEV Community: Peter Muthama

Advanced Array Manipulation Techniques in Python

Problem One: Reverse an Array In-Place

Problem

Breakdown

Code

Example

Problem Two: Rotate an Array Anti-Clockwise by k Steps

Problem

Breakdown

Code

Example

Finding the Row Containing a Target in a Sorted Matrix in Python

Problem Approach

Steps:

Python Implementation

Example Usage

Conclusion

Matrix Pattern Challenges in Python (With Optimized Solutions!)

Problem One: Count Values Less Than Target

Problem

Strategy

Python Solution

Test It!

Problem Two: Min & Max of the Secondary Diagonal

Problem

Strategy

Python Solution

Test It!

Recap

Matrix in Python

Problem 1: Check for a Toeplitz Matrix

Problem:

Example:

Breakdown:

Python Solution:

Test It:

Understanding Recursion in Python: A Beginner-Friendly Guide Part 2

Problem 1: Reverse a String Using Recursion

Problem:

Breakdown:

Solution:

Example:

Problem 2: Fibonacci with Memoization (O(n) Time)

Problem:

Breakdown:

Solution:

Example:

Final Thoughts

Understanding Recursion in Python — 3 Beginner-Friendly Problems

Problem One: Sum from n to 1

Breakdown:

Problem Two: Countdown List using Recursion

🧠 Breakdown:

Problem Three: Sum of Digits Raised to Their Position

Breakdown:

Conclusion

List Operations without in built formular's in Python

Problem One: Reverse a List

Breakdown

Problem Two: Circular Shift Elements

Breakdown

Problem Three: Check for Contiguous Sublist

Breakdown

How to Perform List Operations in Python Without Built-in Methods

Problem One: Find the First Index of a Value

Constraint:

Breakdown:

Example:

Problem Two: Count Unique Elements

Constraint:

Breakdown:

Example:

Why This Matters:

More Math Algorithms in Python Without Libraries

Problem 1: Get All Unique Prime Factors of an Integer

Breakdown:

Solution:

Problem 2: Check If Two Numbers Are Co-Prime

Breakdown:

Problem Two: Rotate an Array Anti-Clockwise by `k` Steps

Problem One: Sum from `n` to `1`