Got a problem that required pulling Euler’s formula out of thin air. Please tell me, who the fuck remembers that Euler’s formula in an interview? My interviewer was out to get me I swear to God.

At this point what are they even testing? Do they even know what they want? Hours of prep wasted. And now I have to go prep for Google. My friend just got destroyed in their loop and said the interviewers were some of the most unreasonable people he has ever had to deal with.

Everywhere I turn in this market it feels like I’m just waiting to get fucked.

https://preview.redd.it/pfgk8odz14kh1.png?width=477&format=png&auto=webp&s=4264076d15afd83383cfdb0512506aa55ff9f4ed

Saw some similar problems from PracHub

Hey everyone,

I recently completed the Amazon SDE interview process and received an offer. I wanted to share the complete experience, especially for candidates moving from testing to development roles.

Background

• Current role: Automation Tester at a fintech company
• Total experience: 5 years
• Preparation time: Approximately 5 months
• Previous interviews or mocks: None
• Verdict: Selected

Application and Online Assessment

Online Assessment: July 17, 2026

OA result: July 21, 2026

Approximate total duration: 2 hours

A recruiter contacted me through LinkedIn and shared the assessment link. I attempted it two days later.

Coding Section

The first problem used an AI-integrated repository environment. I had to diagnose and fix an issue in the search functionality of an Amazon movie application.

There were six test cases, and I passed three.

The second problem was a hard DSA question involving a queue and binary search. I do not remember the exact statement, but my solution passed all except one test case.

The remaining sections included:

• Work Style Assessment
• Behavioral and Leadership Principles Assessment

Four days later, HR informed me that I had cleared the OA.

Round 1: DSA

Format: In person, pen and paper
Duration: Approximately 50 minutes
Difficulty: Easy to medium

Question 1: Increasing Temperature Alert

Given a stream of temperature readings, generate an alert whenever five consecutive readings are strictly increasing.

Question 2: Maximum Profit From Advertising Slots

There are n advertising slots and m companies. Each company requests a certain number of slots and offers a fixed payment for each advertisement.

The task was to allocate the available slots to maximize the total profit.

This was mainly a greedy problem.

I solved both questions with optimal time complexity and explained the edge cases and complexity.

Around ten minutes were reserved for Leadership Principles. The interviewer was friendly, and the conversation went smoothly.

This was an elimination round. Three of the eight candidates were eliminated.

Round 2: Low-Level Design

Date: July 24, 2026
Format: In person, pen and paper
Duration: Approximately 55 minutes

I was asked to design a job scheduling system that could schedule and execute jobs based on:

• Priority: LOW, MEDIUM, or HIGH
• Request type: Ad hoc or periodic
• Execution type: Background or foreground

I designed the main classes, interfaces, and attributes and explained the core scheduling flow.

My scheduling strategy was not completely optimal, so the interviewer reduced the scope and allowed me to explain some parts verbally instead of expecting production-ready code on paper.

The final ten minutes focused on Leadership Principles.

This was also an elimination round, and one candidate was eliminated.

Round 3: HLD With the Hiring Manager

Date: July 29, 2026
Format: Virtual using Bluescape
Duration: Approximately 55 minutes

The Hiring Manager was unavailable during the onsite, so this round was scheduled five days later.

The first 15 minutes focused on Leadership Principles and my previous projects.

Design Question: Split Payment and Settlement System

Design a system for group purchases that tracks:

• Contributions from each participant
• Participants who have not paid
• Settlement deadlines
• Refund distribution
• Final balances and settlements

I initially struggled to understand the requirements and spent around ten minutes clarifying the problem.

I then sketched a basic architecture containing services, routing, and a database. However, I could not explore the design deeply or answer several follow-up questions.

HR later told me that the feedback from this round was mixed. I genuinely thought this round had ended my chances.

Round 4: Bar Raiser

Date: August 3, 2026
Duration: Approximately 50 minutes

The first 15 minutes covered Leadership Principles and a deep dive into my previous experience.

The technical portion involved a medium-hard graph problem based on Dijkstra’s algorithm. I completed it in approximately 25 minutes and explained the time and space complexity.

There were no additional follow-ups, and the interview ended after a short discussion.

Preparation

Leadership Principles

I used ChatGPT to organize and rehearse my real experiences using the STAR format. Leadership Principles carried significant weight throughout the process.

DSA

I solved approximately 270 LeetCode problems.

Low-Level Design

I used Ashish’s awesome-low-level-design material.

High-Level Design

My primary resources were:

• Real interview questions
• ByteByteGo
• Alex Xu’s System Design Interview, Volume 1
• Hello Interview’s YouTube videos

I did not prepare Dynamic Programming and was fortunate not to encounter it in any round.

This was the first interview of my job-switch journey, and I had not attempted any mock interviews. Luck helped with the topics, but five months of preparation made it possible to communicate clearly and recover after a mixed HLD round.

My biggest takeaway is that one weak round may not automatically end the process. Treat every remaining interview as a fresh opportunity, and prepare Leadership Principle stories as seriously as technical topics.

All the best to everyone preparing!

Hey everyone,

I recently participated in a Google on-campus hiring process. Around 50 students were shortlisted for the interview stage.

Round 1: Multi-Source BFS

Duration: Approximately 45 minutes

I was given a problem based on multi-source BFS and completed the initial solution correctly.

In the follow-up, the interviewer asked whether I could optimize the solution by using the fact that the input was a one-dimensional array.

I proposed:

• Finding the previous and next greater elements using a monotonic stack
• Using a difference array to mark or process the affected cells efficiently

The interviewer said the approach was interesting, and I implemented it successfully.

I felt confident about this round because I solved both the original problem and the optimization follow-up.

Round 2: Ambiguous Coding Problem

Duration: Approximately 50 minutes

The second interviewer presented a problem that felt vague to me initially.

I spent approximately 15 minutes asking questions and trying to understand the expected behavior. The interaction felt tense, and I did not feel that my clarification questions were being received positively.

Eventually, I explained my interpretation of the problem and asked the interviewer to confirm it. Once the requirements were clear, I found an approach and completed the implementation within the remaining time.

I left the round feeling that I had recovered well despite the difficult start.

Result

I was confident that both rounds had gone reasonably well, but I was ultimately rejected.

The result was especially difficult to process because some candidates who, according to our discussions afterward, did not complete every follow-up were selected.

I understand that interview decisions are not based only on whether someone reaches a final solution. Interviewers may also evaluate:

• Communication and requirement clarification
• Correctness across hidden edge cases
• Code quality
• Complexity analysis
• Response to hints
• Independence of the solution
• Overall performance relative to the hiring group

Still, receiving a rejection after feeling that I completed both rounds was discouraging. Without specific feedback, it is difficult to know whether I missed a technical issue, communicated poorly, or was simply weaker in an area that was not obvious to me during the interviews.

For people who have interviewed at Google:

• Have you experienced a rejection after completing all the coding questions?
• How much can the clarification phase affect the final evaluation?
• What less-obvious signals might interviewers evaluate beyond solving the problem?
• How do you review your performance when no detailed feedback is provided?

I know one rejection does not define my ability, but this one definitely hurt. I’m going to take a short break, review what I can improve, and continue preparing.

Hey everyone,

I recently participated in a Google on-campus hiring process. Around 50 students were shortlisted for the interview stage.

Round 1: Multi-Source BFS

Duration: Approximately 45 minutes

I was given a problem based on multi-source BFS and completed the initial solution correctly.

In the follow-up, the interviewer asked whether I could optimize the solution by using the fact that the input was a one-dimensional array.

I proposed:

• Finding the previous and next greater elements using a monotonic stack
• Using a difference array to mark or process the affected cells efficiently

The interviewer said the approach was interesting, and I implemented it successfully.

I felt confident about this round because I solved both the original problem and the optimization follow-up.

Round 2: Ambiguous Coding Problem

Duration: Approximately 50 minutes

The second interviewer presented a problem that felt vague to me initially.

I spent approximately 15 minutes asking questions and trying to understand the expected behavior. The interaction felt tense, and I did not feel that my clarification questions were being received positively.

Eventually, I explained my interpretation of the problem and asked the interviewer to confirm it. Once the requirements were clear, I found an approach and completed the implementation within the remaining time.

I left the round feeling that I had recovered well despite the difficult start.

Result

I was confident that both rounds had gone reasonably well, but I was ultimately rejected.

The result was especially difficult to process because some candidates who, according to our discussions afterward, did not complete every follow-up were selected.

I understand that interview decisions are not based only on whether someone reaches a final solution. Interviewers may also evaluate:

• Communication and requirement clarification
• Correctness across hidden edge cases
• Code quality
• Complexity analysis
• Response to hints
• Independence of the solution
• Overall performance relative to the hiring group

Still, receiving a rejection after feeling that I completed both rounds was discouraging. Without specific feedback, it is difficult to know whether I missed a technical issue, communicated poorly, or was simply weaker in an area that was not obvious to me during the interviews.

For people who have interviewed at Google:

• Have you experienced a rejection after completing all the coding questions?
• How much can the clarification phase affect the final evaluation?
• What less-obvious signals might interviewers evaluate beyond solving the problem?
• How do you review your performance when no detailed feedback is provided?

I know one rejection does not define my ability, but this one definitely hurt. I’m going to take a short break, review what I can improve, and continue preparing.

I recently came across this array problem and wanted to share the solution.

Approximate date: August 7, 2026

Problem

You are given an array arr of length n. You may perform these operations:

1. Select an index i, where 1 <= i <= n - 1, and set every element from index 0 to i - 1 equal to arr[i].

​

Cost = i × arr[i]

1. Select an index i, where 0 <= i <= n - 2, and set every element from index i + 1 to n - 1 equal to arr[i].

​

Cost = (n - 1 - i) × arr[i]

Return the minimum total cost required to make every array element equal.

Example

arr = [1, 1, 2, 1, 1]

Choose index 1 and apply the suffix operation:

Cost = (5 - 1 - 1) × 1 = 3

Every element after index 1 becomes 1:

[1, 1, 1, 1, 1]

Therefore, the answer is:

3

Observation

Suppose we want the final value to be v.

If the array already contains a contiguous run of v from index l to r, we can preserve that run and replace everything outside it.

To replace the prefix:

Cost = l × v

To replace the suffix:

Cost = (n - 1 - r) × v

The total cost is:

(l + n - 1 - r) × v

If the run length is:

length = r - l + 1

the formula becomes:

cost = (n - length) × v

For non-negative values, we should therefore preserve the longest contiguous run of a candidate value.

Rather than storing the longest run for every distinct value, we can simply scan every maximal equal-value run and calculate its cost.

C++ Solution

#include <algorithm>
#include <climits>
#include <vector>
using namespace std;

long long minimumCost(const vector<int>& arr) {
    const int n = static_cast<int>(arr.size());
    long long answer = LLONG_MAX;

    int left = 0;

    while (left < n) {
        int right = left;

        while (right + 1 < n && arr[right + 1] == arr[left]) {
            ++right;
        }

        long long runLength = right - left + 1;
        long long cost =
            static_cast<long long>(n - runLength) * arr[left];

        answer = min(answer, cost);
        left = right + 1;
    }

    return answer;
}

Complexity

• Time: O(n)
• Extra space: O(1)

Important Constraint Issue

The stated constraint allows negative values:

-10^5 <= arr[i] <= 10^5

This makes the problem potentially unbounded.

If arr[i] is negative, an operation using that value has a negative cost. Since the statement does not require an operation to change the array, the same negative-cost operation can be repeated indefinitely.

For example:

arr = [-1, 2]

Selecting index 0 and applying the suffix operation costs -1. After the array becomes [-1, -1], the same operation could still be repeated, reducing the total cost without limit.

Therefore, one of the following conditions is probably missing:

• arr[i] must be non-negative or positive.
• Every operation must change at least one element.
• Each operation may only be performed once.
• The number of operations is bounded.

Under the usual assumption that all values are non-negative, the equal-run solution above works in O(n) time.

I recently came across this array problem and wanted to share the solution.

Approximate date: August 7, 2026

Problem

You are given an array arr of length n. You may perform these operations:

1. Select an index i, where 1 <= i <= n - 1, and set every element from index 0 to i - 1 equal to arr[i].

​

Cost = i × arr[i]

1. Select an index i, where 0 <= i <= n - 2, and set every element from index i + 1 to n - 1 equal to arr[i].

​

Cost = (n - 1 - i) × arr[i]

Return the minimum total cost required to make every array element equal.

Example

arr = [1, 1, 2, 1, 1]

Choose index 1 and apply the suffix operation:

Cost = (5 - 1 - 1) × 1 = 3

Every element after index 1 becomes 1:

[1, 1, 1, 1, 1]

Therefore, the answer is:

3

Observation

Suppose we want the final value to be v.

If the array already contains a contiguous run of v from index l to r, we can preserve that run and replace everything outside it.

To replace the prefix:

Cost = l × v

To replace the suffix:

Cost = (n - 1 - r) × v

The total cost is:

(l + n - 1 - r) × v

If the run length is:

length = r - l + 1

the formula becomes:

cost = (n - length) × v

For non-negative values, we should therefore preserve the longest contiguous run of a candidate value.

Rather than storing the longest run for every distinct value, we can simply scan every maximal equal-value run and calculate its cost.

C++ Solution

#include <algorithm>
#include <climits>
#include <vector>
using namespace std;

long long minimumCost(const vector<int>& arr) {
    const int n = static_cast<int>(arr.size());
    long long answer = LLONG_MAX;

    int left = 0;

    while (left < n) {
        int right = left;

        while (right + 1 < n && arr[right + 1] == arr[left]) {
            ++right;
        }

        long long runLength = right - left + 1;
        long long cost =
            static_cast<long long>(n - runLength) * arr[left];

        answer = min(answer, cost);
        left = right + 1;
    }

    return answer;
}

Complexity

• Time: O(n)
• Extra space: O(1)

Important Constraint Issue

The stated constraint allows negative values:

-10^5 <= arr[i] <= 10^5

This makes the problem potentially unbounded.

If arr[i] is negative, an operation using that value has a negative cost. Since the statement does not require an operation to change the array, the same negative-cost operation can be repeated indefinitely.

For example:

arr = [-1, 2]

Selecting index 0 and applying the suffix operation costs -1. After the array becomes [-1, -1], the same operation could still be repeated, reducing the total cost without limit.

Therefore, one of the following conditions is probably missing:

• arr[i] must be non-negative or positive.
• Every operation must change at least one element.
• Each operation may only be performed once.
• The number of operations is bounded.

Under the usual assumption that all values are non-negative, the equal-run solution above works in O(n) time.

Hi everyone,

I recently attempted the first round of an Adobe hackathon and wanted to share the assessment pattern and coding questions.

Duration: Approximately 90 minutes
Format: Timed MCQs and two DSA questions
Status: Waiting for an update

I was not fully prepared, so I treated the assessment as an opportunity to evaluate my current problem-solving skills. I focused more heavily on the DSA section.

MCQ Section

Each MCQ had an individual timer of one minute.

Some questions and answer choices were quite lengthy. A few felt as though they would require more than a minute just to read carefully and understand, which made time management difficult.

My main takeaway is that this section tests reading speed and decision-making in addition to technical knowledge.

DSA Question 1: Count Parent Nodes With a Target Sum

A binary tree was provided using a serialized preorder input format. We were also given an integer k.

The task was to count the parent nodes satisfying:

node.value + node.left.value + node.right.value == k

The main implementation step was constructing the binary tree correctly from the provided preorder representation.

After building the tree, a recursive traversal was sufficient:

1. Visit the current node.
2. Check whether it has the required children.
3. Compare the sum with k.
4. Recursively process the left and right subtrees.
5. Return the total count.

Complexity:

• Time: O(n)
• Recursion space: O(h), where h is the tree height

I found this question easy because it mainly tested tree construction and recursive traversal.

DSA Question 2: Largest Binary Number by Concatenation

We were given N binary strings of different lengths.

The task was to arrange the strings so that their concatenation produced the largest possible binary number.

For example, when deciding the relative order of two strings a and b, we need to compare:

a + b

and:

b + a

If a + b is larger, a should appear before b. Otherwise, b should appear first.

Therefore, the solution is to sort all strings using the comparator:

a comes before b if (a + b) > (b + a)

After sorting, concatenate all the strings to obtain the answer.

During the assessment, I tried to build a greedy solution based on leading 1s, string length, and character-by-character comparisons. The approach became difficult to manage because those local rules do not always determine the globally optimal order.

I was unable to finish this problem within the time limit.

After the assessment, I recognized that comparing a + b with b + a directly was the key observation. It is the same pattern used in the classic Largest Number problem.

Complexity:

• Sorting: Approximately O(N log N × L)
• Final concatenation: O(T)

Here, L is the comparison cost and T is the total length of all strings.

The final binary value may exceed standard integer limits, so it may need to be returned as a string or converted using a big-integer type, depending on the required output format.

Final Thoughts

I would rate the first question as easy.

The second question did not require an advanced data structure, but recognizing the custom comparator made it medium difficulty for me.

My biggest takeaway was that comparing a + b and b + a is much more reliable than creating separate rules based on leading bits, the number of 1s, or string length.

I still have plenty to improve, but this assessment helped me identify an important sorting pattern that I will remember in future coding rounds.

Did anyone else attempt this Adobe hackathon round? How did you find the MCQ time limit and the second coding problem?

Hi everyone,

I recently attempted the first round of an Adobe hackathon and wanted to share the assessment pattern and coding questions.

Duration: Approximately 90 minutes
Format: Timed MCQs and two DSA questions
Status: Waiting for an update

I was not fully prepared, so I treated the assessment as an opportunity to evaluate my current problem-solving skills. I focused more heavily on the DSA section.

MCQ Section

Each MCQ had an individual timer of one minute.

Some questions and answer choices were quite lengthy. A few felt as though they would require more than a minute just to read carefully and understand, which made time management difficult.

My main takeaway is that this section tests reading speed and decision-making in addition to technical knowledge.

DSA Question 1: Count Parent Nodes With a Target Sum

A binary tree was provided using a serialized preorder input format. We were also given an integer k.

The task was to count the parent nodes satisfying:

node.value + node.left.value + node.right.value == k

The main implementation step was constructing the binary tree correctly from the provided preorder representation.

After building the tree, a recursive traversal was sufficient:

1. Visit the current node.
2. Check whether it has the required children.
3. Compare the sum with k.
4. Recursively process the left and right subtrees.
5. Return the total count.

Complexity:

• Time: O(n)
• Recursion space: O(h), where h is the tree height

I found this question easy because it mainly tested tree construction and recursive traversal.

DSA Question 2: Largest Binary Number by Concatenation

We were given N binary strings of different lengths.

The task was to arrange the strings so that their concatenation produced the largest possible binary number.

For example, when deciding the relative order of two strings a and b, we need to compare:

a + b

and:

b + a

If a + b is larger, a should appear before b. Otherwise, b should appear first.

Therefore, the solution is to sort all strings using the comparator:

a comes before b if (a + b) > (b + a)

After sorting, concatenate all the strings to obtain the answer.

During the assessment, I tried to build a greedy solution based on leading 1s, string length, and character-by-character comparisons. The approach became difficult to manage because those local rules do not always determine the globally optimal order.

I was unable to finish this problem within the time limit.

After the assessment, I recognized that comparing a + b with b + a directly was the key observation. It is the same pattern used in the classic Largest Number problem.

Complexity:

• Sorting: Approximately O(N log N × L)
• Final concatenation: O(T)

Here, L is the comparison cost and T is the total length of all strings.

The final binary value may exceed standard integer limits, so it may need to be returned as a string or converted using a big-integer type, depending on the required output format.

Final Thoughts

I would rate the first question as easy.

The second question did not require an advanced data structure, but recognizing the custom comparator made it medium difficulty for me.

My biggest takeaway was that comparing a + b and b + a is much more reliable than creating separate rules based on leading bits, the number of 1s, or string length.

I still have plenty to improve, but this assessment helped me identify an important sorting pattern that I will remember in future coding rounds.

Did anyone else attempt this Adobe hackathon round? How did you find the MCQ time limit and the second coding problem?

Hi everyone,

I recently attempted the first round of an Adobe hackathon and wanted to share the assessment pattern and coding questions.

Duration: Approximately 90 minutes
Format: Timed MCQs and two DSA questions
Status: Waiting for an update

I was not fully prepared, so I treated the assessment as an opportunity to evaluate my current problem-solving skills. I focused more heavily on the DSA section.

MCQ Section

Each MCQ had an individual timer of one minute.

Some questions and answer choices were quite lengthy. A few felt as though they would require more than a minute just to read carefully and understand, which made time management difficult.

My main takeaway is that this section tests reading speed and decision-making in addition to technical knowledge.

DSA Question 1: Count Parent Nodes With a Target Sum

A binary tree was provided using a serialized preorder input format. We were also given an integer k.

The task was to count the parent nodes satisfying:

node.value + node.left.value + node.right.value == k

The main implementation step was constructing the binary tree correctly from the provided preorder representation.

After building the tree, a recursive traversal was sufficient:

1. Visit the current node.
2. Check whether it has the required children.
3. Compare the sum with k.
4. Recursively process the left and right subtrees.
5. Return the total count.

Complexity:

• Time: O(n)
• Recursion space: O(h), where h is the tree height

I found this question easy because it mainly tested tree construction and recursive traversal.

DSA Question 2: Largest Binary Number by Concatenation

We were given N binary strings of different lengths.

The task was to arrange the strings so that their concatenation produced the largest possible binary number.

For example, when deciding the relative order of two strings a and b, we need to compare:

a + b

and:

b + a

If a + b is larger, a should appear before b. Otherwise, b should appear first.

Therefore, the solution is to sort all strings using the comparator:

a comes before b if (a + b) > (b + a)

After sorting, concatenate all the strings to obtain the answer.

During the assessment, I tried to build a greedy solution based on leading 1s, string length, and character-by-character comparisons. The approach became difficult to manage because those local rules do not always determine the globally optimal order.

I was unable to finish this problem within the time limit.

After the assessment, I recognized that comparing a + b with b + a directly was the key observation. It is the same pattern used in the classic Largest Number problem.

Complexity:

• Sorting: Approximately O(N log N × L)
• Final concatenation: O(T)

Here, L is the comparison cost and T is the total length of all strings.

The final binary value may exceed standard integer limits, so it may need to be returned as a string or converted using a big-integer type, depending on the required output format.

Final Thoughts

I would rate the first question as easy.

The second question did not require an advanced data structure, but recognizing the custom comparator made it medium difficulty for me.

My biggest takeaway was that comparing a + b and b + a is much more reliable than creating separate rules based on leading bits, the number of 1s, or string length.

I still have plenty to improve, but this assessment helped me identify an important sorting pattern that I will remember in future coding rounds.

Did anyone else attempt this Adobe hackathon round? How did you find the MCQ time limit and the second coding problem?

Anyone here who can guide me for the Microsoft OA?

• what can be most expected questions in the OA?
• some tips?
• which topics to prepare most and the sources too.
• any previous direct oa questions you have?

It would be really helpful if someone who gave OA recently could help me out or the ones who are experienced too.

Thanks in advance gng.

Anyone here who can guide me for the Microsoft OA?

• what can be most expected questions in the OA?
• some tips?
• which topics to prepare most and the sources too.
• any previous direct oa questions you have?

It would be really helpful if someone who gave OA recently could help me out or the ones who are experienced too.

Thanks in advance gng.

Hey everyone,

I appeared for the American Express Online Assessment, and wanted to share the coding questions for anyone preparing for future AMEX assessments.

Duration: 90 minutes
Total questions: 3 coding problems
Overall difficulty: Medium
Main challenge: Implementation and time management

Question 1: Minimum Moves to Spread Stones

A 3 x 3 grid contained nine stones in total. Some cells had multiple stones, while others were empty.

The task was to move stones between adjacent cells until every cell contained exactly one stone. Moving one stone to an adjacent cell counted as one move.

We had to return the minimum number of moves required.

This was equivalent to LeetCode 2850: Minimum Moves to Spread Stones Over Grid.

One approach is to:

1. Identify cells containing surplus stones.
2. Identify empty cells.
3. Assign surplus stones to empty cells.
4. Use Manhattan distance to calculate the movement cost.
5. Explore the possible assignments using backtracking and return the minimum total cost.

Because the grid is fixed at 3 x 3, the number of possible assignments remains manageable.

Difficulty: Medium

Question 2: Maximum Points Inside a Rectangle

We were given:

• A set of coordinate points (x, y)
• A rectangle perimeter P

The task was to position an axis-aligned rectangle, subject to the perimeter constraint, so that it contained the maximum possible number of points.

We had to return that maximum count.

This felt like a combination of computational geometry, coordinate sorting, and sliding window or two-pointer techniques.

The exact approach depends on details such as whether the side lengths must be integers and whether points on the boundary are included. My initial thought was to consider possible width and height combinations satisfying:

2 × (width + height) = P

For each valid pair, the points could be sorted by one coordinate and processed using a window over the other coordinate.

I could not find an exact LeetCode equivalent for this problem.

Difficulty: Medium–Hard

Question 3: Pizza Discounts Using Classes

The final question involved a pizza-ordering system with four different discount schemes.

The solution required separate functions or classes for the discount rules. We also had to represent pizzas and orders using C++ structs or classes and calculate the correct final price.

The discount calculations themselves were not extremely difficult. The challenging part was implementing all four schemes cleanly, handling the different conditions, and keeping the code organized under the time limit.

A clean object-oriented approach could define a common discount interface and implement each scheme as a separate strategy. This would keep the pricing logic modular and make additional discount types easier to add.

Difficulty: Medium, but implementation-heavy

Overall Experience

The assessment tested:

• Backtracking and assignment problems
• Computational geometry
• Sliding window or two pointers
• Simulation
• Object-oriented design
• Clean C++ implementation
• Time management

The first question had a recognizable LeetCode equivalent. The second was the most conceptually challenging, while the third required the most careful implementation.

If anyone knows exact equivalents for Questions 2 or 3, please share them in the comments. It would be useful for everyone preparing for future AMEX assessments.

Good luck with your preparation!