 Open in App
Not now

# Minimum Steps to obtain N from 1 by the given operations

• Difficulty Level : Hard
• Last Updated : 03 Feb, 2023

Given an integer N, the task is to find the minimum number of operations needed to obtain the number N starting from 1. Below are the operations:

• Add 1 to the current number.
• Multiply the current number by 2.
• Multiply the current number by 3.

Print the minimum number of operations required and the corresponding sequence to obtain N.

Examples:

Input: N = 3
Output:

1 3
Explanation:
Operation 1: Multiply 1 * 3 = 3.
Hence, only 1 operation is required.

Input: N = 5
Output:

1 2 4 5
Explanation:
The minimum required operations are as follows:
1 * 2 -> 2
2 * 2 -> 4
4 + 1 -> 5

Recursive Approach: Recursively generate every possible combination to reduce N to 1 and calculate the number of operations required. Finally, after exhausting all possible combinations, print the sequence that required the minimum number of operations.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `vector<``int``> find_sequence(``int` `n)``{``    ` `    ``// Base Case``    ``if` `(n == 1)``        ``return` `{1, -1};` `    ``// Recursive Call for n-1``    ``auto` `arr = find_sequence(n - 1);``    ``vector<``int``> ans = {arr + 1, n - 1};` `    ``// Check if n is divisible by 2``    ``if` `(n % 2 == 0)``    ``{``        ``vector<``int``> div_by_2 = find_sequence(n / 2);` `        ``if` `(div_by_2 < ans)``            ``ans = {div_by_2 + 1, n / 2};``    ``}` `    ``// Check if n is divisible by 3``    ``if` `(n % 3 == 0)``    ``{``        ``vector<``int``> div_by_3 = find_sequence(n / 3);` `        ``if` `(div_by_3 < ans)``            ``vector<``int``> ans = {div_by_3 + 1, n / 3};``    ``}` `    ``// Returns a tuple (a, b), where``    ``// a: Minimum steps to obtain x from 1``    ``// b: Previous number``    ``return` `ans;``}` `// Function that find the optimal``// solution``vector<``int``> find_solution(``int` `n)``{``    ``auto` `a = find_sequence(n);` `    ``// Print the length``    ``cout << a << endl;` `    ``vector<``int``> sequence;``    ``sequence.push_back(n);` `    ``//Exit condition for loop = -1``    ``//when n has reached 1``    ``while` `(a != -1)``    ``{``        ``sequence.push_back(a);``        ``auto` `arr = find_sequence(a);``        ``a = arr;``    ``}` `    ``// Return the sequence``    ``// in reverse order``    ``reverse(sequence.begin(),``            ``sequence.end());` `    ``return` `sequence;``}` `// Driver Code``int` `main()``{``    ` `    ``// Given N``    ``int` `n = 5;``    ` `    ``// Function call``    ``auto` `i = find_solution(n);``    ` `    ``for``(``int` `j : i)``        ``cout << j << ``" "``;``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``import` `java.util.Collections;``import` `java.util.Vector;` `//Vector v = new Vector(n);` `class` `GFG{``  ` `static` `Vector find_sequence(``int` `n)``{``    ``Vector temp = ``new` `Vector();``    ` `    ``temp.add(``1``);``    ``temp.add(-``1``);``    ` `    ``// Base Case``    ``if` `(n == ``1``)``        ``return` `temp;``    ` `    ``// Recursive Call for n-1``    ``Vector arr = find_sequence(n - ``1``);``    ``Vector ans = ``new` `Vector(n);``    ``ans.add(arr.get(``0``) + ``1``);``    ``ans.add(n - ``1``);``    ` `    ``// Check if n is divisible by 2``    ``if` `(n % ``2` `== ``0``)``    ``{``        ``Vector div_by_2 = find_sequence(n / ``2``);``        ` `        ``if` `(div_by_2.get(``0``) < ans.get(``0``))``        ``{``            ``ans.clear();``            ``ans.add(div_by_2.get(``0``) + ``1``);``            ``ans.add(n / ``2``);``        ``}``    ``}` `    ``// Check if n is divisible by 3``    ``if` `(n % ``3` `== ``0``)``    ``{``        ``Vector div_by_3 = find_sequence(n / ``3``);``        ` `        ``if` `(div_by_3.get(``0``) < ans.get(``0``))``        ``{``            ``ans.clear();``            ``ans.add(div_by_3.get(``0``) + ``1``);``            ``ans.add(n / ``3``);``        ``}``    ``}``    ` `    ``// Returns a tuple (a, b), where``    ``// a: Minimum steps to obtain x from 1``    ``// b: Previous number``    ``return` `ans;``}` `// Function that find the optimal``// solution``static` `Vector find_solution(``int` `n)``{``    ``Vector a = find_sequence(n);``    ` `    ``// Print the length``    ``System.out.println(a.get(``0``));``    ` `    ``Vector sequence = ``new` `Vector();``    ``sequence.add(n);``    ` `    ``// Exit condition for loop = -1``    ``// when n has reached 1``    ``while` `(a.get(``1``) != -``1``)``    ``{``        ``sequence.add(a.get(``1``));``        ``Vector arr = find_sequence(a.get(``1``));``        ``a.set(``1``, arr.get(``1``));``    ``}``    ` `    ``// Return the sequence``    ``// in reverse order``    ``Collections.reverse(sequence);``    ` `    ``return` `sequence;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ` `    ``// Given N``    ``int` `n = ``5``;``    ` `    ``// Function call``    ``Vector res = find_solution(n);``    ` `    ``for``(``int` `i = ``0``; i < res.size(); i++)``    ``{``        ``System.out.print(res.get(i) + ``" "``);``    ``}``}``}` `// This code is contributed by Surendra_Gangwar`

