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

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

最近，在其中一项评估中，我遇到了这个问题：给定两个整数 A 和 B，返回 A..B 范围内的整数个数，可以表示为两个连续整数的乘积，即 X *(X + 1)，也称为 Pronic Number。>

示例 1：

A = 6 和 B = 20，函数应该返回 3，这些整数是 6 = 2 * 3、12 = 3 * 4 和 20 = 4* 5

示例 2：

A = 21 和 B = 29，函数应该返回 0

假设：

A 和 B 是 [1...1000,000,000] 范围内的整数
A

对于 1000,000 的极端输入，我的解决方案失败了。我收到超出时间限制的错误。有人可以帮我进一步优化我的代码吗？

    // 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));
    } 
}

提前致谢。

解决方法

如果您只需要计数。我想这个对你来说是最好的。

说明： 让我们假设，A=6 B=20。现在，start=sqrt(A)= 2 和 end = sqrt(20) = 4 。最初count = (end-start-1)。在这里，您只需要检查 start 和 end。如果 (end*(end+1))<= B 则只需将 count 增加一。还要检查是否 (start*(start+1) >= A) 然后将 count 增加一。所以，这里是 count = 3。

这里的时间复杂度将是常数 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));
    } 
}

@H.R. Emon 感谢您提供直观的解决方案！

根据您的想法，我尝试稍微修改解决方案。我们可以求出(A-1)的Pronic Number的计数a_pronic_count，和B的Pronic Number的计数b_pronic_count，用b_pronic_count - a_pronic_count得到最终答案。时间复杂度为 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));
   } 
}