https://github.com/onyxwizard/coding-challenges

A collection of fundamental recursion problems solved in Java, demonstrating core concepts like base cases, recursive decomposition, and problem-solving strategies for beginners. Perfect for mastering the art of thinking recursively!
https://github.com/onyxwizard/coding-challenges

algomaster algorithm-challenges algorithms algorithms-and-data-structures coding data datastructures hackerrank java java-8 leetcode neetcode takeuforward w3schools

Last synced: about 1 hour ago
JSON representation

A collection of fundamental recursion problems solved in Java, demonstrating core concepts like base cases, recursive decomposition, and problem-solving strategies for beginners. Perfect for mastering the art of thinking recursively!

• Host: GitHub
• URL: https://github.com/onyxwizard/coding-challenges
• Owner: onyxwizard
• License: mit
• Created: 2025-10-27T11:00:36.000Z (8 months ago)
• Default Branch: main
• Last Pushed: 2026-02-25T09:57:17.000Z (4 months ago)
• Last Synced: 2026-02-25T14:36:37.671Z (4 months ago)
• Topics: algomaster, algorithm-challenges, algorithms, algorithms-and-data-structures, coding, data, datastructures, hackerrank, java, java-8, leetcode, neetcode, takeuforward, w3schools
• Language: Java
• Homepage:
• Size: 399 KB
• Stars: 0
• Watchers: 0
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

          
# 🧠 My Java Coding Practice Archive  

*— A living log of problems solved, patterns learned, and progress made*

This repository isn’t just a folder of code—it’s **my digital notebook** for mastering data structures, algorithms, and problem-solving in **Java**. Every file here represents a moment of focus, a bug I wrestled with, or a concept that finally clicked.

I started this not to impress anyone, but to **build consistency**. In a world full of tutorials and shortcuts, I wanted a space where I could *do the work*, day after day, without distraction.

## 🗂️ How It’s Organized

I’ve grouped problems by the **platform or curriculum** that inspired them:

- **`takeuforward/`**  

  Following [Striver’s SDE Sheet](https://takeuforward.org/interviews/strivers-sde-sheet-top-coding-interview-problems/) — a goldmine for DSA interview prep. Organized by topic: arrays, linked lists, trees, graphs, DP, etc.

- **`leetcode/`**  

  Classic LeetCode problems, named with their number and title (e.g., `0001-two-sum/`). I solve these to sharpen my logic and prepare for real interview scenarios.

- **`neetcode/`**  

  Based on the [NeetCode 150](https://neetcode.io/) list — a curated set of the most important problems. Grouped by NeetCode’s own categories like “Arrays & Hashing” or “Backtracking”.

- **`hackerrank/`**  

  Mostly from HackerRank’s *Algorithms* and *Data Structures* tracks. Great for foundational practice and timed challenges.

Inside each, you’ll find:

```

platform/

└── topic/

    └── problem-name/

        └── Solution.java

```

Every `Solution.java` is **self-contained**, includes comments explaining my approach, and often has a `main()` method with sample test cases so I can run it instantly.

## ☕ Why Java?

I chose Java because:

- It’s what I use daily (or aim to).

- Its strong typing helps me think clearly about data.

- It’s widely used in enterprise and interviews.

- Writing clean, object-oriented Java forces discipline.

No Python shortcuts here—just deliberate practice in the language I want to master.

## 📈 What This Repo Tracks (For Me)

This isn’t about solving 1000 problems. It’s about **deep understanding**. For each problem, I ask:

- What’s the brute force?  

- Can I optimize time or space?  

- Have I seen this pattern before?  

- How would I explain this in an interview?

Over time, I hope to see:

- Fewer “I’ve seen this before!” moments → more “I can derive this!” moments  

- Cleaner code with less boilerplate  

- Faster recognition of problem types (sliding window, DFS vs BFS, DP states, etc.)

## 🛠️ How I Use It

1. **Daily Practice**: Pick 1–2 problems based on my current focus area.  

2. **Review Weekly**: Revisit old solutions—can I improve them?  

3. **Run Locally**:  

   ```bash

   cd leetcode/0020-valid-parentheses/

   javac Solution.java && java Solution

   ```

4. **Commit with Context**:  

   My commit messages often include notes like:  

   _“Solved using stack — remembered the pattern from NeetCode!”_

## 🌱 This Is a Work in Progress

Some solutions are elegant. Others are… functional.  

Some folders are full. Others are empty—waiting for me to show up tomorrow.

>And that’s okay.  

This repo isn’t perfect.  

**It’s alive.**

As long as I’m learning, it’s serving its purpose.

*Last updated: October 27, 2025*  

*Next goal: Patterns `takeuforward/`*  

> 💬 **To future me**:  

> *Don’t skip the hard ones. Don’t compare your Day 30 to someone else’s Day 300. Just keep writing `Solution.java`.*