The Greedy Gardener: A Simple Tale of Algorithms

Once upon a time, in a village of coders, there lived a gardener named Prashant. He had two ways of planting flowers in his garden Greedy and Non-Greedy.

1. The Non-Greedy Way

One day, Prashant wanted to count all the even-numbered flowers in his garden.

let count = 0;
for (let flower of flowers) {
  // Just counts every even   flower
  if (flower % 2 === 0) count++; 
}

Simple! he thought. No strategy, just counting.

2. The Greedy Twist

But then, the village chief said:

Prashant, you can plant even-numbered flowers, but never two in a row!

Now, Prashant had to make smart choices:

• Take an even flower only if the last one wasn’t even.
• Commit to the choice—no going back!

let count = 0;
let lastEven = false;

for (let flower of flowers) {
  // Greedy condition
  if (flower % 2 === 0 && !lastEven) {
    count++;
    lastEven = true; // Lock it in!
  } else {
    lastEven = false; // Move on
  }
}

Why was this greedy?

1. ✔ Best immediate choice (take even when possible).
2. ✔ No regrets (never reconsiders past decisions).
3. ✔ No future planning (doesn’t peek ahead).

3. Another Greedy Trick

Later, Prashant had to jump across stones in a river. He used a greedy rule:

Always jump as far as possible at each step!

let maxReach = 0;
for (let i = 0; i < stones.length; i++) {
  // Can't go further!
  if (maxReach < i) return false; 
  
  // Take the biggest leap
  maxReach = Math.max(maxReach, i + stones[i]); 
}
return true;

4. The Gas Station Puzzle

Finally, Prashant had to drive a car around a circular route. He used a greedy strategy:

Start where gas is positive, reset if you run out!

let totalGas = 0, currentGas = 0, start = 0;

for (let i = 0; i < gas.length; i++) {
  totalGas += gas[i] - cost[i];
  currentGas += gas[i] - cost[i];
  if (currentGas < 0) { // Oops, restart!
    start = i + 1;
    currentGas = 0;
  }
}
return totalGas >= 0 ? start : -1;

Moral of the Story

Greedy algorithms make quick, local decisions

1. like a gardener picking flowers or a traveler jumping stones.
2. They’re fast but don’t always find the absolute best solution
3. just the best next step.

So next time you code, ask: Am I being greedy? 😉

— Prashant, the Algorithmic Gardener 🌸