Welcome! This repository serves as a centralized vault for my daily coding progress, structured problem-solving, and logic-driven C++ applications. Every program here focus on handling extreme edge cases, data validation, and modular structure.
Selected Contributor out of 43,000+ applicants! 🌟
🔥 Promoted to Co-Maintainer / Collaborator for core ecosystem repositories! 🚀
-
Role: Co-Maintainer / Collaborator & Core Developer
-
Track: Open Source Engineering Track
-
Timeline: 15 May to 14 August 2026
-
Core Responsibilities: * Managing and reviewing incoming Pull Requests (PRs) from global contributors.
- Architecting clean issue structures, templates, and documentation guidelines (e.g.,
ARCHITECTURE.md). - Mentoring junior contributors and triaging critical backend/auth workflow bugs.
- Architecting clean issue structures, templates, and documentation guidelines (e.g.,
-
Objective: Actively contributing to real-world open-source projects, optimizing C++ structures, and collaborating with global developers to build scalable infrastructure.
A modular banking engine built to compute credit eligibility, manage risk thresholds, and dynamically allocate user perks.
- Smart Risk Management: Automatically slashes the overall credit limit by 20% if the user has an active, outstanding loan profile.
- Strict Input Validation Hooks: Formatted to instantly reject anomalous data patterns such as negative age, sub-zero income inputs, or corrupted CIBIL score limit boundaries.
- Dynamic Reward Tier Allocation: - Premium Tier: High-income users with excellent CIBIL records receive a 10% boost in loyalty/travel reward points.
- Growth Tier: Users with moderate income brackets receive a 5% boost in specialized travel-centric reward tokens.
- Risk Mitigation: Automatically restricts and downgrades credit limits for profiles falling under unsafe CIBIL tiers to prevent bad debts.
A utility algorithm designed to optimize commute decisions based on environment variables and energy metrics.
- Energy Analytics: Processes active fuel levels or vehicle battery parameters to evaluate and explicitly trigger immediate refueling/recharging alerts.
- Adaptive Routing Engine: Analyzes real-time weather datasets and atmospheric hazards to dynamically shift, update, and reroute the user via optimized paths.
A comprehensive math compilation designed to handle precise arithmetic algorithms and strict geometric coordinate computations.
-
Standard Arithmetic: Securely handles addition (
+), subtraction (-), multiplication (*), and division (/) structures for positive integer and floating-point datasets. -
Geometric Coordinate Module: Evaluates and delivers both Area and Perimeter/Circumference constraints seamlessly:
-
Circle: Evaluates exact area (
$\pi r^2$ ) and circumference ($2\pi r$ ). - Square & Rectangle: Computes area and perimeter constraints via linear dimension boundaries.
- Triangle: Implements Heron's Formula to safely parse multi-case side inputs and aggregate precise area definitions.
-
Circle: Evaluates exact area (
An analytical price processing application tailored to optimize system revenue through demographic parameters.
- Implements dynamic pricing structures that realign base fares based on user age brackets and targeted booking day categories.
A console-based simulator designed to process multi-stage beverage customization routines.
- Effectively maps selections between Tea and Coffee, evaluates specialized variants based on user inputs, and computes precise, real-time preparation countdown metrics.
### 6. 🛣️ Eco-Toll Tax Calculator A smart console application designed to calculate route-based toll fees and environmental taxes using strict if-else logic.
✨ Highlights
Route Verification: Filters pricing pipelines based on whether the vehicle is on a National or State Highway. Dynamic Eco-Tax: Nested if-else blocks that analyze the vehicle's weight and mileage to compute a custom environmental tax. Pure Logical Pipeline: Zero loops, zero switch-cases—just clean, cascading conditional structures to evaluate complex tax brackets instantly.
A lightweight, high-performance terminal-based mini-RPG game engine built completely from scratch in C++. Designed to showcase clean architecture, optimized structural control flow, and strict state management.
Handles unique operative classes with specific statistical attributes and progression mechanics:
- Code-Breaker: Specialized in decryption and bypassing terminal firewall layers.
- Ghost-Walker: High stealth capabilities for undetected system infiltration.
- Cyber-Knight: Heavy-duty brute-force specialist for bypassing aggressive security countermeasures.
- Features multi-layered security levels using advanced, highly optimized nested if-else architectures.
- Simulates real-time hacking decision-making trees that adapt based on character choices and stats.
- Implements strict process control flow and error buffering via clean conditional termination (
return 0). - Zero manual memory leaks, ensuring lightweight execution that matches C++'s hardware-level speed capabilities.
- Language: C++ (Standard ISO C++)
- Paradigm: Procedural & Structural Logic Programming
- Interface: CLI (Command Line Interface / Terminal-based)
- Core Concepts: Multi-layered conditional execution, robust state routing, deterministic memory stack management.
-
Active Debugging: Codes are continuously reviewed and refactored (e.g.,
updated_fintech_credit_calculator.cpp,updatedsmart_routing.cpp) to optimize computational complexity and maintain clean naming structures. -
Data Integrity: Strict reliance on input validation structures to eliminate buffer issues and negative runtime errors.
Currently stepping into linear data structures to upgrade the existing procedural engines.
| Problem Name | Core Approach (1-2 Points) | Complexity | Status |
|---|---|---|---|
| Array Reversal | • Two-pointer technique meeting at the center. • In-place element swapping. |
|
Done |
| Two Sum | • Linear scanning or element checking target differences. • Array index tracking. |
|
Done |
| Mountain Peak | • Binary search on bitonic (increasing-decreasing) data. • Mid-element comparison with neighbors to find peak. |
|
Done |
| Rotated Sorted Search | • Modified binary search tracking array inflection points. • Identifying which half is strictly monotonic. |
|
Done |
| Square Root (BS) | • Binary search over integer search space • Mid-point squaring to match closest target. |
|
Done |
| Book Allocation | • Binary search over answer range ( • Greedy continuous allocation check for each mid-value. |
|
Done |
| Painter Partition | • Binary search over answer range (max element to total sum). • Greedy continuous allocation check for each mid-value. |
O(N log(sum)) time O(1) space |
Done |
| Aggressive Cows |
|
|
Done |
| Container With Most Water | • Two-pointer technique meeting at the center. • Area calculation based on width and minimum height. • Moving the smaller pointer inward to maximize potential area. |
O(N) time O(1) space |
Done |
| 3Sum Closest | • Sort array and fix the first element using a loop up to size - 2. • Use a two-pointer approach ( left & right) with absolute distance abs() to track the nearest sum. |
|
Done |
| Pair Sum | • Sort and Setup: Sort the given vector in ascending order to handle internal sorting constraints automatically. • Two-Pointer Traversal: Initialize two pointers s at 0 and e at n - 1. Loop while s < e to find matching pairs while handling duplicate element frequencies. |
|
Done |
- Rotated Arrays: Always locate the sorted subarray boundary before reducing the search space.
-
Book Allocation: Set
$low = \max(\text{array})$ to handle the edge case where a single heavy book exceeds the mid-limit.
- Fixed Memory Allocation: Understanding contiguous memory blocks in C++.
-
Index-Based Access:
$O(1)$ time complexity for direct element retrieval. - Bound Checking: Preventing segmentation faults and buffer overflows.
- Fintech Engine v2: Implement
std::array<int, 100>to batch-process CIBIL scores and filter high-risk profiles in a single execution pass. - Cyber Heist RPG: Store operative inventory items and security firewall layers inside a structural array for sequential decryption loops.