This is not a collection of problems.
This is a public log of evolution.

This repository documents my transformation
from an absolute beginner in C++
to advanced DSA & system-level programming.

Progress:

[██████████░░░░░░░░░░] 54.72%

Progress compounds. Consistency wins.

This repository grows every single day.
Every solved problem sharpens my thinking.
Every commit compounds my skill.

Focus: cin, cout, variables, if-else, loops, operators.

• Print my full name 100 times
• Check if a number is positive, negative, or zero
• Find the largest of 3 numbers
• Check if a year is a leap year
• Reverse a number (123 → 321)
• Count digits in a number
• Sum of digits of a number
• Check if a number is a palindrome
• Print multiplication table of a number
• Print patterns (Right triangle, Pyramid, Diamond)

Focus: Nested loops mastery · Space handling · Symmetry logic · Pattern math thinking

Patterns are not about stars.
They are about controlling loops, indices, and structure.

• Right triangle
• Pyramid
• Diamond
• Rectangle
• More on half-pyramid (or right-triangle)
• Half pyramid (numbers)
• Floyd’s triangle
• 0-1 triangle

• Hollow half-pyramid
• Hollow pyramid
• Hollow diamond
• Butterfly pattern
• Sandglass pattern
• Pascal’s triangle
• Palindromic number pyramid
• Rhombus pattern

• Hollow butterfly
• Spiral matrix print
• Zig-zag matrix

🧠 Goal:
Master space-star balance, index mathematics, and symmetry reasoning.

Focus: Nested loops, mathematical thinking, problem-solving.

• Print all prime numbers from 1 to N
• Check if a number is Armstrong
• Find GCD
• Find LCM
• Generate Fibonacci series
• Convert decimal to binary (without built-in functions)
• Print Pascal’s triangle
• Find factorial without recursion
• Strong number checker
• Perfect number checker
• Build a basic number guessing game

• Find second largest element
• Remove duplicates from array
• Rotate array left/right
• Find missing number in 1–N
• Move all zeros to end
• Kadane’s Algorithm (Maximum subarray sum)
• Merge two sorted arrays
• Implement Binary Search
• Count frequency of elements
• Stock buy-sell (maximum profit)

• Check anagram
• Reverse string without built-in reverse
• Longest word in a sentence
• Count vowels and consonants
• Remove spaces
• Check substring manually
• String compression (aaabb → a3b2)
• Longest palindrome substring (brute force)

Focus: Recursion, backtracking, divide & conquer.

• Fibonacci using recursion
• Power function (x^n) recursively
• Tower of Hanoi
• Generate all permutations of a string
• Subset generation
• Solve maze using recursion
• N-Queens problem
• Sudoku solver
• Merge sort
• Quick sort

Focus: Classes, constructors, destructors, inheritance, polymorphism.

• Create a Bank Account class
• Library management mini system
• Student grading system
• Employee payroll system
• Operator overloading (Complex number class)
• Build my own String class
• Virtual functions example
• Diamond problem demonstration
• File handling project
• Mini ATM simulation

Focus: vector, map, set, unordered_map, stack, queue, algorithms.

• Frequency counter using map
• Balanced parentheses using stack
• Implement LRU Cache
• Sliding window maximum
• Two-sum using unordered_map
• Top K frequent elements
• Custom comparator in priority_queue
• Graph using adjacency list
• BFS and DFS
• Detect cycle in graph

• Implement my own vector class
• Thread-safe counter using mutex
• Memory pool allocator
• Implement shared_ptr manually
• Multi-threaded producer-consumer
• Build a mini shell in C++
• Build a simple HTTP server
• Trie implementation
• Segment tree
• Dijkstra’s algorithm

• Command line calculator
• Mini compiler (tokenizer)
• Custom string parser
• Basic blockchain simulation
• Simple database using file handling
• Snake game (console-based)
• Sudoku game
• Chat system using sockets

1. Fundamentals are non-negotiable
2. No blind copy-paste
3. Rewrite from memory
4. Analyze time & space
5. Refactor aggressively
6. Clean commits only
7. Think like a systems engineer

Most people consume tutorials.
Few build depth.

This repository exists to:

• Build unshakable fundamentals
• Train algorithmic thinking
• Develop systems intuition
• Track visible progress
• Stay accountable publicly

By this tracker reaches 100%, I will be able to:

• Design efficient data structures from scratch
• Understand memory layout & performance trade-offs
• Write production-grade C++
• Build multi-threaded systems
• Think in algorithms naturally

⚔️ This repository is not about solving problems.

It is about building a mind capable of solving anything.