Minimize operations to reduce N to 0 by replacing N by its divisor at each step

Given a positive integer N. Find the minimum number of operations needed to reduce N to 0 when N can reduced by its divisor at each operation.

Example:

Input: N = 5
Output: 4
Explanation:
Reduce 5 as 5-1=4.
Reduce 4 as 4-2=2.
Reduce 2 as 2-1=1.
Reduce 1 as 1-1=0.

Input: N = 8
Output: 4
Explanation:
Reduce 8 as 8-4=4.
Reduce 4 as 4-2=2.
Reduce 2 as 2-1=1.
Reduce 1 as 1-1=0.

Naive Approach:

One easy approach is to find highest divisor of N each time until N becomes 0.

Follow the below steps to solve this problem:

Traverse until N becomes 0.
Find the highest divisor of N and subtract from N.
Count the number of iterations required for N to become 0 this way.
Return the count calculated above as the final answer.

C++14

// C++ program to minimize operations
// to reduce N to 0 by replacing
// N by its divisor at each step

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

ll findElement(ll N)
{
    for (ll i = 2; i * i <= N; i++) {
        if (N % i == 0)
            return N / i;
    }
    return 1;
}

// Function to count minimum number
// of operation
ll minOperations(ll N)
{
    if (N < 0)
        return -1;

    ll count = 0;
    while (N) {
        ll divisor = findElement(N);
        N -= divisor;
        count++;
    }
    return count;
}

// Driver code
int main()
{
    ll N = 5;
    cout << minOperations(N);

    return 0;
}

Java

// Java program to minimize operations
// to reduce N to 0 by replacing
// N by its divisor at each step
import java.io.*;

class GFG {

  static long findElement(long N)
  {
    for (long i = 2; i * i <= N; i++) {
      if (N % i == 0)
        return N / i;
    }
    return 1;
  }

  // Function to count minimum number
  // of operation
  static long minOperations(long N)
  {
    if (N < 0)
      return -1;

    long count = 0;
    while (N > 0) {
      long divisor = findElement(N);
      N -= divisor;
      count++;
    }
    return count;
  }

  // Driver code
  public static void main (String[] args) {
    long N = 5;
    System.out.print(minOperations(N));
  }
}

// This code is contributed by hrithikgarg03188.

Python3

# Python3 program to minimize operations
# to reduce N to 0 by replacing N by its
# divisor at each step

# function to find the element
def findElement(N):
    i = 2
    while i * i <= N:
        if N % i == 0:
            return int(N / i)
        i += 1
    return 1

# function to count the min number of operations
def minOperations(N):
    if N < 0:
        return -1
    count = 0
    while N:
        divisor = findElement(N)
        N -= divisor
        count += 1
    return count

# Driver Code
N = 5
print(minOperations(N))

# This code is contributed by phasing17

// C# program to minimize operations
// to reduce N to 0 by replacing
// N by its divisor at each step
using System;
class GFG {
  static long findElement(long N)
  {
    for (long i = 2; i * i <= N; i++) {
      if (N % i == 0)
        return N / i;
    }
    return 1;
  }

  // Function to count minimum number
  // of operation
  static long minOperations(long N)
  {
    if (N < 0)
      return -1;

    long count = 0;
    while (N > 0) {
      long divisor = findElement(N);
      N -= divisor;
      count++;
    }
    return count;
  }

  // Driver code
  public static void Main()
  {
    long N = 5;
    Console.WriteLine(minOperations(N));
  }
}

// This code is contributed by Samim Hossain Mondal.

JavaScript

    <script>
        // JavaScript program to minimize operations
        // to reduce N to 0 by replacing
        // N by its divisor at each step
        const findElement = (N) => {
            for (let i = 2; i * i <= N; i++) {
                if (N % i == 0)
                    return parseInt(N / i);
            }
            return 1;
        }

        // Function to count minimum number
        // of operation
        const minOperations = (N) => {
            if (N < 0)
                return -1;

            let count = 0;
            while (N) {
                let divisor = findElement(N);
                N -= divisor;
                count++;
            }
            return count;
        }

        // Driver code
        let N = 5;
        document.write(minOperations(N));

    // This code is contributed by rakeshsahni

    </script>

Output:

Time Complexity: O(N^(3/2))
Auxiliary Space: O(1)

Efficient Approach: Above solution can be optimized using pre-computation using Sieve of Eratosthenes for smallest prime factor and modifying it a bit for storing highest factor of N.