Question

有人能告诉我找到从未排序数组求和的最大整数的最佳方法吗？

e.g。

{0.1, 0.2, 0.9, 0.5}

Largest whole number possible is 1 (0.1 + 0.9).

{0.9, 0.2, 0.5, 0.3, 0.9}

Largest possible is 2 (0.9 + 0.9 + 0.2)

感谢

更新

我已经接受了我使用的方法，但下面的一些方法将是编程正确的

Answer 1

我建议总结整个数组，然后找到小数部分等于整数的最小和。除非数字在小数点后具有非常高的精度，否则无论找到确切数字的方法是什么，这种反转都应该节省大量的计算。

此外，对数组进行排序并从最小的数字中贪婪可能会产生不错的结果。但是，最佳解决方案非常依赖于初始集的性质。您能否就您期望的数字类型提供更详细的规格？

Answer 2

此代码的大部分内容用于获取数组的排列。我确信它可以进行优化，但这是在四核单Xeon服务器上计算3个长度为4,5和6的阵列，在45ms内。当我添加一个带有7位小数的第4个数组时，跳转到大约220ms，如果我用8添加第5个数组，则跳到2秒。

基本上，所有这一切都是获取包含浮点数的数组的所有排列，按键将每一个加在一起，如果和是一个大于当前整数的整数，则更新该数字。最终返回尽可能多的数字。

$set1 = array(0.1, 0.2, 0.9, 0.5);
$set2 = array(0.9, 0.2, 0.5, 0.3, 0.9);
$set3 = array(0.9, 0.2, 0.5, 0.3, 0.9, 0.4);

function largestWholeNumber($decimals){
    echo "Calculating largest whole number for decimal set '"
    . implode(",", $decimals)
    . "'<br />";
    $perms = perms($decimals);
    $answer = 0;
    foreach($perms as $dec_array){
        $current_guess = 0;
        foreach($dec_array as $dec){
            $current_guess += $dec;
            if (!preg_match("/[^0-9]+/", $current_guess)){
                if ($answer < $current_guess){
                    $answer = $current_guess;
                    echo "New whole number found " 
                    ."'$answer'"
                    ." with permutation: <br />";
                    print_r($dec_array);
                    echo "<br />";
                }
            }
        }
    }
    echo "Result: $answer<br /><br />";
    return $answer;
}

function factorial($int){
if($int < 2) {
       return 1;
}

for($f = 2; $int-1 > 1; $f *= $int--);

return $f;
}


function perms($arr) {
    $p = array();
    for ($i=0; $i < factorial(count($arr)); $i++) {
        $p[] = perm($arr, $i);
    }
    return $p;
}


function perm($arr, $nth = null) {

    if ($nth === null) {
        return perms($arr);
    }

    $result = array();
    $length = count($arr);

    while ($length--) {
        $f = factorial($length);
        $p = floor($nth / $f);
        $result[] = $arr[$p];
        array_delete_by_key($arr, $p);
        $nth -= $p * $f;
    }

    $result = array_merge($result,$arr);
    return $result;
}
function array_delete_by_key(&$array, $delete_key, $use_old_keys = FALSE) {

    unset($array[$delete_key]);

    if(!$use_old_keys) {
        $array = array_values($array);
    }

    return TRUE;
}

largestWholeNumber($set1); // 1
largestWholeNumber($set2); // 2
largestWholeNumber($set3); // 3

归功于数组置换函数转到dirk dot avery a t gmail的{{1}}

Answer 3

这样的事情？

 $array=array(0.1, 0.2, 0.9, 0.5);
 arsort($array);
 while($highest=array_shift($array)){
   foreach($array as $val){
    $thisval=($highest+val);
    if(round($thisval)==($thisval)){
     return $thisval;
   }
 }
}

编辑：@Felix Kling你是绝对正确的，添加了一个循环

Answer 4

我没有为此编写代码，但psuedo代码如下。一般的想法是你计算组合（x选择y ... http://en.wikipedia.org/wiki/Combination）然后对这些组合中的每一个求和。你迭代这个数组的长度，然后采取你的最大。

