The code itself is usually short, but understanding when to move the window, what to remove, and what to add can be difficult at first.

This blog explains the Sliding Window technique from the basics with a simple example.

What is Sliding Window?

Sliding Window is a technique used to solve problems involving contiguous portions of an array or string.

Instead of repeatedly calculating the same elements, we maintain a window and move it through the input.

For example, consider:

nums = [1, 12, -5, -6, 50, 3]

If the window size is 4, our windows are:

[1, 12, -5, -6]
[12, -5, -6, 50]
[-5, -6, 50, 3]

The window moves one position at a time.

That is why it is called Sliding Window.

Why Do We Need Sliding Window?

Let's say we want to find the maximum sum of any k consecutive elements.

For:

nums = [1, 12, -5, -6, 50, 3]
k = 4

We could calculate every window from scratch:

1 + 12 + (-5) + (-6) = 2

12 + (-5) + (-6) + 50 = 51

(-5) + (-6) + 50 + 3 = 42

This works, but we are repeatedly calculating elements that were already included in the previous window.

Sliding Window avoids this unnecessary work.

The Main Idea

Look at the first window:

[1, 12, -5, -6]  50  3

Its sum is:

2

Now we slide the window one position to the right:

1  [12, -5, -6, 50]  3

What changed?

• 1 left the window.

• 50 entered the window.

So instead of calculating the entire sum again:

new sum = old sum - element leaving + element entering

Therefore:

new sum = 2 - 1 + 50
        = 51

This simple idea is the heart of the fixed-size Sliding Window technique.

Fixed-Size Sliding Window

The general pattern looks like this:

window = sum(nums[:k])

for i in range(k, len(nums)):
    window = window - nums[i-k] + nums[i]

The important line is:

window = window - nums[i-k] + nums[i]

It means:

Remove the element that is leaving
+
Add the element that is entering

Example: LeetCode 643

One beginner-friendly problem for learning Sliding Window is:

Maximum Average Subarray I

Given an integer array nums and an integer k, find the contiguous subarray of length k that has the maximum average.

For example:

nums = [1, 12, -5, -6, 50, 3]
k = 4

The possible windows are:

[1, 12, -5, -6]       → sum = 2
[12, -5, -6, 50]      → sum = 51
[-5, -6, 50, 3]       → sum = 42

The maximum sum is:

51

Therefore, the maximum average is:

51 / 4 = 12.75

Python Solution

class Solution:
    def findMaxAverage(self, nums: List[int], k: int) -> float:
        tot = sum(nums[:k])

        avg = tot / k
        maximum = avg

        for i in range(k, len(nums)):
            tot = tot - nums[i-k] + nums[i]

            avg = tot / k
            maximum = max(maximum, avg)

        return maximum

Let's understand it step by step.

Step 1: Calculate the First Window

tot = sum(nums[:k])

If:

nums = [1, 12, -5, -6, 50, 3]
k = 4

then:

nums[:k]

gives:

[1, 12, -5, -6]

So:

tot = 2

Step 2: Calculate the First Average

avg = tot / k

Therefore:

avg = 2 / 4
    = 0.5

We store this as our current maximum:

maximum = avg

Step 3: Slide the Window

Now we start from index k:

for i in range(k, len(nums)):

Since k = 4, the first value of i is 4.

The new element is:

nums[i]

which is:

nums[4] = 50

The element leaving the window is:

nums[i-k]

Since:

i = 4
k = 4

we get:

i - k = 0

Therefore:

nums[i-k] = nums[0] = 1

So:

tot = tot - nums[i-k] + nums[i]

becomes:

tot = 2 - 1 + 50
    = 51

Our window has now moved from:

[1, 12, -5, -6]

to:

[12, -5, -6, 50]

Step 4: Update the Maximum

We calculate:

avg = tot / k

Therefore:

avg = 51 / 4
    = 12.75

Then:

maximum = max(maximum, avg)

The maximum becomes:

12.75

The same process continues until we reach the end of the array.

The Pattern to Remember

For a fixed-size Sliding Window, remember these three steps:

1. Calculate the first window

window = sum(nums[:k])

2. Slide the window

window = window - nums[i-k] + nums[i]

3. Update the answer

answer = max(answer, window)

That's the basic pattern.

Time Complexity

A brute-force approach may repeatedly calculate the sum of every window.

Sliding Window allows us to update the sum in constant time for each movement.

Therefore:

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

where n is the number of elements in the array.

How to Recognize a Sliding Window Problem

When reading a LeetCode problem, look for words such as:

• contiguous

• consecutive

• substring

• subarray

• window

• exactly k elements

• at most k elements

• longest/shortest substring

• maximum/minimum sum of consecutive elements

For example:

Find the maximum sum of k consecutive elements.

This should immediately make you think:

Fixed-size Sliding Window.

Common Mistake

One common mistake is recalculating the entire window every time.

For example:

for i in range(n-k+1):
    total = sum(nums[i:i+k])

This repeatedly calculates values that were already calculated.

Instead, calculate the first window once and then update it:

window = window - element_leaving + element_entering

Fixed vs Variable Sliding Window

There are two major types of Sliding Window.

Fixed-size window

The window size stays the same.

Example:

k = 4

[1, 2, 3, 4]
   ↓
[2, 3, 4, 5]
   ↓
[3, 4, 5, 6]

Problems such as Maximum Average Subarray I use this pattern.

Variable-size window

The window size can grow and shrink depending on a condition.

For example:

[ a b c d e ]
  ←──────→

The window may expand when the condition is valid and shrink when the condition is violated.

Variable-size Sliding Window is slightly more difficult, so it is better to learn fixed-size windows first.

Practice Roadmap

If you're new to Sliding Window, don't immediately jump into difficult problems.

A good progression is:

1. LeetCode 643 — Maximum Average Subarray I

2. LeetCode 1456 — Maximum Number of Vowels in a Substring of Given Length

3. LeetCode 1343 — Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold

4. LeetCode 1876 — Substrings of Size Three with Distinct Characters

5. LeetCode 209 — Minimum Size Subarray Sum

6. LeetCode 3 — Longest Substring Without Repeating Characters

7. LeetCode 1004 — Max Consecutive Ones III

8. LeetCode 424 — Longest Repeating Character Replacement

The first four help build the fixed-size pattern.

The later problems introduce variable-size windows, which require a deeper understanding of when to expand and shrink the window.

Final Takeaway

Sliding Window is not a completely different way of thinking about arrays.

It is mainly about reusing information from the previous window instead of calculating everything again.

The most important idea is:

Remove what leaves.
Add what enters.
Move the window.
Update the answer.

Once this becomes familiar, many array and string problems that initially look complicated become much easier to recognize.

Start small, understand the pattern, and then increase the difficulty.

Instead of using nested loops and checking every possible pair of elements, the two pointers technique allows us to solve many problems efficiently in O(n) time.

In this blog, I'll explain what the two pointers technique is, when to use it, and some common patterns with examples.

What is the Two Pointers Technique?

The Two Pointers technique uses two indices (pointers) that move through a data structure such as an array or string.

