Given two positive integers **N** and **K**, the task is to find the value of **N** after incrementing the value of **N** in each operation by its smallest divisor exceeding **N** ( *exceeding 1* ), exactly **K** times.

**Examples:**

Input:N = 5, K = 2Output:12Explanation:

Smallest divisor of N (= 5) is 5. Therefore, N = 5 + 5 = 10.

Smallest divisor of N (= 10) is 2. Therefore, N = 5 + 2 = 12.

Therefore, the required output is 12.

Input:N = 6, K = 4Output:14

**Naive Approach:** The simplest approach to solve this problem to iterate over the range **[1, K]** using variable **i** and in each operation, find the smallest divisors greater than **1** of N and increment the value of **N** by the smallest divisor greater than **1** of **N**. Finally, print the value of **N**.

Below is the implementation of the above approach:

## C++

`// C++ program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the smallest` `// divisor of N greater than 1` `int` `smallestDivisorGr1(` `int` `N)` `{` ` ` `for` `(` `int` `i = 2; i <= ` `sqrt` `(N);` ` ` `i++) {` ` ` `// If i is a divisor` ` ` `// of N` ` ` `if` `(N % i == 0) {` ` ` `return` `i;` ` ` `}` ` ` `}` ` ` `// If N is a prime number` ` ` `return` `N;` `}` `// Function to find the value of N by` `// performing the operations K times` `int` `findValOfNWithOperat(` `int` `N, ` `int` `K)` `{` ` ` `// Iterate over the range [1, K]` ` ` `for` `(` `int` `i = 1; i <= K; i++) {` ` ` `// Update N` ` ` `N += smallestDivisorGr1(N);` ` ` `}` ` ` `return` `N;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 6, K = 4;` ` ` `cout << findValOfNWithOperat(N, K);` ` ` `return` `0;` `}` |

## Java

`// Java program to implement` `// the above approach` `class` `GFG{` `// Function to find the smallest` `// divisor of N greater than 1` `static` `int` `smallestDivisorGr1(` `int` `N)` `{` ` ` `for` `(` `int` `i = ` `2` `; i <= Math.sqrt(N);` ` ` `i++) {` ` ` `// If i is a divisor` ` ` `// of N` ` ` `if` `(N % i == ` `0` `) {` ` ` `return` `i;` ` ` `}` ` ` `}` ` ` `// If N is a prime number` ` ` `return` `N;` `}` `// Function to find the value of N by` `// performing the operations K times` `static` `int` `findValOfNWithOperat(` `int` `N, ` `int` `K)` `{` ` ` `// Iterate over the range [1, K]` ` ` `for` `(` `int` `i = ` `1` `; i <= K; i++)` ` ` `{` ` ` `// Update N` ` ` `N += smallestDivisorGr1(N);` ` ` `}` ` ` `return` `N;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `6` `, K = ` `4` `;` ` ` `System.out.print(findValOfNWithOperat(N, K));` `}` `}` `// This code is contributed by shikhasingrajput` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `public` `class` `GFG` `{` ` ` `// Function to find the smallest` ` ` `// divisor of N greater than 1` ` ` `static` `int` `smallestDivisorGr1(` `int` `N)` ` ` `{` ` ` `for` `(` `int` `i = 2; i <= Math.Sqrt(N);` ` ` `i++) {` ` ` `// If i is a divisor` ` ` `// of N` ` ` `if` `(N % i == 0) {` ` ` `return` `i;` ` ` `}` ` ` `}` ` ` `// If N is a prime number` ` ` `return` `N;` ` ` `}` ` ` `// Function to find the value of N by` ` ` `// performing the operations K times` ` ` `static` `int` `findValOfNWithOperat(` `int` `N, ` `int` `K)` ` ` `{` ` ` `// Iterate over the range [1, K]` ` ` `for` `(` `int` `i = 1; i <= K; i++)` ` ` `{` ` ` `// Update N` ` ` `N += smallestDivisorGr1(N);` ` ` `}` ` ` `return` `N;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main(String[] args)` ` ` `{` ` ` `int` `N = 6, K = 4;` ` ` `Console.Write(findValOfNWithOperat(N, K));` ` ` `}` `}` `// This code is contributed by 29AjayKumar` |

## Javascript

`<script>` `// JavaScript program to implement` `// the above approach` `// Function to find the smallest` `// divisor of N greater than 1` `function` `smallestDivisorGr1(N)` `{` ` ` `for` `(let i = 2; i <= Math.sqrt(N);` ` ` `i++) {` ` ` `// If i is a divisor` ` ` `// of N` ` ` `if` `(N % i == 0)` ` ` `{` ` ` `return` `i;` ` ` `}` ` ` `}` ` ` `// If N is a prime number` ` ` `return` `N;` `}` `// Function to find the value of N by` `// performing the operations K times` `function` `findValOfNWithOperat(N, K)` `{` ` ` `// Iterate over the range [1, K]` ` ` `for` `(let i = 1; i <= K; i++)` ` ` `{` ` ` `// Update N` ` ` `N += smallestDivisorGr1(N);` ` ` `}` ` ` `return` `N;` `}` `// Driver Code` `let N = 6, K = 4;` `document.write(findValOfNWithOperat(N, K));` `// This code is contributed by Surbhi Tyagi.` `</script>` |

**Output:**

14

**Time Complexity:** O(K * √N)**Auxiliary Space:** O(1)

**Efficient Approach:** Follow the steps below to solve the problem:

- If N is an even number then update the value of
**N**to**(N + K * 2)**. - Otherwise, find the smallest positive divisor greater than
**1**of**N**say,**smDiv**and update the value**N**to**(N + smDiv + (K – 1) * 2)** - Finally, print the value of
**N**.

Below is the implementation of the above approach:

## C++14

`// C++ program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the smallest` `// divisor of N greater than 1` `int` `smallestDivisorGr1(` `int` `N)` `{` ` ` `for` `(` `int` `i = 2; i <= ` `sqrt` `(N);` ` ` `i++) {` ` ` `// If i is a divisor` ` ` `// of N` ` ` `if` `(N % i == 0) {` ` ` `return` `i;` ` ` `}` ` ` `}` ` ` `// If N is a prime number` ` ` `return` `N;` `}` `// Function to find the value of N by` `// performing the operations K times` `int` `findValOfNWithOperat(` `int` `N, ` `int` `K)` `{` ` ` `// If N is an even number` ` ` `if` `(N % 2 == 0) {` ` ` `// Update N` ` ` `N += K * 2;` ` ` `}` ` ` `// If N is an odd number` ` ` `else` `{` ` ` `// Update N` ` ` `N += smallestDivisorGr1(N)` ` ` `+ (K - 1) * 2;` ` ` `}` ` ` `return` `N;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 6, K = 4;` ` ` `cout << findValOfNWithOperat(N, K);` ` ` `return` `0;` `}` |

**Output:**

14

**Time Complexity:** O(√N)**Auxiliary Space:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.