# onyxwizard/coding-challenges architecture

> Architecture diagram of the GitHub repository onyxwizard/coding-challenges, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-05-20). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/onyxwizard/coding-challenges
- Repository: https://github.com/onyxwizard/coding-challenges

## Overview

This repository is a **personal DSA practice archive**, not a single application. Its architecture is a set of **independent study tracks** organized by learning source and topic, with most code written as **standalone solutions** rather than shared modules.

1. **Top-level partitioning by curriculum/source**
   The root folders represent separate learning streams: `takeuforward/`, `Leetcode/`, `Geeks/`, `codin patterns/`, `neetcode/`, and `thita/`. Each stream has its own internal taxonomy and is effectively isolated from the others.

2. **Primary artifact types**
   The repo mixes three content types:
   - **Java source files** for algorithm implementations
   - **SQL scripts** for database problems
   - **Markdown files** for problem statements, notes, and chapter READMEs  
   This makes the repo a hybrid of code notebook and problem catalog.

3. **Self-contained solution model**
   Most solution files are intended to compile/run on their own and do not appear to depend on a shared library or common package structure. That implies a **loose coupling boundary**: each problem folder is a unit of work.

4. **LeetCode as a problem-solution catalog**
   `Leetcode/` is structured by topic and difficulty rather than by application domain. It contains:
   - algorithm topics under `Quest/Data Structures and Algorithms/...`
   - SQL practice under `sql50/` and `Quest/Database/...`  
   The data flow here is usually: **problem statement markdown → Java/SQL solution file** in the same folder.

5. **Coding patterns library**
   `codin patterns/` is the most systematic algorithm taxonomy. It groups problems by technique:
   - Arrays
   - Prefix Sum
   - Sliding Window
   - Two Pointers
   - Kadane / Monotonic / Stack subpatterns  
   This looks like a reusable **pattern reference library**, where each leaf folder pairs one problem statement with one Java implementation.

6. **TakeUForward / Striver notes and exercises**
   `takeuforward/striver_AZ_cheatsheet/` is organized as a curriculum: basics, recursion, hashing, patterns, sorting. It includes many numbered exercises with corresponding markdown explanations. This track is more pedagogical than the LeetCode folders and reads like a guided syllabus.

7. **GeeksForGeeks-oriented practice**
   `Geeks/DSA/` is split into chapters such as logic, strings, linked lists, and arithmetic/number theory interview problems. This area is closer to textbook-style grouping, with solutions for fundamental operations and introductory algorithm drills.

8. **Foundational learning notes**
   `Data Structures for java/0 Foundations/` and `thita/dsa_fundamentals/` contain chapter-level README/problem documents rather than a large volume of code. These folders function as **conceptual scaffolding**: hierarchy, core principles, generics, complexity, memory layout, number theory.

9. **NeetCode folder is sparse and strategic**
   `neetcode/coreskill/ImplementDataStructures/` suggests a targeted collection focused on implementation-oriented core skills. It appears smaller and more curated than the LeetCode/TakeUForward tracks.

10. **No central runtime or build layer**
   There is no sign of a shared Java project structure, dependency manager, or application entry point. The architecture is therefore **repository-of-examples**, not a deployable system. The “runtime” boundary is usually a single file or folder.

11. **Documentation is part of the structure**
   Markdown files are not just comments; they define the problem context and learning intent. In many folders, the pairing of `*.md` with `*.java` or `*.sql` is the core unit of architecture.

12. **Overall data flow**
   The implicit flow is:
   **curriculum/problem source → topic folder → problem statement/notes → solution implementation**
   There is little cross-folder data sharing; instead, knowledge transfers through repeated pattern practice.

13. **Operational characteristics**
   The repo is designed for iterative manual use: pick a problem, read the markdown, open the solution, run it locally if needed, then archive the result. This favors **discoverability and repetition** over abstraction and reuse.

14. **Diagramming implication**
   If you draw this repository, treat it as a **multi-track knowledge system** with parallel branches for each platform/curriculum, and leaf nodes composed of problem statements plus standalone solutions. The most important boundaries are between curricula, between topics, and between documentation and implementation.