Instead of processing one element at a time, we use two positions that move based on certain conditions until we reach the desired result.

This often reduces the time complexity from O(n²) to O(n).

When Should You Use Two Pointers?

The technique is useful when working with:

• Sorted arrays

• Strings

• Palindromes

• Removing duplicates

• Pair sum problems

• Reversing arrays

• Sliding window variations

Whenever you see words like:

• pair

• sorted

• remove duplicates

• reverse

• palindrome

think about whether the two pointers approach can simplify the solution.

Types of Two Pointer Patterns

There are several common patterns.

1. Opposite Direction Pointers

One pointer starts from the beginning and the other starts from the end.

left                  right
↓                       ↓

[1, 2, 3, 4, 5]

The pointers move toward each other.

Common Problems

• Valid Palindrome

• Two Sum II

• Reverse String

• Container With Most Water

Example:

s = list("hello")

left = 0
right = len(s) - 1

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

print("".join(s))

Output

olleh

Time Complexity:

O(n)

Space Complexity:

O(1)

2. Same Direction Pointers (Fast and Slow)

Both pointers move from left to right.

The fast pointer explores every element while the slow pointer keeps track of the correct position.

slow fast
 ↓    ↓

[1,1,2,2,3]

Common Problems

• Remove Duplicates from Sorted Array

• Move Zeroes

• Remove Element

Example

nums = [1,1,2,2,3]

left = 0

for right in range(1, len(nums)):
    if nums[left] != nums[right]:
        left += 1
        nums[left] = nums[right]

print(nums[:left+1])

Output

[1,2,3]

Time Complexity

O(n)

Space Complexity

O(1)

3. Slow and Fast Pointer

This is another variation where one pointer moves slower than the other.

Usually,

slow += 1
fast += 2

Common Problems

• Detect Cycle in Linked List

• Find Middle of Linked List

• Happy Number

This pattern is mostly used with linked lists rather than arrays.

Example: Two Sum II

Given a sorted array, find two numbers whose sum equals the target.

numbers = [2,7,11,15]
target = 9

left = 0
right = len(numbers)-1

while left < right:
    current = numbers[left] + numbers[right]

    if current == target:
        print(left, right)
        break
    elif current < target:
        left += 1
    else:
        right -= 1

Output

0 1

Notice how we never use nested loops.

Advantages

✅ Simple to understand

✅ Reduces time complexity

✅ Often converts O(n²) solutions into O(n)

✅ Uses constant extra space

Limitations

• Works best with sorted data.

• Doesn't apply to every array problem.

• Choosing pointer movement correctly is important.

Tips to Identify Two Pointer Problems

Ask yourself these questions:

• Is the array sorted?

• Am I searching for a pair?

• Can I avoid nested loops?

• Can I process elements from both ends?

• Can one pointer track the answer while another explores?

If the answer is yes, the Two Pointers technique is worth considering.

Final Thoughts

The Two Pointers technique is one of the most important problem-solving patterns in Data Structures and Algorithms. Once you understand when and how to move the pointers, many coding interview problems become much easier.

I recently practiced this technique by solving problems like Remove Duplicates from Sorted Array, Merge Sorted Array, Valid Palindrome, and Two Sum II. Each problem helped me recognize different pointer movement patterns and improved my confidence in solving array and string problems efficiently.

Mastering this technique is a great step before learning more advanced patterns like Sliding Window, which builds upon similar ideas while handling subarrays and substrings.

Happy Coding! 🚀

Sorting algorithms are fundamental because they improve the efficiency of many operations such as searching, data analysis, and organizing information. They also help build logical thinking and problem-solving skills, making them an essential topic for coding interviews and competitive programming.

In this blog, I'll share the five sorting algorithms I learned in Python:

• Bubble Sort

• Selection Sort

• Insertion Sort

• Merge Sort

• Quick Sort

Along with a simple explanation, I'll also share the Python implementation I practiced.

📌 What is Sorting?

Sorting is the process of arranging data in a specific order, usually ascending or descending.

For example,

Original Array:
[7, 2, 9, 1, 5]

Sorted Array:
[1, 2, 5, 7, 9]

Sorting is used in many real-world applications, such as:

• Displaying products by price

• Ranking students by marks

• Organizing files alphabetically

• Searching for contacts on a phone

• Processing large datasets efficiently

🔵 Bubble Sort

Bubble Sort is one of the simplest sorting algorithms to understand.

It repeatedly compares two adjacent elements. If they are in the wrong order, they are swapped. After each pass through the array, the largest unsorted element moves to the end, just like a bubble rising to the surface of water.

Example

Input:
[5, 3, 8, 4]

After Pass 1:
[3, 5, 4, 8]

After Pass 2:
[3, 4, 5, 8]

Output:
[3, 4, 5, 8]

Python Implementation

def bubbleSort(arr):
    n = len(arr)

    for i in range(n):
        swapped = False

        for j in range(0, n - i - 1):

            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True

        if not swapped:
            break

arr = [64, 34, 25, 12, 22, 11, 90]

bubbleSort(arr)

print(arr)

Output

[11, 12, 22, 25, 34, 64, 90]

🟢 Selection Sort

Selection Sort works by repeatedly finding the smallest element from the unsorted portion of the array and placing it in its correct position.

Instead of swapping many times like Bubble Sort, Selection Sort performs only one swap at the end of each pass.

Example

Input:
[29, 10, 14, 37, 13]

Pass 1:
[10, 29, 14, 37, 13]

Pass 2:
[10, 13, 14, 37, 29]

Output:
[10, 13, 14, 29, 37]

Python Implementation

def selection_sort(arr):
    n = len(arr)

    for i in range(n - 1):

        small = i

        for j in range(i + 1, n):

            if arr[j] < arr[small]:
                small = j

        arr[i], arr[small] = arr[small], arr[i]

    return arr

arr = [-2, 45, 0, 11, -9, 88, -97, -202, 747]

print(selection_sort(arr))

Output

[-202, -97, -9, -2, 0, 11, 45, 88, 747]

🟡 Insertion Sort

Insertion Sort works similarly to how we arrange playing cards in our hands.

It starts with the second element, compares it with the previous elements, and inserts it into the correct position. With every iteration, the sorted portion of the array grows larger.

Example

Input:
[7, 4, 5, 2]

Insert 4:
[4, 7, 5, 2]

Insert 5:
[4, 5, 7, 2]

Insert 2:
[2, 4, 5, 7]

Python Implementation

def insertion_sort(arr):

    n = len(arr)

    if n <= 1:
        return

    for i in range(1, n):

        key = arr[i]

        j = i - 1

        while j >= 0 and key < arr[j]:

            arr[j + 1] = arr[j]

            j -= 1

        arr[j + 1] = key

arr = [12, 11, 13, 5, -1]

print(insertion_sort(arr))

print(arr)

Output

None
[-1, 5, 11, 12, 13]

Note: The function sorts the array in place, so it doesn't return a new array. That's why print(insertion_sort(arr)) prints None, while print(arr) displays the sorted array.

