Question

如果数字 K 是两个不同数字（A，B）的乘积，请找出最大数字（＆lt; = A＆amp;＆lt; = B）划分 K 。

例如：K = 54（6 * 9）。这两个数字都是可用的，即6和9。

我的方法相当简单或微不足道。

取两者中的最小者（在这种情况下为6）。让我们说 A
将数字平方并除以K，如果它是一个完美的除法，那就是数字。
否则A = A-1，直到A = 1.

对于给定的例子，3 * 3 = 9除以K，因此3是答案。

寻找更好的算法，而不是简单的解决方案。

注意：测试用例在1000年左右，因此需要采用最佳方法。

Answer 1

我相信其他人会想出一个涉及模数运算的好答案。这是一种天真的方法......

每个因素本身都可以被考虑（尽管这可能是一项昂贵的操作）。

考虑到这些因素，您可以查找重复因子组。

例如，使用您的示例：

9：3的主要因素

素数因子为6：2,3

所有主要因素：2,3,3,3

有两个3，所以你有答案（3分的平方54）。

36 x 9 = 324

的第二个例子

理论因子为36：2,2,3,3

9：3的主要因素

所有主要因素：2,2,3,3,3,3

所以你有两个2和4个3，这意味着重复2x3x3。 2x3x3 = 18，因此18的平方除以324.

编辑：python原型

import math

def factors(num, dict):
    """ This finds the factors of a number recursively.
        It is not the most efficient algorithm, and I 
        have not tested it a lot.  You should probably
        use another one. dict is a dictionary which looks
        like {factor: occurrences, factor: occurrences, ...}
        It must contain at least {2: 0} but need not have 
        any other pre-populated elements.  Factors will be added
        to this dictionary as they are found.
    """

    while (num % 2 == 0):
        num /= 2
        dict[2] += 1
    i = 3
    found = False
    while (not found and (i <= int(math.sqrt(num)))):
        if (num % i == 0):
            found = True
            factors(i, dict)
            factors(num / i, dict)
        else:
            i += 2
    if (not found):
        if (num in dict.keys()):
            dict[num] += 1
        else:
            dict[num] = 1
    return 0


#MAIN ROUTINE IS HERE

n1 = 37 # first number (6 in your example)
n2 = 41 # second number (9 in your example)
dict = {2: 0} # initialise factors (start with "no factors of 2")
factors(n1, dict) # find the factors of f1 and add them to the list
factors(n2, dict) # find the factors of f2 and add them to the list
sqfac = 1
# now find all factors repeated twice and multiply them together
for k in dict.keys():
    dict[k] /= 2
    sqfac *= k ** dict[k]
# here is the result
print(sqfac)

Answer 2

C ++答案

int func(int i, j)
{ 
    int k = 54
    float result = pow(i, 2)/k
    if (static_cast<int>(result)) == result) 
    {
        if(i < j)
        {
            func(j, i);
        }
        else
        {
            cout << "Number is correct: " << i << endl;
        }
    }
    else
    {
        cout << "Number is wrong" << endl;
        func(j, i)

    }
 }

说明：

第一次递归然后测试结果是否为正整数，如果是，那么如果更大的递归函数尝试另一个倍数则检查另一个倍数是否更小或更大，如果不是则那么它是正确的。然后，如果结果不是正整数，那么print Number是错误的并且执行另一个递归函数来测试j。

Answer 3

如果我正确地解决了问题，我发现你有一个长度= A，宽度= B，面积= K的矩形并且您希望将其转换为正方形并失去最小可能区域

如果是这种情况。因此，算法的问题不是迭代迭代迭代直到获得输出的成本。相反，问题是您的算法在很大程度上取决于输入矩形的长度A和宽度B. 虽然它应该只取决于区域K

例如：

假设A = 1，B = 25
然后K = 25（直肠区域）
您的算法将采用最小值，即A，并将其作为单个答案接受迭代这么快但导致错误，因为它会导致1区的正方形并浪费剩余的24（无论cm 或者m）
虽然这里的正确答案应该是5.算法永远不会达到

所以，在我的解决方案中，我假设一个输入K

我的想法如下

x = sqrt（K）
if（x is int）.. x是答案
else从x-1循环到1，x -
如果K / x ^ 2为int，则x为答案

这可能需要额外的迭代，但可以保证准确的答案此外，对sqrt（K）的成本可能存在一些顾虑但它只会调用一次，以避免误导长度和宽度输入

更好的算法找到方形除法的最大数量K：

3 个答案: