LER_DSA -- Learn, Execute, Repeat

A beginner-friendly 30-day coding-interview curriculum with Java as the primary language and Python as a guided secondary language.

What This Repository Is

LER_DSA teaches reusable problem-solving patterns instead of isolated answers. It combines:

• plain-language concept notes
• runnable Java templates
• focused Java-to-Python comparisons
• a realistic day-by-day study plan
• spaced revision and timed practice
• OOP and data-structure design foundations
• optional advanced topics for company-specific preparation

The curriculum covers the core DSA patterns commonly used in product-company and FAANG-style coding interviews. It does not promise that one month or one problem list can guarantee an offer or cover every possible company question. It gives you a structured foundation and a way to measure readiness honestly.

Start Here

1. Read START_HERE.md for the module map.
2. Follow STUDY_PLAN_DETAILED.md from Day 1.
3. Record every attempt in progress_tracker.md.
4. Use PATTERN_RECOGNITION_GUIDE.md only when you cannot identify the approach.
5. Use JAVA_CHEATSHEET.md and PYTHON_DSA_CHEATSHEET.md as lookups, not books to memorize.

For each module:

Concept -> one relevant template -> two core problems -> Python translation
        -> log mistakes -> cold redo after 3, 7, and 14 days

Sprint at a Glance

• Timeline: 30 study days
• Pace: about 2 hours on regular days and 4 hours on deep-work days
• Core target: 65 to 70 honest attempts, including cold redos
• Stretch target: 85 to 90 only when revision is complete
• Main language: Java
• Python goal: translate the important collections and templates confidently

Week 1: Array Patterns

Big-O, collections, arrays, hashing, prefix sum, two pointers, sliding window, and binary search.

Week 2: Linear Structures

Stacks, monotonic structures, linked lists, recursion, backtracking, strings, matrix, and OOP basics.

Week 3: Non-Linear Structures

Trees, BST, heaps, greedy, intervals, and graph traversal.

Week 4: Optimization and Design

Topological sort, Union-Find, Dijkstra, dynamic programming, tries, bits, design-style problems, OOP, advanced-pattern survey, and final mocks.

Repository Map

LER_DSA/
|
|-- START_HERE.md                    Beginner entry point and module order
|-- STUDY_PLAN_DETAILED.md           Exact 30-day core/optional schedule
|-- progress_tracker.md              Attempts, revisions, weak topics, mocks
|-- PATTERN_RECOGNITION_GUIDE.md     Simple SPACE scan and 16 pattern cards
|-- PROBLEM_SOLVING_FRAMEWORK.md     Brute force to optimized solution process
|-- COVERAGE_AUDIT.md                Honest coverage, gaps, and priorities
|-- JAVA_CHEATSHEET.md               Java interview syntax lookup
|-- PYTHON_DSA_CHEATSHEET.md         Java-to-Python DSA mapping
|-- COMMON_MISTAKES.md               Debugging and edge-case checklist
|-- INTERVIEW_COMMUNICATION.md       How to explain while solving
|-- INTERVIEW_TIPS.md                Preparation outside individual problems
|
|-- 00_fundamentals/                 Big-O and Java collections
|-- 01_arrays_and_hashing/
|-- 02_two_pointers/
|-- 03_sliding_window/
|-- 04_binary_search/
|-- 05_stacks_and_queues/
|-- 06_linked_lists/
|-- 07_recursion_and_backtracking/
|-- 08_trees/
|-- 09_heaps/
|-- 10_graphs/
|-- 11_dynamic_programming/
|-- 12_greedy/
|-- 13_intervals/
|-- 14_tries/
|-- 15_bit_manipulation/
|-- 16_math_and_stats/
|-- 17_union_find/
|-- 18_strings/
|-- 19_sorting_and_matrix/
|-- 20_design/
|-- 21_oop/                          Paired Java and Python OOP examples
|-- 22_advanced_extensions/          Optional post-sprint algorithms

Each DSA module has a Concepts.md and a runnable Patterns.java. The concept file now links to its prerequisite, code reference, next module, and the relevant Python difference.

The Rule That Makes the Sprint Work

A problem is not learned when the editorial makes sense. It is learned when you can later recognize, explain, code, and test it without the editorial.

Use these ratings:

• [S]: solved independently within interview time
• [H]: needed a hint
• [L]: needed the main idea or solution
• [R]: later redone independently

Every [H] and [L] belongs in the revision queue.

Readiness Signals

After the sprint, you are ready for focused interview practice when you can:

• recognize most core patterns in 3 to 5 minutes
• solve common easies in 10 to 15 minutes
• solve many familiar mediums in 25 to 35 minutes
• explain the brute force, invariant, and complexity clearly
• produce syntactically correct Java and test edge cases without IDE dependence
• redo misses cold
• translate Java maps, sets, deques, heaps, node classes, graph traversal, and memoization into Python

For experienced roles, prepare system design, CS fundamentals, project depth, and behavioral evidence separately. DSA is only one part of the process.

If You Have Less or More Time

• Less time: solve only the core problems and keep every review day.
• More time: add optional problems from the current module.
• Core feels weak after Day 30: repeat weak modules before advanced topics.
• Target company asks specialized algorithms: use 22_advanced_extensions after the core.

Resources

• LeetCode
• VisuAlgo
• Big-O Cheat Sheet

Contributing

Focused fixes, clearer beginner explanations, additional tests, and better practice ordering are welcome. Keep pull requests small enough to review and explain what learning problem the change solves.

License

This project is available under the MIT License.

---

@2026 Manohar Eldhandi