🟣 Merge Sort

Merge Sort is based on the Divide and Conquer technique.

Instead of sorting the entire array at once, it repeatedly divides the array into smaller halves until each sub-array contains only one element. Then, it merges these smaller arrays back together in sorted order.

This approach makes Merge Sort one of the most efficient sorting algorithms for large datasets.

Example

Input:
[8, 3, 5, 4]

Divide

[8, 3]
[5, 4]

Divide Again

[8] [3]
[5] [4]

Merge

[3, 8]
[4, 5]

Final Output

[3, 4, 5, 8]

Python Implementation

def merge_sort(arr):

    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2

    left = merge_sort(arr[:mid])

    right = merge_sort(arr[mid:])

    return merge(left, right)


def merge(left, right):

    i = j = 0

    result = []

    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


nums = [8, 3, 5, 4, 7, 6, 1]

print(merge_sort(nums))

Output

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

🔴 Quick Sort

Quick Sort is another Divide and Conquer algorithm.

Instead of splitting the array into equal halves, it selects one element called the pivot. All elements smaller than the pivot are placed on the left, while larger elements are placed on the right. The same process is then repeated recursively for both sides until the array is completely sorted.

Quick Sort is one of the fastest sorting algorithms used in practice.

Example

Input:
[8, 3, 1, 7, 0, 10, 2]

Choose Pivot = 2

Partition

[1, 0] 2 [8, 3, 7, 10]

Recursively sort both sides

Output

[0, 1, 2, 3, 7, 8, 10]

Python Implementation

def partition(arr, low, high):

    pivot = arr[high]

    i = low - 1

    for j in range(low, high):

        if arr[j] <= pivot:

            i += 1

            arr[i], arr[j] = arr[j], arr[i]

    arr[i + 1], arr[high] = arr[high], arr[i + 1]

    return i + 1


def quick_sort(arr, low, high):

    if low < high:

        p = partition(arr, low, high)

        quick_sort(arr, low, p - 1)

        quick_sort(arr, p + 1, high)


arr = [1, 7, 4, 1, 10, 9, -2]

quick_sort(arr, 0, len(arr) - 1)

print(arr)

Output

[-2, 1, 1, 4, 7, 9, 10]

🎯 What I Learned

Learning sorting algorithms taught me that there are many ways to solve the same problem. Every algorithm follows a different strategy, and understanding those strategies helped me improve my logical thinking and problem-solving skills.

While Bubble, Selection, and Insertion Sort helped me understand the basics of sorting, Merge Sort and Quick Sort introduced me to recursion and the Divide and Conquer approach, which are important concepts in DSA.

More than just memorizing code, I learned how each algorithm works internally and why different approaches exist for solving the same problem.

🎉 Conclusion

Learning these five sorting algorithms has been an exciting step in my DSA journey. Each algorithm gave me a new perspective on solving problems and strengthened my understanding of programming concepts.

This is just the beginning of my learning path. Next, I'm planning to explore linked lists, trees, graphs, and many more exciting DSA topics.

I hope this blog helps beginners who are starting with sorting algorithms. If you're learning DSA too, keep practicing consistently and don't hesitate to trace your code step by step—it makes understanding algorithms much easier.

Happy Coding! 🚀

At first, searching seemed straightforward. But as I started learning Binary Search, I discovered that it's much more than just finding an element. Concepts like First Occurrence, Last Occurrence, Lower Bound, Upper Bound, and Count Occurrences completely changed how I looked at binary search.

To strengthen my understanding, I also solved several LeetCode problems that helped me apply these concepts in different scenarios.

In this blog, I'll share everything I learned while studying searching algorithms.

Why Do We Need Searching Algorithms?

Searching is one of the most common operations in programming.

Imagine:

• Finding a student's roll number

• Searching for a contact on your phone

• Looking up a product on Amazon

• Finding a word in a dictionary

Efficient searching makes applications much faster.

Linear Search

What is Linear Search?

Linear Search checks each element one by one until it finds the target.

Example:

arr = [12, 45, 78, 23, 90]
target = 23

It starts from the first element and compares every value.

12 ❌

45 ❌

78 ❌

23 ✅

Python Implementation

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

arr = [12,45,78,23,90]

print(linear_search(arr,23))

Time Complexity

What I Learned

✔ Simple to implement

✔ Works on both sorted and unsorted arrays

✔ Slow for large datasets

Binary Search

What is Binary Search?

Binary Search repeatedly divides the search space into half.

Important: The array must be sorted.

Example:

1 3 5 7 9 11 13

Suppose we want to find 9.

Instead of checking every element,

we first check the middle.

If the target is larger,

search the right half.

Otherwise,

search the left half.

This makes Binary Search much faster than Linear Search.

Python Implementation

def binary_search(arr,target):

    left=0
    right=len(arr)-1

    while left<=right:

        mid=(left+right)//2

        if arr[mid]==target:
            return mid

        elif arr[mid]<target:
            left=mid+1

        else:
            right=mid-1

    return -1

arr=[2,4,6,8,10,12]

print(binary_search(arr,10))

Time Complexity

What I Learned

✔ Works only on sorted arrays

✔ Eliminates half of the search space every iteration

✔ Extremely efficient for large datasets

Binary Search Variations

Once I understood normal Binary Search, I learned several useful variations that appear frequently in coding interviews.

Finding the First Occurrence

Sometimes an array contains duplicate elements.

Example:

1 2 4 4 4 6 8

Searching for 4 should return the first occurrence.

Instead of stopping after finding the target, continue searching towards the left.

What I Learned

• Binary Search can be modified.

• Don't stop immediately after finding the element.

Finding the Last Occurrence

Example

1 2 4 4 4 6 8

Searching for 4 should return the last occurrence.

This time,

continue searching towards the right after finding the target.

What I Learned

The search direction changes depending on what we're trying to find.

Lower Bound

Definition

Lower Bound is the first element that is greater than or equal to the target.

Example

Array

1 2 4 4 6 8

Target = 4

Lower Bound = Index 2

Another example

Target = 5

Lower Bound = Index 4 (value = 6)

What I Learned

Lower Bound doesn't always return the target.

Sometimes it returns the next larger element.

Upper Bound

Definition

Upper Bound is the first element strictly greater than the target.

Example

Array

1 2 4 4 6 8

Target = 4

Upper Bound = Index 4

What I Learned

The only difference from Lower Bound is:

Lower Bound

>= target

Upper Bound

> target

Count Occurrences

Instead of traversing the entire array,

we can calculate the count using

Count = Last Occurrence - First Occurrence + 1

Example

1 2 4 4 4 6

First = 2

Last = 4

Count = 4-2+1

=3

This is much faster than counting every element individually.

LeetCode Problems I Solved

To strengthen these concepts, I solved the following LeetCode problems.

34. Find First and Last Position

What I Learned

• Binary Search can search both left and right.

• Finding first and last occurrence separately.

374. Guess Number Higher or Lower

What I Learned

• Classic Binary Search template.

• Updating left and right correctly.

278. First Bad Version

What I Learned

• Binary Search can find the first valid answer instead of searching for an element.

441. Arranging Coins

What I Learned

• Binary Search can solve mathematical problems.

• Search on the answer instead of searching an array.

69. Sqrt(x)

What I Learned

• Binary Search can efficiently calculate square roots.

• Avoid using built-in functions.

Linear Search vs Binary Search

Key Takeaways

After completing this topic, I learned:

✅ Linear Search

✅ Binary Search

✅ First Occurrence

✅ Last Occurrence

✅ Lower Bound

✅ Upper Bound

✅ Count Occurrences

✅ Binary Search on Answer

✅ Applying Binary Search in LeetCode problems

More importantly, I realized that Binary Search isn't just about finding an element—it's a powerful problem-solving technique that can be adapted to many different types of questions.

Conclusion

Mastering searching algorithms has given me a stronger foundation in Data Structures and Algorithms. Every problem I solved taught me something new—whether it was improving efficiency, recognizing patterns, or thinking differently about a solution.

This is just one milestone in my DSA journey, and I know there is still much more to learn. I'll continue documenting what I learn, the challenges I face, and the lessons I gain along the way.

I hope this blog helps anyone who's beginning their own DSA journey. If you're learning too, keep practicing, stay consistent, and enjoy the process.

See you in the next blog! 👋

Happy Coding! 💻🚀

Instead of randomly solving problems, I chose problems that helped me understand array traversal, sorting, counting, mapping, and basic problem-solving techniques. These problems taught me that arrays are much more than just storing numbers—they're about identifying patterns and manipulating data efficiently.

Here are the array-focused problems I solved and what I learned from each one.

1. Kefa and First Steps (580A)

🎯 Problem Statement

Given an array of integers, find the length of the longest non-decreasing contiguous segment.

💡 My Approach

I traversed the array once while keeping track of:

• Current non-decreasing segment length

• Maximum segment length found so far

Whenever the next element was greater than or equal to the previous one, I extended the current segment. Otherwise, I reset the count.

📚 Concepts Used

✔ Array Traversal

✔ Linear Scan

✔ Comparing Adjacent Elements

💻 Solution Code

n = int(input())
arr = list(map(int, input().split()))

current = 1
maximum = 1

for i in range(1, n):
    if arr[i] >= arr[i - 1]:
        current += 1
    else:
        current = 1

    maximum = max(maximum, current)

print(maximum)

📖 What I Learned

• Traversing arrays efficiently.

• Comparing adjacent elements.

• Maintaining running values while scanning an array.

2. Drinks (200B)

🎯 Problem Statement

Given the percentage of orange juice in each drink, calculate the percentage of orange juice in the mixture.

💡 My Approach

I stored all percentages in an array, calculated their sum, and divided it by the number of drinks.

📚 Concepts Used

✔ Array Traversal

✔ Sum of Elements

✔ Average Calculation

💻 Solution Code

n = int(input())
arr = list(map(int, input().split()))

print(sum(arr) / n)

📖 What I Learned

• Reading arrays from input.

• Using Python's built-in sum().

• Finding averages using arrays.

3. Gravity Flip (405A)

🎯 Problem Statement

After gravity changes direction, the cubes rearrange themselves.

Print the final heights.

💡 My Approach

Instead of simulating gravity, I realized the final arrangement is simply the sorted array.

📚 Concepts Used

✔ Sorting

✔ Arrays

💻 Solution Code

n = int(input())
arr = list(map(int, input().split()))

arr.sort()

print(*arr)

📖 What I Learned

• Sometimes sorting is enough to solve simulation problems.

• Python's sort() is very useful.

4. Is your horseshoe on the other hoof? (228A)

🎯 Problem Statement

Valera wants four horseshoes of different colors.

Find how many additional horseshoes he needs to buy.

💡 My Approach

I used a set to remove duplicate colors.

The answer is:

4 - Number of Unique Colors

📚 Concepts Used

✔ Sets

✔ Counting Distinct Elements

✔ Arrays

💻 Solution Code

arr = list(map(int, input().split()))

print(4 - len(set(arr)))

📖 What I Learned

• Sets automatically remove duplicates.

• Counting unique values becomes much easier.

5. Presents (136A)

🎯 Problem Statement

Each friend gives a gift to exactly one other friend.

Find who gave a gift to each friend.

💡 My Approach

The input provides:

Friend → Receiver

I needed:

Receiver → Friend

So I created another array and reversed the mapping while traversing the original array.

📚 Concepts Used

✔ Arrays

✔ Indexing

✔ Reverse Mapping

💻 Solution Code

n = int(input())
arr = list(map(int, input().split()))

answer = [0] * n

for i in range(n):
    answer[arr[i] - 1] = i + 1

print(*answer)

📖 What I Learned

• Arrays can also be used for mapping relationships.

• Careful indexing can avoid extra loops.

🌱 Key Takeaways

These five problems introduced me to some of the most important array concepts:

• ✅ Reading and traversing arrays

• ✅ Finding the longest segment

• ✅ Computing sums and averages

• ✅ Sorting arrays

• ✅ Counting distinct elements

• ✅ Using sets with arrays

• ✅ Reverse mapping using arrays

Although these problems are beginner-friendly, they helped me understand the building blocks of many Data Structures and Algorithms problems.

🎯 What's Next?

My current progress:

• ✅ More than 20 Codeforces problems solved

• ✅ Learning Data Structures one topic at a time

• ✅ Building consistency through daily practice

Next, I'll continue exploring:

• Prefix Sum

• Two Pointers

• Sliding Window

• Binary Search

• More 800–1000 rated Codeforces problems

Every solved problem strengthens my problem-solving skills and teaches me a new way of thinking.

Thanks for reading, and happy coding! 🚀

In Python, we commonly use lists to represent arrays because they are flexible and easy to work with.

Let's explore the most common array operations with examples.

Creating an Array

arr = [10, 20, 30, 40, 50]

Output:

[10, 20, 30, 40, 50]

Accessing Elements

Each element has an index starting from 0.

arr = [10, 20, 30, 40, 50]

print(arr[0])
print(arr[2])
print(arr[-1])

Output:

10
30
50

Time Complexity: O(1)

Adding Elements

1. Add at the End

arr.append(60)

print(arr)

Output:

[10, 20, 30, 40, 50, 60]

2. Insert at a Specific Position

arr.insert(2, 25)

print(arr)

Output:

[10, 20, 25, 30, 40, 50]

3. Extend an Array

Use extend() to add multiple elements.

arr.extend([60, 70, 80])

print(arr)

Output:

[10, 20, 30, 40, 50, 60, 70, 80]

Removing Elements

Remove by Value

arr.remove(30)

print(arr)

Output:

[10, 20, 40, 50]

Remove by Index

arr.pop(2)

print(arr)

Output:

[10, 20, 40, 50]

Delete Using del

del arr[1]

print(arr)

Output:

[10, 30, 40, 50]

Slicing

Slicing allows us to extract a portion of an array.

arr = [10, 20, 30, 40, 50, 60]

print(arr[1:4])
print(arr[:3])
print(arr[3:])
print(arr[::-1])

Output:

[20, 30, 40]
[10, 20, 30]
[40, 50, 60]
[60, 50, 40, 30, 20, 10]

Searching Elements

Using in

arr = [10, 20, 30, 40]

print(30 in arr)
print(100 in arr)

Output:

True
False

Using index()

print(arr.index(40))

Output:

3

Counting Elements

Find how many times an element appears.

arr = [10, 20, 10, 30, 10]

print(arr.count(10))

Output:

3

Reversing an Array

Method 1: Using reverse()

arr.reverse()

print(arr)

Output:

[50, 40, 30, 20, 10]

Method 2: Using Slicing

print(arr[::-1])

Output:

[50, 40, 30, 20, 10]

Other Useful Operations

Length of an Array

print(len(arr))

Output:

5

Maximum Element

print(max(arr))

Output:

50

Minimum Element

print(min(arr))

Output:

10

Sum of Elements

print(sum(arr))

Output:

150

Sorting

Ascending Order

arr.sort()

print(arr)

Descending Order

arr.sort(reverse=True)

print(arr)

Time Complexity of Common Operations

Why Learn Array Operations?

Array operations are the foundation of Data Structures and Algorithms. Most coding interview questions begin with manipulating arrays, such as searching, inserting, deleting, reversing, or traversing elements.

Mastering these basic operations will make it easier to solve more advanced problems using techniques like Two Pointers, Sliding Window, Prefix Sum, and Binary Search.

Conclusion

Arrays may seem simple, but they are one of the most powerful and frequently used data structures in programming. Understanding how to create, access, add, remove, search, slice, reverse, count, and extend arrays gives you a strong foundation for solving real-world programming problems and coding interview questions.

Every great DSA journey starts with mastering the basics—and arrays are the perfect place to begin.

Happy Coding!

Instead of focusing only on syntax, I started paying more attention to understanding the problem statement, identifying patterns, and choosing the right approach.

Here are the next 10 problems I solved, along with my approach, solution, and key takeaways.

1. Is your horseshoe on the other hoof? (228A)

🎯 What the problem asks

Valera wants to wear four horseshoes of different colors. Find the minimum number of horseshoes he needs to buy.

💡 Approach

The easiest way to detect duplicate colors is by using a set, which automatically removes duplicates.

The answer is simply:

4 - Number of unique colors

📚 Concepts Used

✔ Sets

✔ Duplicate Removal

✔ Length

💻 Solution Code

s = list(map(int, input().split()))

print(4 - len(set(s)))

📖 What I Learned

• Sets automatically remove duplicate values.

• Sometimes counting unique elements is easier than counting duplicates.

2. Presents (136A)

🎯 What the problem asks

Given who each friend gave a gift to, determine who gave a gift to each friend.

💡 Approach

The input gives:

Friend → Receiver

The output asks for:

Receiver → Friend

So I built the reverse mapping while reading the input.

📚 Concepts Used

✔ Lists

✔ Indexing

✔ Reverse Mapping

💻 Solution Code

n = int(input())
p = list(map(int, input().split()))

ans = [0] * n

for i in range(n):
    ans[p[i] - 1] = i + 1

print(*ans)

📖 What I Learned

• Reverse mapping is a useful technique.

• Indexing carefully helps avoid unnecessary loops.

3. I Wanna Be the Guy (469A)

🎯 What the problem asks

Determine whether two friends together can complete every level in the game.

💡 Approach

Combine the levels completed by both players.

Remove duplicates using a set.

If the number of unique levels equals n, they can complete the game.

📚 Concepts Used

✔ Sets

✔ Union

✔ Conditions

💻 Solution Code

n = int(input())

x = list(map(int, input().split()))
y = list(map(int, input().split()))

levels = set(x[1:] + y[1:])

if len(levels) == n:
    print("I become the guy.")
else:
    print("Oh, my keyboard!")

📖 What I Learned

• Set union makes merging data simple.

• Reading the input format carefully is very important.

4. Beautiful Year (271A)

🎯 What the problem asks

Find the next year whose digits are all distinct.

💡 Approach

Keep checking the next year until every digit becomes unique.

📚 Concepts Used

✔ While Loop

✔ Strings

✔ Sets

💻 Solution Code

y = int(input())

while True:
    y += 1

    if len(str(y)) == len(set(str(y))):
        print(y)
        break

📖 What I Learned

• Converting numbers into strings makes digit-based problems much easier.

• Sets are useful for uniqueness checking.

5. New Year and Hurry (750A)

🎯 What the problem asks

Limak has 240 minutes before midnight, but he also needs some time to travel to the New Year party. Find the maximum number of contest problems he can solve before leaving.

💡 Approach

First, calculate the time available for solving problems:

Available Time = 240 - k

Then, keep adding the time required for each problem (5 × i) until the total exceeds the available time.

📚 Concepts Used

✔ Loops

✔ Conditions

✔ Simulation

✔ Accumulation

💻 Solution Code

n, k = map(int, input().split())

time = 240 - k
total = 0
count = 0

for i in range(1, n + 1):
    total += i * 5
    if total <= time:
        count += 1
    else:
        break

print(count)

📖 What I Learned

• Solving problems step by step using simulation.

• Knowing when to stop a loop using break.

• Calculating cumulative values.

6. Soldier and Bananas (546A)

🎯 What the problem asks

A soldier wants to buy several bananas where the price of each banana increases. Find how much money he needs to borrow if he doesn't have enough money.

💡 Approach

Calculate the total cost of buying all bananas.

If the total cost is greater than the money he already has, print the difference.

Otherwise, print 0.

📚 Concepts Used

✔ Loops

✔ Arithmetic Operations

✔ Conditions

💻 Solution Code

k, n, w = map(int, input().split())

total = 0

for i in range(1, w + 1):
    total += k * i

if total > n:
    print(total - n)
else:
    print(0)

📖 What I Learned

• Calculating cumulative sums.

• Handling multiple conditions correctly.

• Writing cleaner logic using loops.

7. Wrong Subtraction (977A)

🎯 What the problem asks

Perform subtraction k times.

If the last digit of the number is 0, remove that digit.

Otherwise, subtract 1.

💡 Approach

Repeat the given operation exactly k times.

