DEV Community: Samantha Vincent

IP adresses and Subnets

Samantha Vincent — Mon, 30 Mar 2026 18:41:16 +0000

IP ADDRESS

In real life, let's say you want to find a place or you want to reach a place you need to know the location or precisely the address of that place. Similarly in computers IP address is used to know or denote a particular computer that is connected under the same network. Basically, every node(device) connected under the same network has a unique address known as IP address.

Example of an IP address: 10.1.32.12
Each part has 8 bits and can store 0-255 values.

SUBNETS

In a large network, communication between different devices take too much time or is unnecessary. Here, Subnets helps separate or breakdown the network into different parts so that communication is easier and not unnecessary. Imagine in a college it has one Public IP(large network) here we use subnets for each block or department so that communication in the department is fast and effective.

How Subnets and IP address work

Every IP belongs to a subnet. Subnets tell you the number of ip's or the the range of IP addresses that are available or fall under that subnet.
For example lets take an IP address: 192.168.1.10
There are always two parts in an IP address
-Network
-Host
Here 192.168.1 is network and 10 denotes host.

To know how many IP's are stored for networks and host we use a method called CIDR(Classless Inter Domain Routing).
CIDR helps us to know how many devices one can connect under a subnet in an IP. The notation for CIDR is a.b.c.d/n

Example: 10.1.32.12/24
Here, /24 means 256 devices can be connected and is stored for networks.

Sorting Algorithms

Samantha Vincent — Sun, 22 Mar 2026 17:39:22 +0000

Sorting Algorithms

A sorting algorithm is a way to arrange elements of an array in a specific order, usually ascending or descending. It helps in organizing data so that other operations like searching and processing become easier and faster.

Sorting algorithms may look similar at first, but each one follows a different idea. Understanding how they work with small examples makes them easier to grasp.

Merge Sort

Merge Sort divides the array into smaller parts and then merges them back in sorted order.

It keeps splitting the array until each part has one element. Then it starts merging them step by step in a sorted way.

Example:
[4, 2, 1, 3]

Split [4, 2] and [1, 3]
Split again [4] [2] [1] [3]
Merge [2, 4] and [1, 3]
Final merge [1, 2, 3, 4]

Key Points:

Uses divide and conquer
Always O(n log n)
Uses extra space for merging

Quick Sort

Quick Sort picks a pivot and places it in the correct position.

Then it rearranges the array so that smaller elements are on the left and larger ones are on the right. The same process is repeated recursively.

Example:
[4, 2, 5, 1, 3]

Pick pivot = 3
Left [2, 1], Right [4, 5]
Sort both sides [1, 2] and [4, 5]
Final [1, 2, 3, 4, 5]

Key Points:

Very fast in practice
Average time O(n log n)
Worst case O(n²) if pivot is bad
In-place (no extra space needed)

Heap Sort

Heap Sort first builds a max heap and then extracts elements one by one.

A max heap ensures the largest element is always at the top. We swap it with the last element and reduce the heap size.

Example:
[4, 1, 3, 2]

Build max heap [4, 2, 3, 1]
Remove 4 [1, 2, 3] → heapify → [3, 2, 1]
Remove 3 [1, 2] → heapify → [2, 1]
Final [1, 2, 3, 4]

Key Points:

Time complexity O(n log n)
No extra space required
Not stable

Counting Sort

Counting Sort counts occurrences of each number instead of comparing elements.

It works best when the range of numbers is small.

Example:
[2, 1, 2, 0, 1]

Count 0:1, 1:2, 2:2
Rebuild [0, 1, 1, 2, 2]

Key Points:

Time complexity O(n + k)
Very fast for small ranges
Not comparison-based
Uses extra space

Conclusion

Each algorithm uses a different idea:

Merge Sort - divide and merge
Quick Sort - partition around pivot
Heap Sort - use heap structure
Counting Sort - count frequencies

Knowing these patterns helps in choosing the right approach.

Reverse the array

Samantha Vincent — Sun, 22 Mar 2026 17:27:35 +0000

Problem

You’re given an array of integers and need to reverse the array in-place.

Strategy

At first, it feels like you can just use a built-in reverse function.

But since we need to do it in-place, I thought about it differently:

What if I swap elements from both ends?

So I use two pointers:

One at the start
One at the end

Then keep swapping them and move inward.

Code

class Solution:
    def reverseArray(self, arr):
        left = 0
        right = len(arr) - 1

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

