Check whether a number can be represented as difference of two consecutive cubes

Given a number N, the task is to check if the number N can be represented as the difference of two consecutive cubes or not. If Yes then print those numbers else print No.

Examples:

Input: N = 19 
Output:
Yes  
2 3
Explanation:
3³ – 2³ = 19

Input: N = 10 
Output: No 

Approach: The key observation in the problem is that a number can be represented as difference of two consecutive cubes if and only if:

=> N = (K+1)³ – K³
=> N = 3*K² + 3*K + 1 
=> 12*N = 36*K² + 36*K + 12 
=> 12*N = (6*K + 3)² + 3 
=> 12*N – 3 = (6*K + 3)²
which means (12*N – 3) must be a perfect square to break N into difference of two consecutive cubes.

Therefore, if the above condition holds true then we will print the numbers using a for a loop by check that for which value of i if (i+1)³ – i³ = N and print the number i and i + 1.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to print the two consecutive
// numbers whose difference is N
void print(int N)
{
    // Iterate in the range [0, 10^5]
    for (int i = 0; i < 100000; i++) {

        if (pow(i + 1, 3)
                - pow(i, 3)
            == N) {

            cout << i << ' ' << i + 1;
            return;
        }
    }
}

// Function to check if N is a
// perfect cube
bool isPerfectSquare(long double x)
{
    // Find floating point value of
    // square root of x.
    long double sr = sqrt(x);

    // If square root is an integer
    return ((sr - floor(sr)) == 0);
}

// Function to check whether a number
// can be represented as difference
// of two consecutive cubes
bool diffCube(int N)
{
    // Check if 12 * N - 3 is a
    // perfect square or not
    return isPerfectSquare(12 * N - 3);
}

// Driver Code
int main()
{
    // Given Number N
    int N = 19;
    if (diffCube(N)) {
        cout << "Yes\n";
        print(N);
    }
    else {
        cout << "No\n";
    }
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{

// Function to print the two consecutive
// numbers whose difference is N
static void print(int N)
{
    // Iterate in the range [0, 10^5]
    for (int i = 0; i < 100000; i++)
    {

        if (Math.pow(i + 1, 3) - Math.pow(i, 3) == N)
        {
            int j = i + 1;
            System.out.println(i + " " + j);
            return;
        }
    }
}

// Function to check if N is a
// perfect cube
static boolean isPerfectSquare(double x)
{
    // Find floating point value of
    // square root of x.
    double sr = Math.sqrt(x);

    // If square root is an integer
    return ((sr - Math.floor(sr)) == 0);
}

// Function to check whether a number
// can be represented as difference
// of two consecutive cubes
static boolean diffCube(int N)
{
    // Check if 12 * N - 3 is a
    // perfect square or not
    return isPerfectSquare(12 * N - 3);
}

// Driver Code
public static void main(String[] args)
{
    // Given Number N
    int N = 19;
    if (diffCube(N))
    {
        System.out.println("Yes");
        print(N);
    }
    else
    {
        System.out.println("No");
    }
}
}

// This code is contributed by rock_cool

Python3

# Python3 program for the above approach
import math

# Function to print the two consecutive
# numbers whose difference is N
def printt(N):

    # Iterate in the range [0, 10^5]
    for i in range(100000):
        if (pow(i + 1, 3) - pow(i, 3) == N):
            print(i, '', i + 1)
            return

# Function to check if N is a
# perfect cube
def isPerfectSquare(x):

    # Find floating povalue of
    # square root of x.
    sr = math.sqrt(x)

    # If square root is an integer
    return ((sr - math.floor(sr)) == 0)

# Function to check whether a number
# can be represented as difference
# of two consecutive cubes
def diffCube(N):

    # Check if 12 * N - 3 is a
    # perfect square or not
    return isPerfectSquare(12 * N - 3)

# Driver Code

# Given number N
N = 19

if (diffCube(N)):
    print("Yes")
    printt(N)

else:
    print("No")

# This code is contributed by sanjoy_62

C#

// C# program for the above approach
using System;
class GFG{

// Function to print the two consecutive
// numbers whose difference is N
static void print(int N)
{
    // Iterate in the range [0, 10^5]
    for (int i = 0; i < 100000; i++)
    {

        if (Math.Pow(i + 1, 3) - Math.Pow(i, 3) == N)
        {
            int j = i + 1;
            Console.WriteLine(i + " " + j);
            return;
        }
    }
}

// Function to check if N is a
// perfect cube
static bool isPerfectSquare(double x)
{
    // Find floating point value of
    // square root of x.
    double sr = Math.Sqrt(x);

    // If square root is an integer
    return ((sr - Math.Floor(sr)) == 0);
}

// Function to check whether a number
// can be represented as difference
// of two consecutive cubes
static bool diffCube(int N)
{
    // Check if 12 * N - 3 is a
    // perfect square or not
    return isPerfectSquare(12 * N - 3);
}

// Driver Code
public static void Main(String[] args)
{
    // Given Number N
    int N = 19;
    if (diffCube(N))
    {
        Console.WriteLine("Yes");
        print(N);
    }
    else
    {
        Console.WriteLine("No");
    }
}
}

// This code is contributed by Rajput-Ji

Javascript

<script>

// Javascript program for the above approach

// Function to print the two consecutive
// numbers whose difference is N
function print(N)
{

    // Iterate in the range [0, 10^5]
    for(let i = 0; i < 100000; i++)
    {
        if (parseInt(Math.pow(i + 1, 3), 10) -
            parseInt(Math.pow(i, 3), 10) == N)
        {
            document.write(i + " " + (i + 1));
            return;
        }
    }
}

// Function to check if N is a
// perfect cube
function isPerfectSquare(x)
{

    // Find floating point value of
    // square root of x.
    let sr = Math.sqrt(x);

    // If square root is an integer
    return ((sr - Math.floor(sr)) == 0);
}

// Function to check whether a number
// can be represented as difference
// of two consecutive cubes
function diffCube(N)
{

    // Check if 12 * N - 3 is a
    // perfect square or not
    return isPerfectSquare(12 * N - 3);
}

// Driver code

// Given Number N
let N = 19;

if (diffCube(N) != 0)
{
    document.write("Yes" + "</br>");
    print(N);
}
else
{
    document.write("No");
}

// This code is contributed by divyeshrabadiya07

</script>

Output:

Yes
2 3

Time Complexity: O(N), where N is in the range 10⁵
Auxiliary Space: O(1)