How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a medium difficulty Coding & Algorithms question, commonly asked during Technical Screen rounds at Walmart Labs.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Walmart Labs during technical interviews.

Compute days until plants stop dying | Walmart Labs Coding Question

Q: Compute days until plants stop dying

This question evaluates a candidate's ability to reason about array-based state transitions and algorithmic complexity, testing competency in analyzing iterative dependencies among elements and handling large input sizes.

Compute days until plants stop dying

Company: Walmart Labs

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: medium

Interview Round: Technical Screen

You are given a row of plants, each with an integer pesticide level. ## Rules - On each day, any plant with a **strictly greater** pesticide level than the plant **immediately to its left** dies. - All plants that die on a given day are removed **simultaneously**. - The leftmost plant never dies (it has no left neighbor). - The process repeats until a day occurs when **no plants die**. ## Task Given an array `plant[]` of pesticide levels from left to right, return the number of days until plants stop dying. ## Input/Output - **Input:** `plant` (array of integers) - **Output:** integer number of days until stable ## Example - Input: `plant = [6, 5, 8, 4, 7, 10, 9]` - Output: `2` ## Assumptions / Constraints (if not otherwise specified) - `1 <= n <= 1e5` - `0 <= plant[i] <= 1e9` - Aim for better than O(n²) time for large `n`.

Quick Answer: This question evaluates a candidate's ability to reason about array-based state transitions and algorithmic complexity, testing competency in analyzing iterative dependencies among elements and handling large input sizes.

You are given a row of plants, where each plant has an integer pesticide level. On each day, any plant with a strictly greater pesticide level than the plant immediately to its left dies. All deaths on the same day happen simultaneously, and the surviving plants close ranks before the next day begins. The leftmost plant never dies because it has no left neighbor. Return the number of days until the plants reach a stable state where no plant dies anymore. Example: If plant = [6, 5, 8, 4, 7, 10, 9], then the answer is 2. - Day 1: plants with levels 8 and 10 die, leaving [6, 5, 4, 7, 9] - Day 2: plants with levels 7 and 9 die, leaving [6, 5, 4] - Day 3: no plants die, so the process stops after 2 days

Constraints

1 <= len(plant) <= 100000
0 <= plant[i] <= 1000000000

Examples

Input: ([6, 5, 8, 4, 7, 10, 9],)

Expected Output: 2

Explanation: After day 1, plants 8 and 10 die. After day 2, plants 7 and 9 die. Then the row is stable.

Input: ([4],)

Expected Output: 0

Explanation: A single plant has no left neighbor, so it never dies.

Input: ([1, 2, 3, 4],)

Expected Output: 1

Explanation: Every plant except the first has a greater pesticide level than its left neighbor, so they all die on day 1.

Input: ([4, 3, 2, 1],)

Expected Output: 0

Explanation: No plant has a greater pesticide level than the plant immediately to its left, so the row is already stable.

Input: ([3, 3, 3, 3],)

Expected Output: 0

Explanation: Equal pesticide levels do not cause death because the rule is strictly greater.

Input: ([3, 6, 2, 7, 5],)

Expected Output: 2

Explanation: Day 1 removes 6 and 7, leaving [3, 2, 5]. Day 2 removes 5, leaving [3, 2].

Hints

A day-by-day simulation can become O(n^2) in the worst case. Try to determine when each plant dies during a single left-to-right scan.
A monotonic stack can help you find the nearest plant to the left that can keep a plant alive, while also tracking how many days removed plants survived.

Quick Overview

This question evaluates a candidate's ability to reason about array-based state transitions and algorithmic complexity, testing competency in analyzing iterative dependencies among elements and handling large input sizes.