Key Lines Explained

arr[left], arr[right] = arr[right], arr[left]
Swaps the elements at the start and end.

left += 1 and right -= 1
Moves both pointers towards the center.

Why This Works

We’re just swapping elements from opposite ends:

First with last
Second with second last
And so on

By the time pointers meet, the array is reversed.

Complexity

Time: O(n)
Space: O(1)

Final Note

This is a simple two-pointer problem.

Instead of creating a new array, just swap elements in-place to reverse it efficiently.

Find the Maximum and Minimum Element in the Array

Samantha Vincent — Sun, 22 Mar 2026 17:23:39 +0000

Problem

You’re given an array of integers and need to find the minimum and maximum elements.

Strategy

At first, it feels like sorting the array will help.

But we don’t really need to sort just to find min and max.

So I kept it simple:

For each number, I check—

Is it smaller than the current minimum?
Is it bigger than the current maximum?

And update accordingly.

Code

class Solution:
    def getMinMax(self, arr):
        minimum = arr[0]
        maximum = arr[0]

        for num in arr:
            if num < minimum:
                minimum = num
            if num > maximum:
                maximum = num

        return [minimum, maximum]

Key Lines Explained

if num < minimum:
Update the minimum when we find a smaller number.

if num > maximum:
Update the maximum when we find a bigger number.

Why This Works

We just keep track of two things while looping:

Smallest number so far
Largest number so far

No need to rearrange anything.

Complexity

Time: O(n)
Space: O(1)

Final Note

This problem is very straightforward.

Instead of doing extra work like sorting, just compare and update as you go.

Kth Smallest

Samantha Vincent — Sun, 22 Mar 2026 17:20:48 +0000

Kth Smallest Element

Problem

You’re given an array of integers and an integer k, and need to find the kth smallest element in the array.

Strategy

At first, it feels like you need something complex to track the kth element.

But since the kth smallest element is based on sorted order, I thought about it differently:

What if I just sort the array first?

So the idea is simple:

Sort the array
Return the element at index k - 1

Because indexing starts from 0.

Code

class Solution:
    def kthSmallest(self, arr, k):
        arr.sort()
        return arr[k - 1]

Key Lines Explained

arr.sort()
Sorts the array in ascending order.

return arr[k - 1]
Since arrays are 0-indexed, the kth smallest element will be at index k - 1.

Why This Works

Once the array is sorted:

Smallest element → index 0
2nd smallest → index 1
kth smallest → index k-1

So the answer becomes direct.

Complexity

Time: O(n log n)
Space: O(1)

Final Note

This is the most straightforward approach.

Even though there are more optimized solutions (like heaps or quickselect), sorting keeps it simple and easy to understand.

Sort 0s, 1s, and 2s

Samantha Vincent — Sun, 22 Mar 2026 17:16:52 +0000

Problem

You’re given an array of integers and need to sort an array containing only 0s, 1s, and 2s.

Strategy

At first, it feels like you can just sort the array or count frequencies.

But the follow-up asks for a one-pass solution with constant space.

Instead, I thought about it differently:
At each position, I asked—

Where should this element go?

So I used three pointers:

low for placing 0s
mid for traversal
high for placing 2s

So for every element:

If it’s 0 → move it to the front
If it’s 1 → leave it where it is
If it’s 2 → move it to the end

This way, everything gets sorted in a single pass.

Code

class Solution:
    def sort012(self, arr):
        low = 0
        mid = 0
        high = len(arr) - 1

        while mid <= high:
            if arr[mid] == 0:
                arr[low], arr[mid] = arr[mid], arr[low]
                low += 1
                mid += 1
            elif arr[mid] == 1:
                mid += 1
            else:
                arr[mid], arr[high] = arr[high], arr[mid]
                high -= 1

Key Lines Explained

if arr[mid] == 0:
Move 0 to the front by swapping with the low pointer.

elif arr[mid] == 1:
Already in the correct place, just move forward.

else:
Move 2 to the end by swapping with the high pointer.

Why This Works

We split the array into three parts:

Left side → all 0s
Middle → all 1s
Right side → all 2s

As we traverse, we keep adjusting these regions until the array is sorted.

Complexity

Time: O(n)
Space: O(1)

Final Note

This problem looks like a sorting problem, but it’s really about placing elements in the right region.

Once you think in terms of positions instead of sorting, the one-pass solution becomes clear.

Move All Negative Elements to End