Main entry points: [`codin patterns/topics/Arrays`](https://github.com/onyxwizard/coding-challenges/tree/HEAD/codin%20patterns/topics/Arrays) (Array patterns), [`takeuforward/striver_AZ_cheatsheet`](https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet) (Striver AZ), [`Leetcode/Quest`](https://github.com/onyxwizard/coding-challenges/tree/main/Leetcode/Quest) (LeetCode Quest), [`Data Structures for java`](https://github.com/onyxwizard/coding-challenges/tree/HEAD/Data%20Structures%20for%20java) (Data Structures for java)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_group_foundations["Foundations"]
  node_node_foundations["Data Structures for java<br/>notes track"]
end

subgraph group_group_geeks["Geeks"]
  node_node_geeks["Geeks DSA<br/>practice track"]
end

subgraph group_group_leetcode["LeetCode"]
  node_node_leetcode["LeetCode Quest<br/>problem catalog"]
  node_node_leetcode_dsa["Algo quest<br/>algo topics"]
  node_node_leetcode_sql[("SQL practice<br/>sql catalog")]
end

subgraph group_group_patterns["Coding patterns"]
  node_node_patterns["Coding patterns<br/>pattern library"]
  node_node_tp_arrays["Array patterns<br/>array techniques"]
  node_node_tp_prefix["Prefix sum<br/>subpattern set"]
  node_node_tp_slide["Sliding window<br/>subpattern set"]
  node_node_tp_twop["Two pointers<br/>subpattern set"]
end

subgraph group_group_takeuforward["TakeUForward"]
  node_node_takeu["Striver AZ<br/>curriculum track"]
  node_node_takeu_rec["Recursion<br/>lesson set"]
  node_node_takeu_basic["Basics<br/>starter set"]
  node_node_takeu_sort["Sorting"]
end

subgraph group_group_neetcode["NeetCode"]
  node_node_neetcode["NeetCode core<br/>curated track"]
end

subgraph group_group_thita["Thita"]
  node_node_thita["Thita fundamentals<br/>concept notes"]
end

node_node_root["Repo archive<br/>DSA archive"]

node_node_root -->|"contains"| node_node_foundations
node_node_root -->|"contains"| node_node_geeks
node_node_root -->|"contains"| node_node_leetcode
node_node_root -->|"contains"| node_node_patterns
node_node_root -->|"contains"| node_node_takeu
node_node_root -->|"contains"| node_node_neetcode
node_node_root -->|"contains"| node_node_thita
node_node_foundations -->|"aligns with"| node_node_thita
node_node_geeks --> node_node_geeks
node_node_leetcode -->|"organizes"| node_node_leetcode_dsa
node_node_leetcode -->|"organizes"| node_node_leetcode_sql
node_node_leetcode_dsa -->|"mirrors"| node_node_patterns
node_node_patterns -->|"contains"| node_node_tp_arrays
node_node_tp_arrays -->|"includes"| node_node_tp_prefix
node_node_tp_arrays -->|"includes"| node_node_tp_slide
node_node_tp_arrays -->|"includes"| node_node_tp_twop
node_node_takeu -->|"contains"| node_node_takeu_rec
node_node_takeu -->|"contains"| node_node_takeu_basic
node_node_takeu -->|"contains"| node_node_takeu_sort
node_node_takeu_basic -->|"prereq"| node_node_takeu_rec
node_node_neetcode -->|"overlaps"| node_node_tp_twop
node_node_thita -->|"complements"| node_node_foundations

click node_node_foundations "https://github.com/onyxwizard/coding-challenges/tree/main/Data Structures for java"
click node_node_geeks "https://github.com/onyxwizard/coding-challenges/tree/main/Geeks/DSA"
click node_node_leetcode "https://github.com/onyxwizard/coding-challenges/tree/main/Leetcode/Quest"
click node_node_leetcode_dsa "https://github.com/onyxwizard/coding-challenges/tree/main/Leetcode/Quest/Data Structures and Algorithms"
click node_node_leetcode_sql "https://github.com/onyxwizard/coding-challenges/tree/main/Leetcode/sql50"
click node_node_patterns "https://github.com/onyxwizard/coding-challenges/tree/main/codin patterns"
click node_node_tp_arrays "https://github.com/onyxwizard/coding-challenges/tree/main/codin patterns/topics/Arrays"
click node_node_tp_prefix "https://github.com/onyxwizard/coding-challenges/tree/main/codin patterns/topics/Arrays/PrefixSum"
click node_node_tp_slide "https://github.com/onyxwizard/coding-challenges/tree/main/codin patterns/topics/Arrays/SlidingWindow"
click node_node_tp_twop "https://github.com/onyxwizard/coding-challenges/tree/main/codin patterns/topics/Arrays/TwoPointers"
click node_node_takeu "https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet"
click node_node_takeu_rec "https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet/basic/Recursion"
click node_node_takeu_basic "https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet/basic"
click node_node_takeu_sort "https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet/sorting"
click node_node_neetcode "https://github.com/onyxwizard/coding-challenges/tree/main/neetcode/coreskill/ImplementDataStructures"
click node_node_thita "https://github.com/onyxwizard/coding-challenges/tree/main/thita/dsa_fundamentals"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_node_foundations,node_node_thita toneBlue
class node_node_geeks toneAmber
class node_node_leetcode,node_node_leetcode_dsa,node_node_leetcode_sql toneMint
class node_node_patterns,node_node_tp_arrays,node_node_tp_prefix,node_node_tp_slide,node_node_tp_twop toneRose
class node_node_takeu,node_node_takeu_rec,node_node_takeu_basic,node_node_takeu_sort toneIndigo
class node_node_neetcode toneTeal
class node_node_root toneNeutral
```

## Components

### Foundations

Conceptual learning notes and chapter-based docs.

- [Data Structures for java](https://github.com/onyxwizard/coding-challenges/tree/HEAD/Data%20Structures%20for%20java): notes track · Foundational Java data-structures notes organized into chapters. · `Data Structures for java`

### Geeks

GeeksForGeeks-style DSA drills organized by chapter.

- [Geeks DSA](https://github.com/onyxwizard/coding-challenges/tree/main/Geeks/DSA): practice track · Chapter-based practice set with basic algorithms and interview drills. · `Geeks/DSA`

### LeetCode

Problem catalog split by algorithm and SQL practice.

- [LeetCode Quest](https://github.com/onyxwizard/coding-challenges/tree/main/Leetcode/Quest): problem catalog · LeetCode solutions organized by topic and database practice. · `Leetcode/Quest`
- [Algo quest](https://github.com/onyxwizard/coding-challenges/tree/HEAD/Leetcode/Quest/Data%20Structures%20and%20Algorithms): algo topics · Algorithm problems grouped under linear-scan style topic folders. · `Leetcode/Quest/Data Structures and Algorithms`
- [SQL practice](https://github.com/onyxwizard/coding-challenges/tree/main/Leetcode/sql50): sql catalog · Database exercises and SQL50 query solutions. · `Leetcode/sql50`

### Coding patterns

Technique-first algorithm reference library.

- [Coding patterns](https://github.com/onyxwizard/coding-challenges/tree/HEAD/codin%20patterns): pattern library · Technique-centric catalog of reusable problem patterns. · `codin patterns`
- [Array patterns](https://github.com/onyxwizard/coding-challenges/tree/HEAD/codin%20patterns/topics/Arrays): array techniques · Array-focused pattern families such as prefix sum, sliding window, and two pointers. · `codin patterns/topics/Arrays`
- [Prefix sum](https://github.com/onyxwizard/coding-challenges/tree/HEAD/codin%20patterns/topics/Arrays/PrefixSum): subpattern set · Prefix-sum, difference-array, hashmap, and binary-search variants. · `codin patterns/topics/Arrays/PrefixSum`
- [Sliding window](https://github.com/onyxwizard/coding-challenges/tree/HEAD/codin%20patterns/topics/Arrays/SlidingWindow): subpattern set · Fixed and dynamic window templates for arrays and strings. · `codin patterns/topics/Arrays/SlidingWindow`
- [Two pointers](https://github.com/onyxwizard/coding-challenges/tree/HEAD/codin%20patterns/topics/Arrays/TwoPointers): subpattern set · Fast/slow, opposite-direction, same-direction, partitioning, and array-pair patterns. · `codin patterns/topics/Arrays/TwoPointers`

### TakeUForward

Striver syllabus and guided exercises.

- [Striver AZ](https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet): curriculum track · Guided syllabus for basics, hashing, recursion, patterns, and sorting. · `takeuforward/striver_AZ_cheatsheet`
- [Recursion](https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet/basic/Recursion): lesson set · Intro recursion exercises with matching explanations and Java solutions. · `takeuforward/striver_AZ_cheatsheet/basic/Recursion`
- [Basics](https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet/basic): starter set · Core starter exercises including hashing and pattern printing. · `takeuforward/striver_AZ_cheatsheet/basic`
- [Sorting](https://github.com/onyxwizard/coding-challenges/tree/main/takeuforward/striver_AZ_cheatsheet/sorting): sorting track · Comparison and recursive sorting implementations. · `takeuforward/striver_AZ_cheatsheet/sorting`

### NeetCode

Small curated core-skill track.

- [NeetCode core](https://github.com/onyxwizard/coding-challenges/tree/main/neetcode/coreskill/ImplementDataStructures): curated track · Small implementation-oriented core skills collection. · `neetcode/coreskill/ImplementDataStructures`

### Thita

Foundational DSA notes and concept scaffolding.

- [Thita fundamentals](https://github.com/onyxwizard/coding-challenges/tree/main/thita/dsa_fundamentals): concept notes · Chapter-level foundational notes on complexity, memory, and arithmetic. · `thita/dsa_fundamentals`

### Other components

- **Repo archive**: DSA archive · A multi-track personal practice repository with standalone solutions and notes.

## Connections

- Repo archive → Data Structures for java: contains · Top-level learning track for foundational Java structures.
- Repo archive → Geeks DSA: contains · Top-level DSA practice branch.
- Repo archive → LeetCode Quest: contains · Top-level LeetCode practice branch.
- Repo archive → Coding patterns: contains · Top-level coding-pattern library.
- Repo archive → Striver AZ: contains · Top-level Striver curriculum branch.
- Repo archive → NeetCode core: contains · Top-level NeetCode core-skill branch.
- Repo archive → Thita fundamentals: contains · Top-level conceptual notes branch.
- Data Structures for java → Thita fundamentals: aligns with · Both areas are chapter-based learning scaffolds.
- Geeks DSA → Geeks DSA: Internal practice chapters include strings and logic drills.
- LeetCode Quest → Algo quest: organizes · Algorithm quest content lives under the DSA subtree.
- LeetCode Quest → SQL practice: organizes · Separate subtree for SQL practice and query problems.
- Algo quest → Coding patterns: mirrors · LeetCode algorithm topics overlap with reusable pattern families.
- Coding patterns → Array patterns: contains · Array techniques are the central pattern family.
- Array patterns → Prefix sum: includes · Prefix-sum, difference-array, and related variants.
- Array patterns → Sliding window: includes · Sliding window templates for arrays and strings.
- Array patterns → Two pointers: includes · Two-pointer variants and linked-list fast/slow patterns.
- Striver AZ → Recursion: contains · Recursion is a major guided subsection.
- Striver AZ → Basics: contains · Basic exercises group foundational drills.
- Striver AZ → Sorting: contains · Sorting lessons form a later subsection.
- Basics → Recursion: prereq · Basic reasoning supports the recursion exercises.
- NeetCode core → Two pointers: overlaps · Core skills collection likely focuses on implementation patterns.
- Thita fundamentals → Data Structures for java: complements · Both are conceptual foundations rather than solution catalogs.
