Java中如何优化计算Pronic数的解决方案

Question

Recently, in one of the assessments, I came across this question: Given two integers A and B, return the number of integers from the range A..B which can be expressed as the product of two consecutive integers, that is X *(X + 1) which is also known as Pronic Number.

Example 1:

A = 6 and B = 20, the function should return 3, These integers are 6 = 2 * 3, 12 = 3 * 4 and 20 = 4* 5

Example 2:

A = 21 and B = 29, the function should return 0

Assumptions:

1. A and B are integers within the range [1...1000,000,000]
2. A <= B

My solution fails for the extreme input which is 1000,000,000. I got Time Limit Exceeded error. Can somebody please help me to optimize my code further?

    // Java program to check if a number is pronic or not 

import java.io.*; 
import java.util.*; 
import java.math.*; 

class solution 
{ 

    // Function to check Pronic Number 
    static int pronic_check(int A, int B) 
    { 
        int count = 0;
        for (int i = A; i <= B; i++){
            if (i % 2 == 0)      // a pronic number is always even
            {
                int x = (int)(Math.sqrt(i));
                if (x * (x + 1) == i) 
                    count++; 
            }
        }

        return count;
    } 
    
    public static void main(String[] args) 
    {    
        System.out.println(pronic_check(5000, 990000000));
    } 
} 

Thanks in advance.

Answer 1

If you just need the count. I guess this one is going to be best for you.

Explanation: Lets assume, A=6 B=20 . Now, start=sqrt(A)= 2 and end = sqrt(20) = 4 . Initially count = (end-start-1) . Here, you need to check for only start and end . If (end*(end+1))<= B then just increase the count by one. Also check if (start*(start+1) >= A) then increase count by one. So, here the count = 3 .

And here the Time complexity will be constant O(1) .

import java.io.*; 
import java.util.*; 
import java.lang.Math; 

class solution 
{ 
   // Function to check Pronic Number 
    static int pronic_check(int A, int B) 
    { 
        int count = 0;
        int start =  (int) Math.sqrt(A); 
        int end = (int) Math.sqrt(B);
        count = (end -start -1 );
        if (start*(start+1) >= A) {
            count++;
        }
        if (end*(end+1) <= B){
            count++;
        } 

        return count;
    } 
    
    public static void main(String[] args) 
    {    
        System.out.println(pronic_check(5000, 990000000));
    } 
} 

Answer 2

@H.R. Emon Thanks for the intuitive solution!

Based on your idea, I tried modifying the solution a bit. We can find the count of (A-1)'s Pronic Number, a_pronic_count, and the count of B's Pronic Number, b_pronic_count, and use b_pronic_count - a_pronic_count to get the final answer. Time complexity is O(1).

class solution
{
   public static int pronic_count(int A, int B){
       int a_cnt = count(A);
       int b_cnt = count(B);
    
       return b_cnt - a_cnt + 1;
   } 
   public static int count(int num){
       int n = (int)Math.sqrt(num);
    
       if (n*(n+1) == num) return n;
       return  n-1;
   }

   public static void main(String[] args) 
   {    
     System.out.println(pronic_count(1, 1000000000));
   } 
}