Java 查找与某个数字、某个数字最接近的因子

我试图自动寻找一个数字与另一个数字最接近的因子

示例：

700到30的最接近系数是28（30不等于700，但28等于700）

一个显而易见的解决方案是，只需获得700的所有因子，并进行简单的距离计算，以找到最接近30的因子，但这似乎效率低下

另一个解决方案是找到所有基本素因子，如：

private List<Integer> getPrimeFactors(int upTo) {
    List<Integer> result = new ArrayList<>();
    for (int i = 2; i <= upTo; i++) {
        if (upTo % i == 0) {
            result.add(i);
        }
    }
    return result;
}

私有列表getPrimeFactors（整数到）{
列表结果=新建ArrayList（）；
对于（int i=2；i你不需要计算所有的因子，但是你可以从这个数的两个方向去寻找它最接近的数，它是给定数的因子

PSEDOO代码将为：

n= given number(dividend);
x= second number( whose closest number is required)
i=0;
if(n%x==0) print x;
else
while(true){
   if(n%(x-i)==0){
      print x-i
      break 
   }
   else if(n%(x+i)==0){
     print x+i;    
       break 
   }
   else i=i+1
}

packagedummy；
公开课考试{
公共静态void main（字符串[]args）{
int factorf=700；
int factorFrom=30；
对于（int i=2；i1&&factorFrom%（factorFrom-i）==0）{
System.out.println（factorFrom-i）；
i=系数f；
}
}
}
}
我将解决方案包装在一个小型静态方法中：

/**
* @param target the number you want the factor to be close to
* @param number the number you want the result to be a factor of
*/
private static int getClosestFactor(int target, int number) {
    for (int i = 0; i < number; i++) {
        if (number % (target + i) == 0) {
            return target + i;
        } else if (number % (target - i) == 0) {
            return target - i;
        }
    }
    return number;
}

/**
*@param target您希望因子接近的数字
*@param number您希望结果作为因子的数字
*/
私有静态int getClosestFactor（int目标，int编号）{
for（int i=0；i
这应该是一个快速的解决方案：

public static int findClosestFactor(int number, int closeTo) {
    int result = 1;
    int currentDist = closeTo - 1;
    // stop conditions for comparison
    boolean compareSmallFactor = true;
    boolean compareLargeFactor = true;
    for (int factor1 = (int) Math.sqrt(number); factor1 > 0; factor1--) {
        if (number % factor1 == 0) {
            if (compareSmallFactor) {
                int dist1 = Math.abs(closeTo - factor1);
                if (dist1 < currentDist) {
                    result = factor1;
                    currentDist = dist1;
                }
                // factor 1 is getting always smaller
                // so you need not compare next time, if go away from target (smaller than target)
                if (factor1 <= closeTo) {
                    compareSmallFactor = false;
                }
            }

            if (compareLargeFactor) {
                int factor2 = number / factor1;
                int dist2 = Math.abs(closeTo - factor2);
                if (dist2 < currentDist) {
                    result = factor2;
                    currentDist = dist2;
                }
                // factor 2 is getting always larger
                // so you need not compare next time, if go away from target (larger than target)
                if (factor2 >= closeTo) {
                    compareLargeFactor = false;
                }
            }

            // if both factors go away from target, you can cancel
            if (!compareSmallFactor && !compareLargeFactor) {
                break;
            }
        }
    }
    return result;
}

public static int findClosestFactor（int number，int closeTo）{
int结果=1；
int currentDist=接近-1；
//比较的停止条件
布尔comparesmalfactor=true；
布尔比较器argefactor=true；
对于（int factor1=（int）Math.sqrt（number）；factor1>0；factor1--）{
如果（数字%factor1==0）{
if（比较小因素）{
int dist1=Math.abs（接近因子1）；
if（dist1
您可以对数字进行因子分解，然后使用功率集生成器（对于多集[1]）搜索最接近最大值的一组因子，而无需进行检查

可以修改功率集生成器，以防止进一步向下迭代超过所需值的分支（分支和边界）。即：如果因子
（2,5,7,13,19）
。数字是
80
，您有
2*5*7=70.2*5*7*13=910
。无需检查
2*5*7*19
，因为它显然会超过最大值

[1] 将因式分解视为多集是一个好主意。例如，在
700的情况下，（（2,2）、（5,2）、（7,1））
。您可以将其视为（2,2,5,5,7），但它会做额外的工作，因为不需要多次找到2*5=10，但如果不将其视为多集，则会发生这种情况。
这是一个数学问题，如果您有编程问题，请说明它为什么不是编程问题？继续递减数字（30）直到找到一个
input%value==0
。不知道它是否更有效：-）@RobbyCornelissen别忘了incrementing@kai取决于“最近的”的定义。您的（伪）系统会发生什么情况代码为
n=19
和
x=3
。@CiaPan：我觉得代码似乎会打印
1
。是的，它会打印1，因为它是满足给定条件的最接近的数字。啊，是的，你们都是对的。我一定是误读了代码…顺便说一句，第一个
如果..否则
，同样的测试也会进行（两次）在第一次
迭代中，使用
i==0
进行迭代。什么是数字，什么是最大值？这似乎完全错误。@你想详细说明一下吗？数字是你希望因子接近的数字，最大值是你要除以的数字。将
数字
重命名为
目标
，将
最大值
重命名为
数字，不要忘了检查
number%target==0
。好的，这通常是有效的，但在第一次返回时，您的意思肯定是
return target+i
。它会遇到一些极值问题。如果
target=0
，它会崩溃。如果
target<-2*number
您将得到
number
，但结果应该是这样的
1
（如果只需要积极因素a）。
public static int findClosestFactor(int number, int closeTo) {
    int result = 1;
    int currentDist = closeTo - 1;
    // stop conditions for comparison
    boolean compareSmallFactor = true;
    boolean compareLargeFactor = true;
    for (int factor1 = (int) Math.sqrt(number); factor1 > 0; factor1--) {
        if (number % factor1 == 0) {
            if (compareSmallFactor) {
                int dist1 = Math.abs(closeTo - factor1);
                if (dist1 < currentDist) {
                    result = factor1;
                    currentDist = dist1;
                }
                // factor 1 is getting always smaller
                // so you need not compare next time, if go away from target (smaller than target)
                if (factor1 <= closeTo) {
                    compareSmallFactor = false;
                }
            }

            if (compareLargeFactor) {
                int factor2 = number / factor1;
                int dist2 = Math.abs(closeTo - factor2);
                if (dist2 < currentDist) {
                    result = factor2;
                    currentDist = dist2;
                }
                // factor 2 is getting always larger
                // so you need not compare next time, if go away from target (larger than target)
                if (factor2 >= closeTo) {
                    compareLargeFactor = false;
                }
            }

            // if both factors go away from target, you can cancel
            if (!compareSmallFactor && !compareLargeFactor) {
                break;
            }
        }
    }
    return result;
}