Samantha Vincent — Sun, 22 Mar 2026 17:10:36 +0000

Problem

You’re given an array of integers and need to move all negative elements to the end while maintaining the order of elements.

Strategy

At first, it feels like you can just swap elements in-place.

But that quickly gets messy, especially if you want to preserve the order.

Instead, I thought about it differently:
At each element, I asked—

Is it positive or negative?

So for every element:

If it’s positive, keep it in one list
If it’s negative, keep it in another list

This way, I can process the array in one pass and rebuild it.

Code

class Solution:
    def segregateElements(self, arr):
        positives = []
        negatives = []

        for num in arr:
            if num >= 0:
                positives.append(num)
            else:
                negatives.append(num)

        i = 0
        for num in positives:
            arr[i] = num
            i += 1
        for num in negatives:
            arr[i] = num
            i += 1

Key Lines Explained

current_sum = max(arr[i], current_sum + arr[i])

This line doesn’t apply here, but the key idea is similar—making a decision at each step.

Here, the decision is simply whether the number is positive or negative.

Why This Works

If we try to rearrange elements directly, we might break the order.

By separating them first:

We preserve order
We keep the logic simple
Then we combine them back

Complexity

Time: O(n)
Space: O(n)

Final Note

This problem looks like it needs tricky in-place operations, but it doesn’t.

Once you focus on separating elements instead of rearranging them during traversal, the solution becomes much simpler.

Kadanes Algorithm

Samantha Vincent — Sun, 22 Mar 2026 17:03:58 +0000

Problem

You’re given an array of integers and need to find the maximum sum of any contiguous subarray.

Strategy

At first, it feels like you need to check every possible subarray.

But that quickly becomes too slow.

Instead, I thought about it differently:
At each position, I asked—

Is it better to continue the current subarray, or start fresh from here?

So for every element:

Either extend the current sum
Or start a new subarray from that element

This way, I only pass through the array once.

Code

class Solution:
    def maxSubArray(self, arr):
        current_sum = arr[0]
        max_sum = arr[0]

        for i in range(1, len(arr)):
            current_sum = max(arr[i], current_sum + arr[i])
            max_sum = max(max_sum, current_sum)

        return max_sum

Key Lines Explained

`current_sum = max(arr[i], current_sum + arr[i])`

This decides whether to:

Continue the current subarray
Or start a new one

`max_sum = max(max_sum, current_sum)`

Keeps track of the maximum sum seen so far.

Why This Works

If the current sum becomes negative, it won’t help in building a larger sum later.

So instead of carrying it forward, we reset and start from the current element.

Complexity

Time: O(n)
Space: O(1)

Final Note

This problem looks like it needs brute force, but it doesn’t.

Once you focus on making a decision at each step instead of looking at all possibilities, the solution becomes much simpler.

Kadanes Algorithm - P2

Samantha Vincent — Sun, 22 Mar 2026 16:52:22 +0000

Problem

You’re given an array of integers and need to find the maximum sum of any contiguous subarray.

Strategy

At first, it feels like you need to check every possible subarray.

But that quickly becomes too slow.

Instead, I thought about it differently:
At each position, I asked—

Is it better to continue the current subarray, or start fresh from here?

So for every element:

Either extend the current sum
Or start a new subarray from that element

This way, I only pass through the array once.

Code

class Solution:
    def maxSubArray(self, arr):
        current_sum = arr[0]
        max_sum = arr[0]

        for i in range(1, len(arr)):
            current_sum = max(arr[i], current_sum + arr[i])
            max_sum = max(max_sum, current_sum)

        return max_sum

Key Lines Explained

current_sum = max(arr[i], current_sum + arr[i])
This decides whether to:
- Continue the current subarray
- Or start a new one
max_sum = max(max_sum, current_sum)

Keeps track of the maximum sum seen so far.

Why This Works

If the current sum becomes negative, it won’t help in building a larger sum later.

So instead of carrying it forward, we reset and start from the current element.

Complexity

Time: O(n)
Space: O(1)

Final Note

This problem looks like it needs brute force, but it doesn’t.

Once you focus on making a decision at each step instead of looking at all possibilities, the solution becomes much simpler.

Next Permutation

Samantha Vincent — Sun, 22 Mar 2026 16:44:54 +0000

Next Permutation

Problem

Given an array, rearrange it into the next lexicographically greater permutation.
If no such permutation exists, rearrange it into the smallest possible order (sorted in ascending order).

The change has to be done in-place.

Strategy

At first, it feels like you need to generate all permutations and then pick the next one.

But that’s not practical.

Instead, I tried looking at the array from the right side.

Moving from right to left, find the first place where the order breaks
That’s the point where we can make a slightly bigger permutation
Swap it with the next larger element
Then reverse everything after it to make it as small as possible

So it becomes:
find where it breaks → swap → reverse

Code

class Solution:
    def nextPermutation(self, nums):
        n = len(nums)

        i = n - 2
        while i >= 0 and nums[i] >= nums[i + 1]:
            i -= 1

        if i >= 0:
            j = n - 1
            while nums[j] <= nums[i]:
                j -= 1
            nums[i], nums[j] = nums[j], nums[i]

        left, right = i + 1, n - 1
        while left < right:
            nums[left], nums[right] = nums[right], nums[left]
            left += 1
            right -= 1

Key Lines Explained

while i >= 0 and nums[i] >= nums[i+1]:
This finds the point where the sequence stops increasing from the right.
nums[i], nums[j] = nums[j], nums[i]
Swap with the next larger element to make the permutation just a bit bigger.
Reversing from i+1 to end
This ensures the remaining part is the smallest possible.

Why This Works

We’re not trying to create all permutations.

We’re just making the smallest possible change that results in a larger arrangement.

If that’s not possible (like in a completely decreasing array), we reset to the smallest order.

Complexity

Time: O(n)
Space: O(1)

Final Note

This problem doesn’t feel obvious at first.

But once you start looking at the array from the right and focus on where the order changes, the steps become clear and repeatable.

Move Zeros

Samantha Vincent — Sun, 22 Mar 2026 16:41:51 +0000

Move Zeroes

Problem

You’re given an array and need to move all 0s to the end, while keeping the order of the non-zero elements the same.

The catch is that it has to be done in-place.

Strategy

At first, it feels like you need to shift elements every time you see a zero.

But that quickly gets messy.

Instead, I focused on the non-zero elements:

Keep a position for where the next non-zero should go
Traverse the array once
Every time I see a non-zero, move it to that position

So instead of pushing zeros back, I’m just pulling non-zero elements forward.

Code

class Solution:
    def moveZeroes(self, nums):
        j = 0

        for i in range(len(nums)):
            if nums[i] != 0:
                nums[j], nums[i] = nums[i], nums[j]
                j += 1

Key Lines Explained

j = 0
This keeps track of where the next non-zero element should be placed.
if nums[i] != 0:
We only act when we find a non-zero value.
nums[j], nums[i] = nums[i], nums[j]
This moves the non-zero element forward without losing order.
j += 1
Move to the next position after placing a non-zero.

Why This Works

All non-zero elements are moved forward in the same order they appear.

Zeros are never explicitly moved — they just get pushed to the end as a result of the swaps.

Complexity

Time: O(n)
Space: O(1)

Final Note

This problem looks like it’s about zeros, but it’s actually about placing non-zero elements correctly.

Once that perspective shifts, the solution becomes straightforward.

Valid Anagram

Samantha Vincent — Sun, 22 Mar 2026 16:38:54 +0000

Valid Anagram

Problem

Given two strings s and t, check if t is an anagram of s.

An anagram means both strings contain the same characters with the same frequency, just arranged differently.

Strategy

The idea is simple:

Count how many times each character appears in s
Then try to “cancel out” those counts using t

If everything balances to zero, the strings are anagrams.

Code

class Solution:
    def isAnagram(self, s, t):
        if len(s) != len(t):
            return False

        count = {}

        for ch in s:
            count[ch] = count.get(ch, 0) + 1

        for ch in t:
            if ch not in count or count[ch] == 0:
                return False
            count[ch] -= 1

        return True

Key Lines Explained

if len(s) != len(t):
If lengths differ, they can’t be anagrams.
count[ch] = count.get(ch, 0) + 1
Count frequency of each character in s.
if ch not in count or count[ch] == 0:
If a character in t doesn’t match, return False.
count[ch] -= 1
Reduce count as we match characters.

Why This Works

Anagrams have the same characters in the same quantities.

By counting and cancelling, we’re checking if both strings are perfectly balanced.

Complexity

Time: O(n)
Space: O(1) (since only lowercase letters)

Final Note

This problem is less about strings and more about counting.

Once you think in terms of frequency instead of order, it becomes straightforward.