Minimum Number of Days to Eat N Oranges - Practice Coding Problems

Minimum Number of Days to Eat N Oranges - Problem

Imagine you're on a unique diet plan with n oranges in your kitchen! Each day, you can choose one of three strategic eating options:

Option 1: Eat exactly 1 orange (always available)
Option 2: If the remaining oranges n is divisible by 2, eat n/2 oranges in one day
Option 3: If the remaining oranges n is divisible by 3, eat 2*(n/3) oranges in one day

Your goal is to find the minimum number of days required to consume all n oranges. This is a classic optimization problem that requires smart decision-making at each step!

Example: With 10 oranges, you could eat 1 orange for 10 days, but there's a much faster way using the divisibility rules!

Input & Output

example_1.py — Basic case

$ Input: n = 10

› Output: 4

💡 Note: Day 1: Eat 1 orange (10 → 9), Day 2: 9%3=0, eat 6 oranges (9 → 3), Day 3: 3%3=0, eat 2 oranges (3 → 1), Day 4: Eat 1 orange (1 → 0). Total: 4 days.

example_2.py — Small number

$ Input: n = 6

› Output: 3

💡 Note: Day 1: 6%3=0, eat 4 oranges (6 → 2), Day 2: 2%2=0, eat 1 orange (2 → 1), Day 3: Eat 1 orange (1 → 0). Total: 3 days.

example_3.py — Edge case

$ Input: n = 1

› Output: 1

💡 Note: Only one orange left, so we eat it in 1 day.

Constraints

1 ≤ n ≤ 2 × 10⁹
Time limit: 1 second
Space limit: 256 MB

Visualization

Tap to expand

Understanding the Visualization

Identify Power-ups

Look for numbers divisible by 2 (50% damage) or 3 (66% damage)

Calculate Path Cost

Eat oranges one-by-one until you can use a power-up

Make the Big Jump

Use division to dramatically reduce the number

Memoize Results

Remember solutions to avoid recalculating

Key Takeaway

🎯 Key Insight: The optimal strategy prioritizes making big jumps by reaching numbers divisible by 2 or 3, combined with memoization to avoid redundant calculations. This transforms an exponential problem into a logarithmic one!

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses memoized recursion with a key optimization: instead of always trying n-1, calculate the cost to reach numbers divisible by 2 or 3, then make big jumps via division. This reduces complexity from O(3ⁿ) to O(log n), making it efficient for large inputs up to 2×10⁹.

Common Approaches

Approach	Time	Space	Notes
✓ Memoized Recursion (Optimal)	O(log n)	O(log n)	Use dynamic programming with memoization to avoid recalculating subproblems
Brute Force Recursion	O(3^n)	O(n)	Try all possible eating strategies recursively without optimization

Memoized Recursion (Optimal) — Algorithm Steps

Create a memoization map to store calculated results
Base case: If n ≤ 1, return n days
Check if result already exists in memo map
Key optimization: Calculate days to reach divisible numbers
For n%2: (n%2) days to eat one-by-one + 1 day to eat n/2 + recurse on n/2
For n%3: (n%3) days to eat one-by-one + 1 day to eat 2n/3 + recurse on n/3
Store and return minimum result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with n=10

Check memo (empty), calculate for n=10

Smart jump calculation

Option 1: 0+1+minDays(5), Option 2: 1+1+minDays(3)

Recursive calls

Calculate minDays(5) and minDays(3) separately

Memoization saves time

Store results to avoid recalculation

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_N 100000
int memo[MAX_N];
int initialized = 0;

int minDays(int n) {
    if (!initialized) {
        memset(memo, -1, sizeof(memo));
        initialized = 1;
    }
    
    if (n < MAX_N && memo[n] != -1) {
        return memo[n];
    }
    
    if (n <= 1) {
        return n;
    }
    
    // Key optimization: calculate cost to reach divisible numbers
    int option1 = (n % 2) + 1 + minDays(n / 2);  // Make divisible by 2
    int option2 = (n % 3) + 1 + minDays(n / 3);  // Make divisible by 3
    
    int result = (option1 < option2) ? option1 : option2;
    
    if (n < MAX_N) {
        memo[n] = result;
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", minDays(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each number can only be calculated once, and we make logarithmic jumps via division by 2 and 3

⚡ Linearithmic

Space Complexity

O(log n)

Memoization map stores at most O(log n) unique subproblems due to the divisibility pattern

⚡ Linearithmic Space

32.8K Views

High Frequency

~25 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Memoized Recursion (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler