Java中Pronic数计算方案的优化

最近，在一次评估中，我遇到了这个问题： 给定两个整数A和B，返回范围A..B中的整数数，该范围可表示为两个连续整数的乘积，即X*（X+1），也称为Pronic数

示例1:

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

示例2:

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

假设：

A和B是[1…100000000]范围内的整数

---

A如果您只需要计数。我想这个对你最好

说明： 让我们假设，

A=6b=20

。 现在，

start=sqrt（A）=2

和

end=sqrt（20）=4

。最初

count=（end-start-1）

。在这里，您只需要检查

start

和

end

。如果

（end*（end+1））=A）

则将

计数增加一。因此，这里的
计数=3

这里的时间复杂度是常数
O（1）

import java.io.*；
导入java.util.*；
导入java.lang.Math；
类解决方案
{ 
//函数检查Pronic编号
静态int pronic_检查（int A，int B）
{ 
整数计数=0；
int start=（int）Math.sqrt（A）；
int end=（int）Math.sqrt（B）；
计数=（结束-开始-1）；
如果（开始*（开始+1）>=A）{
计数++；
}
if（end*（end+1）@H.R.Emon感谢您提供直观的解决方案

基于你的想法，我试着修改一下解决方案。
我们可以找到（A-1）的Pronic数的计数，A_Pronic_计数，和B的Pronic数的计数，B_Pronic_计数，并使用B_Pronic_计数-A_Pronic_计数得到最终答案。
时间复杂度为O（1）

你可以试着在代码复查堆栈交换上提问：也可以看看这个博客：你为什么要删除其他答案？而不仅仅是编辑它？很抱歉。我已经完全使用了一种新的方法。所以我认为如果我只添加一个新的ans会更好。我不知道。谢谢你提供的信息。很好的一个，这很聪明，你减少了O（1）+1的复杂性，因此我将删除我的答案。我试图做同样的事情，但我错过了if（end*（end+1）@H.R.Emon，非常感谢这个简单的解决方案。事实上，这对我来说并不那么直观。你能解释一下只考虑a和B的平方根并计算结果背后的理论吗？考虑过做返回（n*（n+1）=num）？n:n-1；
    // 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));
    } 
} 

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

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