我也确信有关于贪婪和短路此循环的优化。

$len = count($decimals);
$maxVals = array();

for( $choose = $len; $choose > 1; $choose-- ) {
    // get $decimals choose $choose

    // loop and sum each choose array, checking for an integer sum

    // store max if exists
}

return sum($maxVals);

Answer 5

好好想一想。

$sum = array_sum($arr);
$floor_sum = floor($sum);
if ($sum = $floor_sum){
return $sum
}else{

for ($i = 0; $i < sizeof($arr); $i++){
  if ($sum - $arr[$i] = $floor_sum){
     return $sum - $arr[i];
  }else{
    for ($x = 0; $x < sizeof($arr)- 1; $x++){
      if ($x != $i){
        if ($sum - $arr[$i] - $arr[$x] = $floor_sum){
         return $sum - $arr[$i] - $arr[$x];
        }else {
            //Iterate more times
        }
      }
    }
  }
}

}

我有上述但必须有一个更简单的方法吗？

Answer 6

这是一个值得思考的问题。在我的头顶，这是我使用的伪代码：

A =元素数组。
A'=已排序的元素数组。
S =所有元素的总和。
虽然A'不为空：
1. V = S的整数部分。
2. R = S = S - floor（S）的剩余部分
3. 制作A'，X。
4. 从X的最大值到最小值迭代为X [i]：
  1. 如果X [i]＆lt; R，从R中减去X [i]。从X中删除X [i]。
  2. 如果R == 0，我们找到了解决方案。 V是整数，X包含加数。 STOP。
5. 如果X为空，则没有解决方案。 STOP。
6. 将A减去A'中的最大值。 S = S - Max（A'）。从A'中删除Max（A'）。
回到第4步。

当然，我必须看看这是否真的有效。这是我编写的用于测试它的（非常混乱，丢失的质量）代码：

<?php
$AA = $A = array(0.1, 0.2, 0.9, 0.5);

bcscale(8);

sort($AA, SORT_NUMERIC);
echo 'A = ' . implode(', ', $A), PHP_EOL;
echo 'A\' = ' . implode(', ', $AA), PHP_EOL;

$S = array_sum($AA);
echo 'S = ' . $S, PHP_EOL;

while (count($AA)) {
    $V = floor($S);
    echo 'V = ' . $V, PHP_EOL;

    $R = bcsub($S, $V);
    echo 'R = ' . $R, PHP_EOL;

    $X = $AA;
    $XX = array();

    // Look for the largest value that is less than or equal to R.
    for ($i = count($X) - 1; $i >= 0; $i--) {
        echo 'X[i] = ' . $X[$i] . ', R = ' . $R, PHP_EOL;
        $c = bccomp($X[$i], $R);
        if ($c > 0) {
            continue;
        }
        $XX[] = $X[$i];
        $R = bcsub($R, $X[$i]);
        unset($X[$i]);

        if (bccomp($R, '0', strlen($R)) == 0) {
            echo 'Largest whole number sum: ' . $V, PHP_EOL;  
            echo 'Elements: ' . implode(', ', $X), PHP_EOL;   
            break 2;
        }
    }

    if (count($X) == 0) {
        echo 'No sums to a whole number are possible.', PHP_EOL;
        break;
    }

    $t = array_pop($AA);
    $S = bcsub($S, $t);
}

echo 'S = ' . $S, PHP_EOL;
?>

这是一个丑陋的O（N ^ 2）算法，但它应该是正确的。任何人都可以看到一个初始启动数组，这会失败吗？

为了好玩，我尝试了50个元素的数组，用这些行替换第一行：

$A = array();
for ($i = 0; $i < 50; $i++) {
    $A[] = mt_rand(1, 99) / 100.0;
}
$AA = $A;

一目了然，它看起来是正确的 - 我会将验证交给其他人;）

PHP中最大的整数来自未排序数组的总和

6 个答案: