This repository contains my daily practices, algorithmic solutions, and logic challenges developed while completing the JavaScript Algorithms and Data Structures certification from freeCodeCamp.
The focus of this space is strictly aligned with software engineering core values: writing clean, dry, optimized, and scalable code prepared to integrate with modern architectures and Artificial Intelligence solutions.
- Algorithmic Thinking: Mastering complex problem-solving by breaking down logic into efficient, reusable code blocks.
- Data Structuring: Understanding advanced memory management, storage, and data manipulation (Objects, Arrays, Maps, and Matrices).
- AI Readiness: Consolidating the fundamental asynchronous logic and data pipeline mechanics required to consume APIs and integrate AI models.
This repository serves as the logical backbone of my Frontend technical stack. All programming mechanics developed here connect directly with the modern semantic layouts and responsive constraints implemented in my portfolio:
- Dynamic DOM Manipulation: Gaining absolute control over the document tree to transform static interfaces into interactive web applications.
- Performance Optimization: Implementing programmatic best practices to guarantee minimal execution runtime and clean code architecture.
| Module / Project | Logical Description & Scope | Core Technologies & Skills |
|---|---|---|
| 001-build-a-javascript-trivia-bot | Implemented a static trivia assistant using variable registration (let) and continuous string concatenation. Engineered to output dynamic text blocks derived from variable data manipulation. |
Variables (let), String Concatenation, Data Output (console.log) |
| 002-build-a-sentence-maker | Developed a dynamic Mad Libs-style narrative engine. Leveraged variable mutability to reuse pointers, override string literals sequentially, and dynamically reconstruct structural content blocks within runtime. | Variable Reassignment, Data Mutability, String Interpolation Mechanics |
| 003-debug-type-coercion-errors | Resolved logical bugs in an arithmetic evaluation app by identifying and mitigating implicit type coercion. Refactored mixed-type expressions (booleans, strings, and null values) into explicit numeric types to ensure strict mathematical accuracy. | Type Coercion, Data Types, Explicit Casting, Debugging |
| 004-debug-increment-and-decrement-operator-errors-in-a-buggy-app | Refactored evaluation errors caused by misuse of prefix and postfix arithmetic operators. Analyzed memory state mutation timing to ensure correct variable assignment and sequence control within operations. | Prefix Operators, Postfix Operators, State Mutation, Variable Reassignment |
| 005-build-a-fortune-teller | Engineered a randomized prediction engine utilizing pseudo-random number generation (Math.random). Implemented conditional control flow structures (if/else if/else) and strict equality comparison (===) to map numeric states to corresponding predefined string variables. |
Math Object, Pseudo-Randomness, Conditional Logic, Strict Equality (===) |
| 006-build-a-boolean-check-function | Engineered a precise validation function to determine primitive boolean types. Opted for explicit type evaluation using the typeof operator to guarantee minimal execution overhead and eliminate structural syntax redundancy over verbose conditional branches. |
Type Assessment, Operator typeof``, Logical Optimization, `Data Verification` |
| 007-build-an-email-masker | Developed a data privacy utility to dynamically mask email addresses while leaving boundary characters intact. Utilized .indexOf() for dynamic token parsing, .slice() for precise string segmentation, and .repeat() to generate scalable, variable-length data masking clusters. |
String Extraction, Dynamic Indexing, Data Anonymization, Boundary Control |
| 008-build-a-celsius-to-fahrenheit-converter | Engineered an algorithmic conversion utility using precise thermodynamic formulas. Optimized numerical operations by executing direct calculations directly inside the return statement to minimize cognitive overhead and ensure maximum execution efficiency. | Mathematical Operators, Function Parameters, Algorithmic Efficiency, Direct Return |
| 009-build-a-card-counting-assistant | Developed a live state-tracking blackjack assistant. Leveraged global state persistence to maintain an accumulating counter across sequential function executions, implemented atomic mutations via arithmetic prefix operators, and utilized .includes() array lookups combined with logical NOT inversion (!) for early-return input validation and clean conditional branching to enforce dynamic data output. |
Global Scope, State Persistence, Prefix/Postfix Timing, Array .includes()``, Conditional Branching |
| 010-build-a-leap-year-calculator | Engineered a date-validation utility to determine leap years based on gregorian calendar constraints. Combined multiple conditional sub-statements via logical operators (&&, ||) to evaluate multi-tiered divisibility rules, applying explicit memory state checks to bypass implicit coercion and eliminate hardcoded dependencies. |
Logical Operators (&&, ||), Nested Control Flows, Algorithmic Edge Cases, Dynamic Parameterization |
| 011-build-a-string-truncator | Implemented a data-sanitization utility designed to truncate string literals based on maximum character thresholds. Leveraged the native .length evaluation property alongside precise dynamic indexing via .slice() to truncate long data payloads and append truncation indicators ("...") without mutating short immutable strings. |
String Segmentation, .length Property, .slice() Method, Data Sanitization |
| 012-confirm-the-ending | Engineered an algorithm to verify string boundaries without relying on higher-level ECMAScript 6 helper methods (like .endsWith()). Utilized dynamic negative indexing via the .slice() method to extract and isolate sub-strings from the tail end of data payloads, performing strict-equality validation over literal character streams. |
String Boundary Analysis, Negative Array Indexing, Memory Sub-string Slicing, Strict Structural Equality |
| 013-build-a-lunch-picker-program | Developed a memory collection management utility manipulating list states via native array mutators (.push(), .pop(), .shift(), .unshift()). Secured mutation paths by implementing structural protection clauses via structural boundary validation (.length === 0), isolated memory extraction with .slice(0), and calculated non-deterministic selections using algebraic formulas over Math.random(). |
Array Mutation Methods, Boundary Protection Clauses, Array Stringification, Pseudo-Random Selection |
| 014-build-a-golf-score-translator | Engineered an algorithmic translator mapped to standard sporting score thresholds. Leveraged dynamic numeric evaluations (strokes <= par - 2) alongside an isolated global string array matrix, bypassing dense multi-line scopes through single-line short-circuit expressions to ensure a clean, high-performance logical architecture. |
Conditional Cascades, Matrix Index Lookup, Single-Line Code Blocks, Arithmetic Evaluators |
| 015-build-a-cargo-manifest-validator | Engineered a robust multi-tiered data validation engine designed to sanitize complex object structures using shallow copies ({ ...obj }) to prevent global state mutation. Implemented structural protection clauses via strict key lookup evaluation (in operator), explicit primitive type checks (typeof, Number.isInteger), and isolated error accumulation objects. Optimized execution paths by replacing generic reference evaluations with native meta-programming validation (Object.keys().length) to verify schema compliance before triggering downstream operational states. | Object Destruction/Spreading, Shallow Copying, The in Operator, Object Meta-programming (Object.keys), Input Sanitization & Data Integrity |
- freeCodeCamp: JavaScript Algorithms and Data Structures (In Progress — Started: September 2026)
- freeCodeCamp: Responsive Web Design (Completed)
- Core Language: Modern JavaScript (ECMAScript 6+)
- Testing Environments: Browser Developer Tools / Native freeCodeCamp Suite
- Methodologies: Functional Programming, Object-Oriented Programming (OOP), Search & Sort Algorithms, Data Mutation Mitigation.
📂 Source code and logic architecture under constant optimization. Track my continuous growth across my public repositories!