https://github.com/ehab-elshimi-developer/java-problem-solving-sheets
Scalable Java problem-solving sheets — modular, backend-ready, clean-coded, and mindset-driven. Designed to simulate real-world engineering challenges.
https://github.com/ehab-elshimi-developer/java-problem-solving-sheets
algorithms backend-development clean-code data-structures design-patterns engineering-mindset exception-handling java modularization multithreading oop oop-in-java problem-solving solid-principles
Last synced: 2 months ago
JSON representation
Scalable Java problem-solving sheets — modular, backend-ready, clean-coded, and mindset-driven. Designed to simulate real-world engineering challenges.
- Host: GitHub
- URL: https://github.com/ehab-elshimi-developer/java-problem-solving-sheets
- Owner: ehab-elshimi-developer
- Created: 2025-07-09T08:24:03.000Z (3 months ago)
- Default Branch: main
- Last Pushed: 2025-08-06T17:18:07.000Z (2 months ago)
- Last Synced: 2025-08-06T19:19:53.592Z (2 months ago)
- Topics: algorithms, backend-development, clean-code, data-structures, design-patterns, engineering-mindset, exception-handling, java, modularization, multithreading, oop, oop-in-java, problem-solving, solid-principles
- Language: Java
- Homepage:
- Size: 24.4 KB
- Stars: 1
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
Awesome Lists containing this project
README
# 🧠 Java Training Hub – Problem Solving Sheets (1 to ∞)
🚀 A comprehensive and ever-growing repository for mastering Java programming through structured **problem-solving sheets** and backend-focused exercises.
This is part of my continuous journey to become a highly capable **Backend Java Developer**, building strong mental foundations in:
- Java Syntax & Core Principles
- OOP & Design Patterns
- Data Structures & Algorithms
- Multithreading & Concurrency
- Clean Code, SOLID, and Software Craftsmanship
---
## 📘 Overview
This repository is structured into a series of progressive **Java Problem Solving Sheets**, starting from basic syntax and gradually advancing toward complex backend logic and real-world systems.
Each problem is solved using **clean, modular, testable Java code**, written in a way that promotes **deep understanding, reusability**, and **engineering discipline**.
> 🧠 Think of each sheet as a level in your mental gym – and the gym never closes.
---
## 🚀 Topics & Skills Covered
- ✅ **Basic Syntax & Variables** – Java fundamentals, data types, operators
- ✅ **Control Flow** – `if/else`, loops, switch-case
- ✅ **Functions & Recursion** – Modular programming and recursive strategies
- ✅ **Arrays & Data Structures** – Arrays, Lists, Stacks, Queues, HashMaps, Sets
- ✅ **Object-Oriented Programming (OOP)** – Encapsulation, Inheritance, Polymorphism, Abstraction
- ✅ **Design Patterns** – Singleton, Factory, Strategy, and more
- ✅ **Exception Handling** – Robust error management & custom exceptions
- ✅ **Algorithms** – Searching, Sorting, Problem Solving
- ✅ **Multithreading** – Concurrency models and real-world thread use
- ✅ **Clean Code & SOLID Principles** – Write for humans, not just machines
- ✅ **Modularization** – Reusable components with separation of concerns
---
## 📁 Folder Structure
The structure is open-ended and infinitely extensible:
src/
├─ sheet1/
│ ├─ Sh1Pr1.java
│ ├─ Sh1Pr2.java
│ └─ ...
├─ sheet2/
│ └─ ...
└─ sheetN/
Each sheet includes:
- 📄 **Well-named Java classes** (e.g., `Sh5Pr2.java`)
- 🧠 **Inline problem descriptions** where applicable
- 🧪 **Testable & clean implementations** with modular design
- 🧱 Built to reflect **real backend workflows** and encourage scalability
> ♾️ The sheet count keeps growing as learning continues.
---
## 🧩 Sample Problems
### 🔸 Basic Syntax & Logic
- Hello World
- Swap Without Temp
- Even or Odd
- Find Largest of 3
- Sum of Digits
### 🔸 Control Flow
- Factorial with Loops
- Prime Number Detection
- Reverse Digits
- Fibonacci Sequence
- Armstrong Number Check
---
## 📊 Infinite Progress Tracker
| Sheet | Status | Focus Area |
|-----------|---------------|----------------------------------------|
| Sheet 1 | ✅ Completed | Java basics & intro problems |
| Sheet 2 | ✅ Completed | Arrays & simple data structure use |
| Sheet 3 | ✅ Completed | Strings & char manipulation |
| Sheet 4 | ✅ Completed | Patterns, nested loops |
| Sheet 5 | ✅ Completed | 2D Arrays, matrices |
| Sheet 6 | 🟡 In Progress | Matrix logic & deeper conditions |
| Sheet 7 | ⏳ Upcoming | Intermediate structures & sorting |
| Sheet 8 | ⏳ Upcoming | Recursion & OOP combinations |
| Sheet 9 | ⏳ Upcoming | Dynamic programming & analysis |
| Sheet 10+ | ♾️ Endless | Real-world backend & architecture |
> 🔁 The tracker reflects continuous improvement — not a final destination.
---
## 🔮 What's Next?
This hub will keep expanding with:
- ✨ **Recursive Problem Solving & Memoization**
- ✨ **Data Structures from Scratch** – Linked Lists, Trees, HashMaps
- ✨ **Multithreading Challenges** – Runnable, Threads, Sync
- ✨ **File Handling & Stream APIs**
- ✨ **JUnit & Integration Testing**
- ✨ **Mini Backend Systems** – CLI projects, service layers, modular logic
- ✨ **Controller-based Architecture** – Preparing for scalable backend design
> 🎯 **Goal:** Build the mindset and codebase of a real software engineer — not just a student.
---
## 🛠 Getting Started
### 1. Clone the Repository
```bash
git clone https://github.com/ehab-elshimi-developer/java-problem-solving-sheets.git
```
### 2. Open in Your Preferred Java IDE
💡 **Recommended**: [IntelliJ IDEA](https://www.jetbrains.com/idea/) or [VS Code](https://code.visualstudio.com/) with **Java Extension Pack**
---
### 3. Explore & Run
This repository follows a **modular, auto-scalable structure** powered by `Generator.java`.
Each set of problems is organized into folders:
```
src/
├─ sheet1/
│ ├─ Sh1Pr1.java
│ ├─ Sh1Pr2.java
│ └─ ...
├─ sheet2/
│ └─ ...
└─ ...
```
✅ **Naming Convention**
`ShXPrY.java` → where `X = sheet number`, `Y = problem number`
---
### 🔁 Run a Specific Problem
Update `Main.java`:
```java
runProblem(6, 4); // Executes sheet6.Sh6Pr4
```
---
### 🔄 Run a Full Sheet
```java
testGeneratedSheet(6); // Executes Sh6Pr1 to Sh6Pr10
```
🧪 **Reflection** is used to dynamically load and invoke the `.run()` method of each class.
---
### ⚙️ Use the Generator
Run `Generator.java` to:
- 🔍 Detect the latest existing sheet
- 🆕 Create the next sheet automatically (e.g., `sheet7/`)
- 🧱 Generate files like `Sh7Pr1.java` to `Sh7Pr6.java`
- 🛠️ Update `Main.java` for immediate execution
🧭 Whether you're starting with syntax or diving into algorithms — just generate and go.
---
## 🏷️ Tags
`Java` `Problem Solving` `Backend Development` `OOP`
`Data Structures` `Algorithms` `Multithreading` `Design Patterns`
`SOLID Principles` `Clean Code` `Modularization` `Exception Handling` `Reflection`
---
## 🤝 Contributing
This repo is part of a **personal learning journey** — but open to evolution.
If you’d like to:
- 💡 Suggest a new challenge
- 🛠 Improve an existing solution
- 🐞 Fix a bug
- ✨ Refactor structure or readability
Feel free to:
- 📥 [Open an Issue](https://github.com/ehab-elshimi-developer/java-problem-solving-sheets/issues)
- 🔁 [Submit a Pull Request](https://github.com/ehab-elshimi-developer/java-problem-solving-sheets/pulls)
🙌 **All contributions are welcome!**
---
## 👨💻 Author
**Ehab Elshimi**
🎯 *Aspiring Backend Java Developer*
📍 *Egypt – Preparing for European opportunities*
💡 *Passionate about clean architecture & scalable systems*
📬 [ehabelshimi.dev@gmail.com](mailto:ehabelshimi.dev@gmail.com)
🌐 [@ehab-elshimi-developer](https://github.com/ehab-elshimi-developer)
---
> 🧠 *"Train your mind to solve problems like an engineer. Write code like you’re building a system, not just passing a test."*
> — **Ehab Elshimi** 🚀