## Python3

 `# Python3 program to implement``# the above approach`  `def` `find_sequence(n):` `    ``# Base Case``    ``if` `n ``=``=` `1``:``        ``return` `1``, ``-``1`` ` `    ``# Recursive Call for n-1``    ``ans ``=` `(find_sequence(n ``-` `1``)[``0``] ``+` `1``, n ``-` `1``)`` ` `    ``# Check if n is divisible by 2``    ``if` `n ``%` `2` `=``=` `0``:``        ``div_by_2 ``=` `find_sequence(n ``/``/` `2``)` `        ``if` `div_by_2[``0``] < ans[``0``]:``            ``ans ``=` `(div_by_2[``0``] ``+` `1``, n ``/``/` `2``)`` ` `    ``# Check if n is divisible by 3``    ``if` `n ``%` `3` `=``=` `0``:``        ``div_by_3 ``=` `find_sequence(n ``/``/` `3``)` `        ``if` `div_by_3[``0``] < ans[``0``]:``            ``ans ``=` `(div_by_3[``0``] ``+` `1``, n ``/``/` `3``)`` ` `    ``# Returns a tuple (a, b), where``    ``# a: Minimum steps to obtain x from 1``    ``# b: Previous number``    ``return` `ans`` ` `# Function that find the optimal``# solution``def` `find_solution(n):``    ``a, b ``=` `find_sequence(n)`` ` `    ``# Print the length``    ``print``(a)` `    ``sequence ``=` `[]``    ``sequence.append(n)` `    ``# Exit condition for loop = -1``    ``# when n has reached 1``    ``while` `b !``=` `-``1``:``        ``sequence.append(b)``        ``_, b ``=` `find_sequence(b)`` ` `    ``# Return the sequence``    ``# in reverse order``    ``return` `sequence[::``-``1``]` `# Driver Code` `# Given N``n ``=` `5` `# Function Call``print``(``*``find_solution(n))`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG{``  ` `static` `List<``int``> find_sequence(``int` `n)``{``  ``List<``int``> temp = ``new` `List<``int``>();` `  ``temp.Add(1);``  ``temp.Add(-1);` `  ``// Base Case``  ``if` `(n == 1)``    ``return` `temp;` `  ``// Recursive Call for n-1``  ``List<``int``> arr = find_sequence(n - 1);``  ``List<``int``> ans = ``new` `List<``int``>(n);``  ``ans.Add(arr + 1);``  ``ans.Add(n - 1);` `  ``// Check if n is divisible by 2``  ``if` `(n % 2 == 0)``  ``{``    ``List<``int``> div_by_2 =``         ``find_sequence(n / 2);` `    ``if` `(div_by_2 < ans)``    ``{``      ``ans.Clear();``      ``ans.Add(div_by_2 + 1);``      ``ans.Add(n / 2);``    ``}``  ``}` `  ``// Check if n is divisible``  ``// by 3``  ``if` `(n % 3 == 0)``  ``{``    ``List<``int``> div_by_3 =``         ``find_sequence(n / 3);` `    ``if` `(div_by_3 < ans)``    ``{``      ``ans.Clear();``      ``ans.Add(div_by_3 + 1);``      ``ans.Add(n / 3);``    ``}``  ``}` `  ``// Returns a tuple (a, b), where``  ``// a: Minimum steps to obtain x``  ``// from 1 b: Previous number``  ``return` `ans;``}` `// Function that find the optimal``// solution``static` `List<``int``> find_solution(``int` `n)``{``  ``List<``int``> a = find_sequence(n);` `  ``// Print the length``  ``Console.WriteLine(a);` `  ``List<``int``> sequence =``       ``new` `List<``int``>();``  ``sequence.Add(n);` `  ``// Exit condition for loop = -1``  ``// when n has reached 1``  ``while` `(a != -1)``  ``{``    ``sequence.Add(a);``    ``List<``int``> arr =``         ``find_sequence(a);``    ``a.Insert(1, arr);``  ``}` `  ``// Return the sequence``  ``// in reverse order``  ``sequence.Reverse();``  ``return` `sequence;``}` `// Driver Code``public` `static` `void` `Main(String []args)``{   ``  ``// Given N``  ``int` `n = 5;` `  ``// Function call``  ``List<``int``> res = find_solution(n);` `  ``for``(``int` `i = 0; i < res.Count; i++)``  ``{``    ``Console.Write(res[i] + ``" "``);``  ``}``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output:

```4
1 2 4 5```

Time Complexity: T(N) = T(N-1) + T(N/2) + T(N/3), where N is given integer. This algorithm results in an exponential time complexity.

Auxiliary Space: O(1)

Recursion With Memoization Approach: The above approach can be optimized by memoizing the overlapping subproblems.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to find the sequence``// with given operations``pair<``int``, ``int``> find_sequence(``int` `n,``                             ``map<``int``, pair<``int``, ``int``> >& map)``{``  ``// Base Case``  ``if` `(n == 1)``    ``return` `make_pair(1, -1);` `  ``// Check if the subproblem``  ``// is already computed or not``  ``if` `(map.find(n) != map.end())``    ``return` `map[n];` `  ``// Recursive Call for n-1``  ``pair<``int``, ``int``> ans = make_pair(``    ``(find_sequence(n - 1, map).first + 1), n - 1);` `  ``// Check if n is divisible by 2``  ``if` `(n % 2 == 0) {``    ``pair<``int``, ``int``> div_by_2 = find_sequence(n / 2, map);``    ``if` `(div_by_2.first < ans.first)``      ``ans = make_pair(div_by_2.first + 1, n / 2);``  ``}` `  ``// Check if n is divisible by 3``  ``if` `(n % 3 == 0) {``    ``pair<``int``, ``int``> div_by_3 = find_sequence(n / 3, map);``    ``if` `(div_by_3.first < ans.first)``      ``ans = make_pair(div_by_3.first + 1, n / 3);``  ``}` `  ``// Memoize``  ``map[n] = ans;` `  ``// Returns a tuple (a, b), where``  ``// a: Minimum steps to obtain x from 1``  ``// b: Previous state``  ``return` `ans;``}` `// Function to check if a sequence can``// be obtained with given operations``vector<``int``> find_solution(``int` `n)``{``  ``// Stores the computed``  ``// subproblems``  ``map<``int``, pair<``int``, ``int``> > map;``  ``pair<``int``, ``int``> ans = find_sequence(n, map);` `  ``// Return a sequence in``  ``// reverse order``  ``cout << ans.first << endl;``  ``vector<``int``> sequence;``  ``sequence.push_back(n);` `  ``// If n has reached 1``  ``while` `(ans.second != -1) {``    ``sequence.push_back(ans.second);``    ``ans = find_sequence(ans.second, map);``  ``}` `  ``// Return sequence in reverse order``  ``reverse(sequence.begin(), sequence.end());``  ``return` `sequence;``}` `int` `main()``{` `  ``// Given N``  ``int` `n = 5;` `  ``// Function Call``  ``vector<``int``> seq = find_solution(n);``  ``for` `(``int` `i = 0; i < seq.size(); i++)``    ``cout << seq[i] << ``" "``;``}` `// This code is contributed by lokeshpotta20.`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to find the sequence``# with given operations``def` `find_sequence(n, ``map``):` `    ``# Base Case``    ``if` `n ``=``=` `1``:``        ``return` `1``, ``-``1` `    ``# Check if the subproblem``    ``# is already computed or not``    ``if` `n ``in` `map``:``        ``return` `map``[n]` `    ``# Recursive Call for n-1``    ``ans ``=` `(find_sequence(n ``-` `1``, ``map``)[``0``]\``    ``+` `1``, n ``-` `1``)` `    ``# Check if n is divisible by 2``    ``if` `n ``%` `2` `=``=` `0``:``        ``div_by_2 ``=` `find_sequence(n ``/``/` `2``, ``map``)` `        ``if` `div_by_2[``0``] < ans[``0``]:``            ``ans ``=` `(div_by_2[``0``] ``+` `1``, n ``/``/` `2``)` `    ``# Check if n is divisible by 3``    ``if` `n ``%` `3` `=``=` `0``:``        ``div_by_3 ``=` `find_sequence(n ``/``/` `3``, ``map``)` `        ``if` `div_by_3[``0``] < ans[``0``]:``            ``ans ``=` `(div_by_3[``0``] ``+` `1``, n ``/``/` `3``)` `    ``# Memoize``    ``map``[n] ``=` `ans` `    ``# Returns a tuple (a, b), where``    ``# a: Minimum steps to obtain x from 1``    ``# b: Previous state``    ``return` `ans` `# Function to check if a sequence can``# be obtained with given operations``def` `find_solution(n):` `    ``# Stores the computed``    ``# subproblems``    ``map` `=` `{}``    ``a, b ``=` `find_sequence(n, ``map``)` `    ``# Return a sequence in``    ``# reverse order``    ``print``(a)``    ``sequence ``=` `[]``    ``sequence.append(n)` `    ``# If n has reached 1``    ``while` `b !``=` `-``1``:``        ``sequence.append(b)``        ``_, b ``=` `find_sequence(b, ``map``)` `    ``# Return sequence in reverse order``    ``return` `sequence[::``-``1``]` `# Driver Code` `# Given N``n ``=` `5` `# Function Call``print``(``*``find_solution(n))`

## Javascript

 `// JavaScript implementation of the above approach` `// Function to find the sequence``// with given operations``function` `find_sequence(n, map) {``    ``// Base Case``    ``if` `(n === 1) {``        ``return` `[1, -1];``    ``}` `    ``// Check if the subproblem``    ``// is already computed or not``    ``if` `(map.hasOwnProperty(n)) {``        ``return` `map[n];``    ``}` `    ``// Recursive Call for n-1``    ``let ans = [find_sequence(n - 1, map) + 1, n - 1];` `    ``// Check if n is divisible by 2``    ``if` `(n % 2 === 0) {``        ``let div_by_2 = find_sequence(n / 2, map);` `        ``if` `(div_by_2 < ans) {``            ``ans = [div_by_2 + 1, n / 2];``        ``}``    ``}` `    ``// Check if n is divisible by 3``    ``if` `(n % 3 === 0) {``        ``let div_by_3 = find_sequence(n / 3, map);` `        ``if` `(div_by_3 < ans) {``            ``ans = [div_by_3 + 1, n / 3];``        ``}``    ``}` `    ``// Memoize``    ``map[n] = ans;` `    ``// Returns a tuple [a, b], where``    ``// a: Minimum steps to obtain x from 1``    ``// b: Previous state``    ``return` `ans;``}` `// Function to check if a sequence can``// be obtained with given operations``function` `find_solution(n) {``    ``// Stores the computed``    ``// subproblems``    ``let map = {};``    ``let [a, b] = find_sequence(n, map);` `    ``// Return a sequence in``    ``// reverse order``    ``console.log(a);``    ``let sequence = [];``    ``sequence.push(n);` `    ``// If n has reached 1``    ``while` `(b !== -1) {``        ``sequence.push(b);``        ``[_, b] = find_sequence(b, map);``    ``}` `    ``// Return sequence in reverse order``    ``return` `sequence.reverse();``}` `// Driver Code` `// Given N``let n = 5;` `// Function Call``console.log(...find_solution(n));`

Output:

```4
1 2 4 5```

Time Complexity: O(N)
Auxiliary Space: O(N)

Iterative Dynamic Programming Approach: The above approach can be further optimized by using an iterative DP approach. Follow the steps below to solve the problem:

1. Create an array dp[] to store the minimum length of sequence that is required to compute 1 to N by the three available operations.
2. Once the dp[] array is computed, obtain the sequence by traversing the dp[] array from N to 1.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to generate``// the minimum sequence``void` `find_sequence(``int` `n)``{` `  ``// Stores the values for the``  ``// minimum length of sequences``  ``int` `dp[n + 1];``  ``memset``(dp, 0, ``sizeof``(dp));` `  ``// Base Case``  ``dp = 1;` `  ``// Loop to build up the dp[]``  ``// array from 1 to n``  ``for``(``int` `i = 1; i < n + 1; i++)``  ``{``    ``if` `(dp[i] != 0)``    ``{` `      ``// If i + 1 is within limits``      ``if` `(i + 1 < n + 1 &&``          ``(dp[i + 1] == 0 ||``           ``dp[i + 1] > dp[i] + 1))``      ``{` `        ``// Update the state of i + 1``        ``// in dp[] array to minimum``        ``dp[i + 1] = dp[i] + 1;``      ``}` `      ``// If i * 2 is within limits``      ``if` `(i * 2 < n + 1 &&``          ``(dp[i * 2] == 0 ||``           ``dp[i * 2] > dp[i] + 1))``      ``{` `        ``// Update the state of i * 2``        ``// in dp[] array to minimum``        ``dp[i * 2] = dp[i] + 1;``      ``}` `      ``// If i * 3 is within limits``      ``if` `(i * 3 < n + 1 &&``          ``(dp[i * 3] == 0 ||``           ``dp[i * 3] > dp[i] + 1))``      ``{` `        ``// Update the state of i * 3``        ``// in dp[] array to minimum``        ``dp[i * 3] = dp[i] + 1;``      ``}``    ``}``  ``}` `  ``// Generate the sequence by``  ``// traversing the array``  ``vector<``int``> sequence;``  ``while` `(n >= 1)``  ``{` `    ``// Append n to the sequence``    ``sequence.push_back(n);` `    ``// If the value of n in dp``    ``// is obtained from n - 1:``    ``if` `(dp[n - 1] == dp[n] - 1)``    ``{``      ``n--;``    ``}` `    ``// If the value of n in dp[]``    ``// is obtained from n / 2:``    ``else` `if` `(n % 2 == 0 &&``             ``dp[(``int``)``floor``(n / 2)] == dp[n] - 1)``    ``{``      ``n = (``int``)``floor``(n / 2);``    ``}` `    ``// If the value of n in dp[]``    ``// is obtained from n / 3:``    ``else` `if` `(n % 3 == 0 &&``             ``dp[(``int``)``floor``(n / 3)] == dp[n] - 1)``    ``{``      ``n = (``int``)``floor``(n / 3);``    ``}``  ``}` `  ``// Print the sequence``  ``// in reverse order``  ``reverse(sequence.begin(), sequence.end());` `  ``// Print the length of``  ``// the minimal sequence``  ``cout << sequence.size() << endl;``  ``for``(``int` `i = 0; i < sequence.size(); i++)``  ``{``    ``cout << sequence[i] << ``" "``;``  ``}``}` `// Driver code``int` `main()``{` `  ``// Given Number N``  ``int` `n = 5;` `  ``// Function Call``  ``find_sequence(n);` `  ``return` `0;``}` `// This code is contributed by divyeshrabadiya07`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{``    ` `// Function to generate``// the minimum sequence``public` `static` `void` `find_sequence(``int` `n)``{``    ` `    ``// Stores the values for the``    ``// minimum length of sequences``    ``int``[] dp = ``new` `int``[n + ``1``];``    ``Arrays.fill(dp, ``0``);``    ` `    ``// Base Case``    ``dp[``1``] = ``1``;``    ` `    ``// Loop to build up the dp[]``    ``// array from 1 to n``    ``for``(``int` `i = ``1``; i < n + ``1``; i++)``    ``{``        ``if` `(dp[i] != ``0``)``        ``{``            ` `            ``// If i + 1 is within limits``            ``if` `(i + ``1` `< n + ``1` `&&``            ``(dp[i + ``1``] == ``0` `||``             ``dp[i + ``1``] > dp[i] + ``1``))``            ``{``                ` `                ``// Update the state of i + 1``                ``// in dp[] array to minimum``                ``dp[i + ``1``] = dp[i] + ``1``;``            ``}``            ` `            ``// If i * 2 is within limits``            ``if` `(i * ``2` `< n + ``1` `&&``            ``(dp[i * ``2``] == ``0` `||``             ``dp[i * ``2``] > dp[i] + ``1``))``            ``{``                ` `                ``// Update the state of i * 2``                ``// in dp[] array to minimum``                ``dp[i * ``2``] = dp[i] + ``1``;``            ``}``            ` `            ``// If i * 3 is within limits``            ``if` `(i * ``3` `< n + ``1` `&&``            ``(dp[i * ``3``] == ``0` `||``             ``dp[i * ``3``] > dp[i] + ``1``))``            ``{``                ` `                ``// Update the state of i * 3``                ``// in dp[] array to minimum``                ``dp[i * ``3``] = dp[i] + ``1``;``            ``}``        ``}``    ``}``    ` `    ``// Generate the sequence by``    ``// traversing the array``    ``List sequence = ``new` `ArrayList();``    ``while` `(n >= ``1``)``    ``{``        ` `        ``// Append n to the sequence``        ``sequence.add(n);``        ` `        ``// If the value of n in dp``        ``// is obtained from n - 1:``        ``if` `(dp[n - ``1``] == dp[n] - ``1``)``        ``{``            ``n--;``        ``}``        ` `        ``// If the value of n in dp[]``        ``// is obtained from n / 2:``        ``else` `if` `(n % ``2` `== ``0` `&&``         ``dp[(``int``)Math.floor(n / ``2``)] == dp[n] - ``1``)``        ``{``            ``n = (``int``)Math.floor(n / ``2``);``        ``}``        ` `        ``// If the value of n in dp[]``        ``// is obtained from n / 3:``        ``else` `if` `(n % ``3` `== ``0` `&&``         ``dp[(``int``)Math.floor(n / ``3``)] == dp[n] - ``1``)``        ``{``            ``n = (``int``)Math.floor(n / ``3``);``        ``}``    ``}``    ` `    ``// Print the sequence``    ``// in reverse order``    ``Collections.reverse(sequence);``    ` `    ``// Print the length of``    ``// the minimal sequence``    ``System.out.println(sequence.size());``    ``for``(``int` `i = ``0``; i < sequence.size(); i++)``    ``{``        ``System.out.print(sequence.get(i) + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ` `    ``// Given Number N``    ``int` `n = ``5``;``    ` `    ``// Function Call``    ``find_sequence(n);``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to generate``# the minimum sequence``def` `find_sequence(n):` `    ``# Stores the values for the``    ``# minimum length of sequences``    ``dp ``=` `[``0` `for` `_ ``in` `range``(n ``+` `1``)]` `    ``# Base Case``    ``dp[``1``] ``=` `1` `    ``# Loop to build up the dp[]``    ``# array from 1 to n``    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        ``if` `dp[i] !``=` `0``:` `            ``# If i + 1 is within limits``            ``if` `i ``+` `1` `< n ``+` `1` `and` `(dp[i ``+` `1``] ``=``=` `0` `\``            ``or` `dp[i ``+` `1``] > dp[i] ``+` `1``):``                ` `                ``# Update the state of i + 1``                ``# in dp[] array to minimum``                ``dp[i ``+` `1``] ``=` `dp[i] ``+` `1` `            ``# If i * 2 is within limits``            ``if` `i ``*` `2` `< n ``+` `1` `and` `(dp[i ``*` `2``] ``=``=` `0` `\``            ``or` `dp[i ``*` `2``] > dp[i] ``+` `1``):``                ` `                ``# Update the state of i * 2``                ``# in dp[] array to minimum``                ``dp[i ``*` `2``] ``=` `dp[i] ``+` `1` `            ``# If i * 3 is within limits``            ``if` `i ``*` `3` `< n ``+` `1` `and` `(dp[i ``*` `3``] ``=``=` `0` `\``            ``or` `dp[i ``*` `3``] > dp[i] ``+` `1``):``                ` `                ``# Update the state of i * 3``                ``# in dp[] array to minimum``                ``dp[i ``*` `3``] ``=` `dp[i] ``+` `1` `    ``# Generate the sequence by``    ``# traversing the array``    ``sequence ``=` `[]``    ``while` `n >``=` `1``:` `        ``# Append n to the sequence``        ``sequence.append(n)` `        ``# If the value of n in dp``        ``# is obtained from n - 1:``        ``if` `dp[n ``-` `1``] ``=``=` `dp[n] ``-` `1``:``            ``n ``=` `n ``-` `1` `        ``# If the value of n in dp[]``        ``# is obtained from n / 2:``        ``elif` `n ``%` `2` `=``=` `0` `\``        ``and` `dp[n ``/``/` `2``] ``=``=` `dp[n] ``-` `1``:``            ``n ``=` `n ``/``/` `2` `        ``# If the value of n in dp[]``        ``# is obtained from n / 3:``        ``elif` `n ``%` `3` `=``=` `0` `\``        ``and` `dp[n ``/``/` `3``] ``=``=` `dp[n] ``-` `1``:``            ``n ``=` `n ``/``/` `3` `    ``# Return the sequence``    ``# in reverse order``    ``return` `sequence[::``-``1``]` `# Driver Code` `# Given Number N``n ``=` `5` `# Function Call``sequence ``=` `find_sequence(n)` `# Print the length of``# the minimal sequence``print``(``len``(sequence))` `# Print the sequence``print``(``*``sequence)`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``// Function to generate``  ``// the minimum sequence``  ``public` `static` `void` `find_sequence(``int` `n)``  ``{` `    ``// Stores the values for the``    ``// minimum length of sequences``    ``int``[] dp = ``new` `int``[n + 1];``    ``Array.Fill(dp, 0);` `    ``// Base Case``    ``dp = 1;` `    ``// Loop to build up the dp[]``    ``// array from 1 to n``    ``for``(``int` `i = 1; i < n + 1; i++)``    ``{``      ``if``(dp[i] != 0)``      ``{` `        ``// If i + 1 is within limits``        ``if``(i + 1 < n + 1 &&``           ``(dp[i + 1] == 0 ||``            ``dp[i + 1] > dp[i] + 1))``        ``{` `          ``// Update the state of i + 1``          ``// in dp[] array to minimum``          ``dp[i + 1] = dp[i] + 1;``        ``}` `        ``// If i * 2 is within limits``        ``if``(i * 2 < n + 1 &&``           ``(dp[i * 2] == 0 ||``            ``dp[i * 2] > dp[i] + 1))``        ``{` `          ``// Update the state of i * 2``          ``// in dp[] array to minimum``          ``dp[i * 2] = dp[i] + 1;``        ``}` `        ``// If i * 3 is within limits``        ``if``(i * 3 < n + 1 &&``           ``(dp[i * 3] == 0 ||``            ``dp[i * 3] > dp[i] + 1))``        ``{` `          ``// Update the state of i * 3``          ``// in dp[] array to minimum``          ``dp[i * 3] = dp[i] + 1;``        ``}       ``      ``}``    ``}` `    ``// Generate the sequence by``    ``// traversing the array``    ``List<``int``> sequence = ``new` `List<``int``>();``    ``while``(n >= 1)``    ``{` `      ``// Append n to the sequence``      ``sequence.Add(n);` `      ``// If the value of n in dp``      ``// is obtained from n - 1:``      ``if``(dp[n - 1] == dp[n] - 1)``      ``{``        ``n--;``      ``}` `      ``// If the value of n in dp[]``      ``// is obtained from n / 2:``      ``else` `if``(n % 2 == 0 &&``              ``dp[(``int``)Math.Floor((``decimal``)n / 2)] ==``              ``dp[n] - 1)``      ``{``        ``n = (``int``)Math.Floor((``decimal``)n / 2);``      ``}` `      ``// If the value of n in dp[]``      ``// is obtained from n / 3:``      ``else` `if``(n % 3 == 0 &&``              ``dp[(``int``)Math.Floor((``decimal``)n / 3)] ==``              ``dp[n] - 1)``      ``{``        ``n = (``int``)Math.Floor((``decimal``)n / 3);``      ``}` `    ``}` `    ``// Print the sequence``    ``// in reverse order``    ``sequence.Reverse();` `    ``// Print the length of``    ``// the minimal sequence``    ``Console.WriteLine(sequence.Count);``    ``for``(``int` `i = 0; i < sequence.Count; i++)``    ``{``      ``Console.Write(sequence[i] + ``" "``);``    ``}``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main ()``  ``{` `    ``// Given Number N``    ``int` `n = 5;` `    ``// Function Call``    ``find_sequence(n);``  ``}``}` `// This code is contributed by rag2127`

## Javascript

 ``

Output:

```4
1 3 4 5```

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up