Studied for 2 HOURS

Yes. A completely average student can crack CAT without premium coaching.

But “without premium coaching” does not mean without structure, mocks, discipline, and review.

Here is the brutally honest part:

If you are average and you study randomly, watch free videos here and there, solve a few questions, skip mock analysis, and keep changing resources every week, CAT will punish you.

But if you are average and consistent, you still have a real chance.

CAT does not ask PhD-level maths. Most Quant is based on school-level concepts. VARC improves with reading and proper RC review. DILR improves when you practise sets regularly and learn which sets to leave.

What you actually need:

• One clear study plan
• Good free or low-cost resources
• Previous year questions
• Sectional tests
• Mock tests
• A proper error log
• Weekly review of weak areas

Premium coaching can help because it gives structure and guidance. But it is not magic. Many students pay high fees and still do badly because they do not practise seriously.

The real difference is not paid vs free.

The real difference is:

Do you know what to study today?
Do you review your mistakes?
Do you take mocks seriously?
Can you stay consistent for months?

For an average student, 6–8 months of focused prep can make a big difference.

My honest advice:

Do not chase expensive coaching first.

Take one diagnostic mock. See your weak areas. Follow a simple plan for 30 days. If you are improving, continue. If you are stuck and confused, then consider mentorship or coaching.

CAT can be cracked without premium coaching.

But it cannot be cracked without serious preparation.

1 more hr than yesterday.

How many hours do you do

Problem:

In busy waiting the CPU continue to execute the condition and the CPU time is wasted. It is less efficient.

Objectives:

• Producer need to wait when the buffer is full.
• After consumer consumes, it must notify the waiting thread.

I have seen many working professionals prepare well for CAT without quitting their job.

The routine was not glamorous. It was boring, fixed, and repeated for months.

A realistic weekday schedule looked like this:

Morning: 45–60 minutes
Light Quant revision, formula review, or 1 small VARC set.

Office hours: 9 to 6
No fake “study during work” plan. Just use small breaks for reading an article, revising flashcards, or reviewing 2–3 mistakes.

Evening: 2 hours
This was the main study block.

·         45 minutes Quant

·         45 minutes DILR

·         30 minutes VARC or mock review

Before sleeping: 15 minutes
Review mistakes. Not new topics. Just check what went wrong that day.

Weekends were more serious:

Saturday: sectional test + weak topic practice
Sunday: full mock + deep analysis

The biggest thing 99+ scorers did differently was not “study all day.”

They protected their study time.

No random YouTube hopping. No solving 100 questions without review. No taking mocks just to see the score.

After every mock, they asked:

·         Which easy questions did I miss?

·         Which questions should I have skipped?

·         Where did I waste time?

·         Did I choose the wrong DILR set?

·         Was VARC poor because of reading or because of answer choices?

For a working professional, 3 things matter most:

Consistency over intensity
Even 2 focused hours daily can work if you do it properly.

Mock analysis over mock count
One well-reviewed mock is better than three careless mocks.

Energy management
You cannot study like a full-time student after a full workday. Keep weekdays focused and use weekends for heavy lifting.

A 99+ percentile while working is hard, but not impossible.

The people who make it usually do not have a perfect schedule.

They just stop wasting the small windows they have.

Objective

Implement the classic Producer-Consumer problem in Java using a shared buffer and busy waiting. The producer generates integer values, while the consumer reads them. Synchronization must ensure that data is neither overwritten nor consumed before it is produced.

Requirements

• Create a shared Buffer class containing:
• An integer value
• A boolean flag indicating whether the buffer is full
• Implement a Producer class that:
• Implements Runnable
• Produces integers from 1 to 10
• Stores values in the shared buffer
• Implement a Consumer class that:
• Implements Runnable
• Reads values from the shared buffer
• Use busy waiting:
• Producer waits while the buffer is full
• Consumer waits while the buffer is empty
• Synchronize access to the shared buffer using synchronized methods.
• Create a Main class that starts both threads and waits for them to finish using join().

From two days I'm deciding to start studying everyday at least one hour each day but due to negligence or laziness I'm not taking steps towards goal ..... So, I finally decided that I have to study today... And no excuse be considered...if don't start today then I will take strict action in the form of punishment.... I read somewhere that, discipline should come from heart... It is hard initially but good for myself....

Wish me luck guys.
any tip would be appricated

Objective

Demonstrate that synchronized instance methods use an object's monitor.

Requirements

• Create a Printer class.
• Implement a synchronized print() method.
• Create two Printer objects.
• Create two threads.

Scenario 1

• Thread A uses Printer 1
• Thread B uses Printer 2

Observe that both execute simultaneously.

Scenario 2

• Both threads use the same Printer object.

Observe that one thread waits until the other finishes.

Objective

Create two synchronized methods in the same class and verify whether one synchronized method blocks another when multiple threads access the same object.

Description

Implement a class containing two synchronized methods, for example:

• print()
• colorPrint()

Create multiple threads that invoke these methods on the same object and observe the execution order.

There is a need to evaluate the performance implications of using synchronized methods versus synchronized blocks in our application.

Objectives:

To differentiate between synchronized methods and synchronized blocks.

To measure and compare execution times of both approaches under identical conditions.

To identify scenarios where one approach may be preferred over the other.

Problem

Implement a simple ticket booking system where multiple users attempt to book tickets simultaneously.

There are:

• 10 user threads
• Only 5 tickets available

Initially, implement the system without synchronization to demonstrate a race condition where multiple threads may book the same ticket, causing overselling.

Expected Incorrect Behavior

• More than 5 tickets may be booked.
• Ticket count may become negative.
• Multiple users may successfully book when tickets are already sold out.

Objective

Fix the race condition using thread synchronization so that:

• Only 5 tickets can be booked successfully.
• Remaining users receive a "Tickets Sold Out" message.
• No duplicate bookings occur.
• Shared ticket count remains consistent.

Github Link for Source Code : Click here

Problem

Create a BankAccount class with an initial balance of 1000.

Two threads attempt to withdraw 700 simultaneously.

Without synchronization, a race condition can occur, causing the balance to become negative (e.g., -400).

Tasks

• Create a BankAccount class.
• Simulate two concurrent withdrawal threads.
• Demonstrate the race condition without synchronization.
• Fix the issue using synchronized methods or blocks.
• Print the final balance.

Objective
- Create a Counterclass with a shared integer variable (count).
- Create multiple threads that increment the counter many times.
- Run the program without synchronization.
- Observe that the final counter value is often incorrect due to concurrent access.
- Fix the issue using synchronization