Use modulus (%) to check the last digit and integer division (//) to remove the last digit.

📚 Concepts Used

✔ While Loop

✔ Modulus

✔ Integer Division

✔ Conditions

💻 Solution Code

n, k = map(int, input().split())

while k > 0:
    if n % 10 == 0:
        n = n // 10
    else:
        n -= 1
    k -= 1

print(n)

📖 What I Learned

• Using % to access the last digit.

• Using // to remove digits.

• Repeating operations with a while loop.

8. Elephant (617A)

🎯 What the problem asks

An elephant wants to reach his friend's house.

In one move, he can walk 1, 2, 3, 4, or 5 steps.

Find the minimum number of moves required.

💡 Approach

Since the elephant can move a maximum of 5 steps at once, always taking the largest possible step minimizes the number of moves.

If the distance is not exactly divisible by 5, one extra move is required.

📚 Concepts Used

✔ Integer Division

✔ Modulus

✔ Conditions

💻 Solution Code

x = int(input())

if x % 5 == 0:
    print(x // 5)
else:
    print((x // 5) + 1)

📖 What I Learned

• Breaking a problem into complete groups and a remaining part.

• Applying greedy thinking for simple optimization problems.

• Using integer division effectively.

9. Bear and Big Brother (791A)

🎯 What the problem asks

Limak's weight triples every year, while Bob's weight doubles every year.

Find how many years it takes for Limak to become heavier than Bob.

💡 Approach

Update both weights every year.

Count the number of years until Limak's weight becomes greater than Bob's.

📚 Concepts Used

✔ While Loop

✔ Simulation

✔ Variable Updates

💻 Solution Code

a, b = map(int, input().split())

years = 0

while a <= b:
    a *= 3
    b *= 2
    years += 1

print(years)

📖 What I Learned

• Simulating changes over time.

• Updating multiple variables inside a loop.

• Using loop conditions correctly.

10. Anton and Danik (734A)

🎯 What the problem asks

Anton and Danik play several games.

Each game is represented by:

• A → Anton wins

• D → Danik wins

Determine who wins more games.

💡 Approach

Count the number of 'A' and 'D' characters in the string.

Compare the counts and print the winner.

If both counts are equal, print Friendship.

📚 Concepts Used

✔ Strings

✔ Counting

✔ Conditions

💻 Solution Code

n = int(input())
games = input()

anton = games.count("A")
danik = games.count("D")

if anton > danik:
    print("Anton")
elif danik > anton:
    print("Danik")
else:
    print("Friendship")

📖 What I Learned

• Counting character occurrences in strings.

• Comparing multiple conditions.

• Using built-in string functions effectively.

🚀 What's Next?

My current progress:

✅ 20 Codeforces Problems Solved

My next goals are:

• 🎯 Reach 50 solved Codeforces problems

• 🎯 Solve 900–1000 rated implementation problems consistently

• 🎯 Improve my problem-solving speed

• 🎯 Build a stronger foundation in Data Structures and Algorithms

Every problem teaches me a new way of thinking, and I'm excited to continue this journey one challenge at a time.

These problems helped me strengthen my basics in Python and improve my logical thinking.

Here are the problems I solved and what I learned from them.

1. Team (231A)

What the problem asks

Three friends decide whether they will solve a problem only if at least two of them are sure about the solution.

We need to count how many problems they will solve.

What I understood

This problem mainly checks counting logic.

For each problem:

• count the number of 1s

• if count ≥ 2, increase answer

Concepts used

✔ Loops ✔ Conditions ✔ Lists

Solution Code

n = int(input())
count = 0

for i in range(n):
    row = list(map(int, input().split()))
    if sum(row) >= 2:
        count += 1

print(count)

What I learned

• How to count values inside a list

• How to process multiple test cases

2. Next Round (158A)

What the problem asks

Find how many participants move to the next round based on score.

What I understood

A participant qualifies if:

• score is greater than 0

• score is greater than or equal to the kth participant’s score

Concepts used

✔ Lists ✔ Indexing ✔ Conditions

Solution Code

n, k = map(int, input().split())
scores = list(map(int, input().split()))

count = 0

for i in range(n):
    if scores[i] >= scores[k-1] and scores[i] > 0:
        count += 1

print(count)

What I learned

• Handling conditions carefully

• Working with array positions

3. Bit++ (282A)

What the problem asks

Perform increment or decrement based on operations.

What I understood

If the statement contains ++, increase value. If it contains --, decrease value.

Concepts used

✔ Strings ✔ Conditions ✔ Loops

Solution Code

n = int(input())
x = 0

for i in range(n):
    s = input()

    if "++" in s:
        x += 1
    else:
        x -= 1

print(x)

What I learned

• String checking

• Updating variables repeatedly

4. Boy or Girl (236A)

What the problem asks

Check whether the username has odd or even number of distinct characters.

What I understood

Use a set to remove duplicates.

Count unique characters.

Concepts used

✔ Sets ✔ Length ✔ Conditions

Solution Code

name = input()

if len(set(name)) % 2 == 0:
    print("CHAT WITH HER!")
else:
    print("IGNORE HIM!")

What I learned

• Practical use of sets

• Removing duplicates efficiently

5. Word Capitalization (281A)

What the problem asks

Capitalize only the first letter of the word.

What I understood

Take first character, convert it to uppercase, and join with remaining characters.

Concepts used

✔ Strings ✔ Slicing

Solution Code

word = input()

print(word[0].upper() + word[1:])

What I learned

• String slicing

• String methods

6. Petya and Strings (112A)

What the problem asks

Compare two strings without considering case.

What I understood

Convert both strings into same case and compare.

Concepts used

✔ Strings ✔ Lowercase conversion

Solution Code

a = input().lower()
b = input().lower()

if a < b:
    print(-1)
elif a > b:
    print(1)
else:
    print(0)

What I learned

• Case-insensitive comparison

• Lexicographical order

7. Word (59A)

What the problem asks

Convert the word into uppercase or lowercase depending on majority.

What I understood

Count uppercase and lowercase letters.

If uppercase > lowercase: convert all to uppercase. Else lowercase.

Concepts used

✔ Strings ✔ Loops ✔ Conditions

Solution Code

word = input()

upper = 0
lower = 0

for ch in word:
    if ch.isupper():
        upper += 1
    else:
        lower += 1

if upper > lower:
    print(word.upper())
else:
    print(word.lower())

What I learned

• Character checking

• Counting conditions

8. Stones on the Table (266A)

What the problem asks

Count how many stones need to be removed if adjacent colors are same.

What I understood

Compare each stone with the next one.

If same: increase count.

Concepts used

✔ Strings ✔ Loops ✔ Indexing

Solution Code

n = int(input())
s = input()

count = 0

for i in range(n-1):
    if s[i] == s[i+1]:
        count += 1

print(count)

What I learned

• Adjacent comparison

• String traversal

9. Helpful Maths (339A)

What the problem asks

Sort numbers separated by +.

Example:

3+2+1 → 1+2+3

What I understood

Split the string, sort the values, and join them.

Concepts used

✔ Split ✔ Sort ✔ Join

Solution Code

s = input()

nums = s.split("+")
nums.sort()

print("+".join(nums))

What I learned

• String splitting

• Sorting

• Joining strings

10. Beautiful Matrix (263A)

What the problem asks

We are given a 5×5 matrix where only one element is 1 and all others are 0.

We need to move that 1 to the center position (3,3) using minimum moves.

Each move can swap adjacent rows or columns.

What I understood

The main task is to find where 1 is located.

Once found:

• calculate row distance from center

• calculate column distance from center

• add both distances

Formula:

moves = abs(row - 2) + abs(col - 2)

(Because Python uses 0-based indexing)

Concepts used

✔ Nested Loops ✔ Lists ✔ Conditions ✔ Absolute Difference

Solution Code

for i in range(5):
    row = list(map(int, input().split()))
    
    if 1 in row:
        r = i
        c = row.index(1)

moves = abs(r - 2) + abs(c - 2)

print(moves)

What I learned

• How to work with matrices

• How nested loops help traverse rows and columns

• Using abs() to calculate minimum distance

Conclusion

These beginner problems taught me that competitive programming is not just about coding — it is about understanding the problem, finding the logic, and applying the right concepts.

Through these problems, I improved my understanding of:

• loops

• strings

• sets

• lists

• conditions

I am continuing to solve more problems and improve my problem-solving skills step by step.

Next target:

📍 More Codeforces problems

📍 Better problem-solving speed

📍 Stronger DSA foundation

This is everything I’ve learned so far, explained in the simplest way possible.

Chapter 1: Talking to the Computer

The first thing I learned was:

print("Hello World")

This was my introduction to Python.

It taught me something very important:

A computer does not think on its own. It only follows the instructions we give.

The print() function is used to display output on the screen. It is the simplest way for a program to communicate with us.

Think of it like:

Me → Python → Output

This was the first step in understanding how programming works.

Chapter 2: Variables — Memory Boxes 📦

Variables are used to store information in memory.

Example:

name = "Annet"
age = 21

Imagine:

📦 name → "Annet" 📦 age → 21

Here, name stores text and age stores a number.

Variables help us save data so we can use it later in the program.

This taught me that programming is not just writing code — it is about storing, managing, and using data.

Chapter 3: Data Types — Different Types of Boxes

Not all data is the same.

Python divides data into different types:

x = 10        # Integer
y = 3.14      # Float
name = "Annet" # String
is_happy = True # Boolean

Each type has its own purpose:

• Integers for whole numbers

• Floats for decimal values

• Strings for text

• Booleans for true or false values

This taught me that understanding data types is important because different operations work differently on each type.

Chapter 4: Taking Input — Letting Users Speak 🎤

Before learning input, my programs were fixed.

Then I learned:

name = input("Enter your name: ")
print(name)

The input() function allows the user to give data to the program.

This made my programs interactive.

Now the program could take different values from different users.

This was the first step in making my programs dynamic.

Chapter 5: Type Casting — Transforming Data 🔄

Sometimes data is not in the form we need.

Example:

x = "10"

Here, 10 is a string, not a number.

To use it as a number:

x = int(x)

This converts the string into an integer.

Type casting helps convert data from one type to another.

This taught me that data must sometimes be transformed before it can be used properly.

Chapter 6: Operators — The Action Makers ⚡

Operators are symbols used to perform operations.

+   Add
-   Subtract
*   Multiply
/   Divide
%   Remainder

Example:

a = 10
b = 5
print(a+b)

Operators help us manipulate data and perform calculations.

Without operators, variables would just hold values without doing anything useful.

Chapter 7: Decision Making — Teaching Logic 🧠

This is where programming became more logical.

if age >= 18:
    print("Eligible")
else:
    print("Not eligible")

The program checks a condition and decides what to do.

This taught me that programs can make decisions based on data.

Decision making is one of the most important parts of programming.

Chapter 8: Loops — Repetition Without Rewriting 🔁

Sometimes we need to repeat the same task many times.

Instead of writing:

print("Hello")
print("Hello")
print("Hello")

We use:

for i in range(3):
    print("Hello")

Loops save time and reduce repeated code.

This taught me that repetition can be controlled efficiently.

Loop controls

break

Stops the loop immediately.

continue

Skips the current iteration and moves to the next.

pass

Used as a placeholder when no code is written yet.

These help control the flow of loops.

Chapter 9: Pattern Printing — My First Real Logic Test ⭐

Patterns looked simple at first.

But they required logic.

Example:

*
**
***
****

Pattern printing taught me:

• How nested loops work

• How rows and columns are managed

• How logic can create visual structures

This improved my problem-solving skills.

Chapter 10: Strings — Playing with Text ✍️

Strings are sequences of characters.

Example:

name = "Python"

Strings are very important because most real-world data is text.

Indexing

Used to access a single character.

name[0]

Output:

P

Slicing

Used to access part of a string.

name[0:3]

Output:

Pyt

Reverse

name[::-1]

Output:

nohtyP

This taught me how text can be manipulated in different ways.

Chapter 11: Data Structures — Organizing Information 🗂️

Data structures help store multiple values efficiently.

Lists

Lists are ordered and mutable.

a = [1,2,3]

They can be modified:

a.append(4)

Lists taught me how to manage collections of data.

Tuples

Tuples are ordered but immutable.

t = (1,2,3)

Packing:

t = 1,2,3

Unpacking:

a,b,c = t

Tuples taught me that some data should remain fixed.

Sets

Sets store unique values only.

s = {1,2,2,3}

Output:

{1,2,3}

Sets automatically remove duplicates.

This taught me how uniqueness is handled in Python.

Dictionaries

Dictionaries store data as key-value pairs.

student = {
    "name": "Annet",
    "age": 21
}

Example:

name → Annet

This taught me how data can be stored and accessed using keys.

Dictionaries are useful for structured information.

Chapter 12: Functions — Reusable Logic 🛠️

Functions help avoid writing the same code repeatedly.

def add(a,b):
    return a+b

A function is a block of reusable code.

This taught me that programming should be organized and reusable.

return

The return statement sends the result back.

Without return, the function only performs.

With return, it gives a value back.

This made functions much more useful.

*args and **kwargs

These make functions flexible.

def fun(*args)

Used for multiple values.

def fun(**kwargs)

Used for multiple named values.

This taught me how functions can accept varying amounts of data.

Lambda

Small one-line functions.

square = lambda x: x*x

Useful for simple operations.

Chapter 13: Recursion — Functions Calling Themselves 🔄

Recursion means a function calling itself.

Example:

def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)

This taught me that big problems can be broken into smaller versions of the same problem.

Recursion improved my understanding of problem-solving.

Chapter 14: File Handling — Making Data Permanent 📁

Before file handling, data disappeared after program execution.

Now:

with open("notes.txt","w") as file:
    file.write("Hello")

This allows data to be stored permanently.

File handling taught me that programs can save and read information.

Chapter 15: Exception Handling — Handling Mistakes Gracefully ⚠️

Errors are normal in programming.

What matters is handling them properly.

try:
    x = 10/0
except:
    print("Error")

This prevents the program from crashing.

It taught me how to manage unexpected situations.

raise

Creating my own errors:

raise ValueError("Invalid input")

This taught me that I can define and control errors based on conditions.

What I Realized

Learning Python is not about memorizing syntax.

It is about:

• thinking clearly

• breaking problems

• building logic

• solving step by step

From a simple calculator to recursion and file handling, every topic taught me something deeper.

Next stop:

🚀 Object-Oriented Programming 🚀 Data Structures and Algorithms 🚀 Competitive Programming

Lets me explain the customization process step by step

1. Theme

Initially, I was using the default VS Code theme, which felt plain and uninspiring and i really wanted to make my theme look colourfull and vibrant that's when i find multiple extensions to do it. My most favourite extensions are

• haSakura-theme : A pink vibrant theme which is bright and pookie coded

• Shades of Purple : A professional theme with hand-picked & bold shades of purple

• JellyFish Theme : A beautifully crafted theme designed to reduce eye strain while making code stand out clearly.

2. Icons

This are the icons used in the files in the vs code making them cute and creative make us enjoy creating new files and looking at those unique icons for different languages . Some of the icon theme that i explored while customization include

• Celestial Magic Girl Icon Theme : Cute and magical icons

• RuneScape Icon Theme : Old School RuneScape Icon Theme

• Ghibli Icon Theme : Icons from ghibli movies

3. Pets

This is the very surprising feature that i find while customising vs code also have extensions for choosing your won pet there a numberous pets that you can choose from. Whenever coding feels repetitive, interacting with these pets adds a bit of fun to the experience. It's toooo cute to add on your vs code. Some of the favourties are

• Amber pet : A cute anime girl that gives cute reaction and makes sound

• vscode-pets : You can add as many pets you want and name they they will be playing with each other

• Pokemon Pets : Bring your favorite Pokémon into VS Code with adorable virtual companions that stay by your side while coding.

4. Cursor

Cursor extensions allow you to customize the appearance and behavior of your cursor. This can make you to write long lines of code without getting bored. You can choose cursor of your liked one. Some of the good one are

• QuackTrack: Cute Animated Pixel Duck : A cute Duck (and his friends) next to your cursor to make debugging more enjoyable and boost your productivity!

• Neovide Cursor : Adds smooth cursor movement and elegant animations, bringing a polished Neovim-inspired feel to VS Code.

• Vision Smash Code : Add cursor trail effects, window animations, and gradient theme effects to VS Code, making your coding experience more vivid and interesting!

5.Fonts

Fonts play a huge role in making the coding experience comfortable and visually appealing. A good programming font improves readability, reduces eye strain, and makes code look cleaner and more professional. Some of the fonts I explored while customizing VS Code include:

• JetBrains Mono : A modern font designed specifically for developers, featuring excellent readability and programming ligatures.

• Fira Code : A popular coding font that combines common programming symbols into elegant ligatures, making code easier to read.

• Cascadia Code : Microsoft's coding font, optimized for VS Code with clear character distinctions and built-in ligatures.

Final Thoughts

Customizing VS Code was a lot more fun than I expected. What started as a simple attempt to make my editor look better turned into a way of creating a workspace that feels more personal and enjoyable to use every day.

From colorful themes and unique icon packs to virtual pets, cursor effects, and programming fonts, every small change made coding a little more exciting. While these customizations don't directly improve coding skills, they can make the development experience more comfortable and motivating.

My current setup is still evolving, and I'm always exploring new extensions and ideas. If you're someone who spends hours coding, I highly recommend experimenting with different customizations and creating a workspace that reflects your own personality.

Thank you for reading!

Happy coding! 🚀

What is HTML?

HTML (HyperText Markup Language) is the foundation of every website. It provides the structure of a webpage using elements such as headings, paragraphs, images, links, forms, and buttons.

Think of HTML as the skeleton of a website.

Topics I Learned

1. Basic HTML Structure

One of the first things I learned was the basic structure of an HTML document.

• <html>

• <head>

• <title>

• <body>

These tags form the foundation of every webpage.

2. Headings and Paragraphs

I learned how to display content using:

• <h1> to <h6> for headings

• <p> for paragraphs

These tags help organize information clearly.

3. Links and Navigation

I learned to create clickable links using:

<a href="https://example.com">Visit Website</a>

I also learned how to open links in a new tab using:

target="_blank"

4. Images

Displaying images was another exciting step.

<img src="image.jpg" alt="Image">

I learned how to adjust image sizes and use images in my portfolio.

5. Forms

Forms allow users to enter information.

I practiced:

• Text inputs

• Labels

• Placeholders

• Submit buttons

This helped me understand how websites collect user information.

6. IDs and Classes

I learned the difference between IDs and classes.

• IDs are unique.

• Classes can be used for multiple elements.

Example:

<p id="title">Hello</p>
<p class="text">Welcome</p>

7. CSS Styling

After learning HTML, I started styling pages using CSS.

I explored:

• Colors

• Borders

• Padding

• Margins

• Backgrounds

This transformed plain webpages into attractive designs.

8. Background Images

One of the most interesting things I learned was adding background images.

background-image: url("image.jpg");
background-size: cover;
background-position: center;

I also learned the purpose of:

• background-repeat

• background-attachment

• background-size

• background-position

9. Navigation Bar

I started creating a navigation bar for my portfolio with sections such as:

• About

• Skills

• Projects

• Certifications

• Education

• Contact

This helped me understand how real websites are organized.

10. Pseudo Classes

I learned CSS pseudo-classes such as:

• :hover

• :visited

• :active

• :nth-child()

These allow elements to react to user interactions.

11. Positioning and Layouts

I explored:

• float

• position

• relative

• absolute

• fixed

• sticky

These concepts helped me control where elements appear on the page.

12. Challenges I Faced

The most valuable part of my learning journey was applying everything to a personal portfolio website.

While building it, I faced many challenges:

• Elements not aligning correctly

• CSS properties not working as expected

• Layout issues

But solving these problems taught me much more than simply watching tutorials.

What I Learned Beyond HTML

The biggest lesson was that learning web development is not about memorizing tags. It is about building projects, making mistakes, debugging, and improving step by step.

Every error taught me something new.

What's Next?

My next goals are:

• Improve my CSS skills

• Learn Flexbox

• Learn JavaScript

• Make my portfolio responsive

• Build more projects

My First Portfolio Website

One of the most exciting parts of my learning journey was building and deploying my first portfolio website.

This portfolio is the first version of my work. I know it is far from perfect and may not look as professional as experienced developers' portfolios. However, I am proud of it because it represents my first step into web development and showcases the concepts I have learned so far.

Building this portfolio taught me valuable lessons about HTML structure, CSS styling, layouts, navigation, debugging, and deployment. More importantly, it showed me that learning happens through creating, experimenting, and improving.

I plan to continue refining the design, improving responsiveness, learning modern CSS techniques such as Flexbox and Grid, and adding more projects as I grow as a developer.

Connect With Me

🌐 Portfolio: https://annet-own-portfolio.netlify.app/

💻 GitHub: https://github.com/annet2005

🔗 LinkedIn:https://www.linkedin.com/in/annetraj/

Final Thoughts

Starting web development can feel challenging at first, but every small step contributes to growth. Just a few days ago, I had very little understanding of how websites were built. Today, I have created and deployed my own portfolio website and gained a strong foundation in HTML and CSS.

This is only the beginning of my journey. I am excited to continue learning, building projects, improving my skills, and sharing my progress along the way.

Thank you for reading my first blog. I hope it encourages other beginners to start building and learning one step at a time.