in reply to Re: Finding Sum of Consecutive Numerical Difference in Set of Numbers
in thread Finding Sum of Consecutive Numerical Difference in Set of Numbers

I wonder too. I can get -4, -14, or -2, but not -10. 

@num = (2, 4, 5, 7); 
use List::Util "reduce"; 
$lsub = reduce { $a - $b } @num; 
$asum = reduce { $b - $a } reverse @num; 
$coeff = do { my @y = @num; while (1 < @y) { $y[$_] -= $y[$_ + 1] for 
+0 .. @y - 2; splice @y, -1; } $y[0] }; 
print "lisp difference: $lsub\nalternating sum: $asum\nhighest coeff: 
+$coeff\n";

[download]
===> 
lisp difference: -14
alternating sum: -4
highest coeff: -2

[download]

Replies are listed 'Best First'.
Re^3: Finding Sum of Consecutive Numerical Difference in Set of Numbers
by sauoq (Abbot) on Oct 29, 2005 at 10:47 UTC

    Here's a -10... 

    sub get_neg_10_outta_these {
    my $n = shift;
    my $sum; 
    $sum += $n - $_  for (@_);
    return $sum; 
}

my @nums = (2, 4, 5, 7); 
print get_neg_10_outta_these(@nums),"\n";

    [download]
    -sauoq
"My two cents aren't worth a dime.";
[reply]
[d/l]

      I have a dusty ruby script somewhere to solve problems like this... yes, here's it. 

      
def mask \
        s, m;
        (0 ... s.size).find_all {|k| 0 != m[k] }.map {|k| s[k] }
end;


def poss2 \
        v1, v2, s1, s2;
        yield v1 + v2, "(" + s1 + " + " + s2 + ")";
        yield v1 - v2, "(" + s1 + " - " + s2 + ")";
        yield v1 * v2, "(" + s1 + " * " + s2 + ")";
        1e-8 < v2.abs and
                yield Float(v1) / v2, "(" + s1 + " / " + s2 + ")";
        s1 =~ /^\d+$/ && s2 =~ /^\d$/ and
                yield v1 + 10*v2, s1 + s2;
end;


def poss \
        v, s;
        if 1 == v.size;
                yield v.first, s.first;
        else
                (1 ... (1<<v.size) - 1).each{|m|
                        vv2 = []; ss2 = [];
                        poss(mask(v, ~m), mask(s, ~m)) {
                                |v2, s2|
                                vv2.push v2;
                                ss2.push s2;
                        };
                        poss(mask(v, m), mask(s, m)) {
                                |v1, s1|
                                (0 ... vv2.size).each {|k|
                                        poss2(v1, vv2[k], s1, ss2[k]) 
+{
                                                |v3, s3|
                                                yield v3, s3;
                                        };
                                };
                        };
                };
        end;
end;


#

def main;
        poss(NUMS, NUMS.map{|x| x.to_s}) {
                |r, s|
                (r - TARGET).abs < 1e-6 and
                        print r, " = ", s, "\n";
        };
end;


#NUMS = [1, 3, 4, 6];
#TARGET = 24;
NUMS = [2, 4, 5, 7];
TARGET = -10;
main;


__END__

      [download]

      Update: output is 

      -10 = (4 - (2 + (5 + 7)))
-10 = (4 - (2 + (7 + 5)))
-10 = (4 - (5 + (2 + 7)))
-10 = (4 - (5 + (7 + 2)))
-10 = (4 - ((2 + 5) + 7))
-10 = (4 - ((5 + 2) + 7))
-10 = (4 - (7 + (2 + 5)))
-10 = (4 - (7 + (5 + 2)))
-10 = (4 - ((2 + 7) + 5))
-10 = (4 - ((7 + 2) + 5))
-10 = (4 - ((5 + 7) + 2))
-10 = (4 - ((7 + 5) + 2))
-10 = ((4 - 2) - (5 + 7))
-10 = ((4 - 2) - (7 + 5))
-10.0 = ((4 / 2) - (5 + 7))
-10.0 = ((4 / 2) - (7 + 5))
-10 = (5 - ((2 * 4) + 7))
-10 = (5 - ((4 * 2) + 7))
-10 = (5 - (7 + (2 * 4)))
-10 = (5 - (7 + (4 * 2)))
-10.0 = (5 / ((7 / 2) - 4))
-10 = ((4 - 5) - (2 + 7))
-10 = ((4 - 5) - (7 + 2))
-10 = ((4 - (2 + 5)) - 7)
-10 = ((4 - (5 + 2)) - 7)
-10 = (((4 - 2) - 5) - 7)
-10.0 = (((4 / 2) - 5) - 7)
-10 = ((5 - (2 * 4)) - 7)
-10 = ((5 - (4 * 2)) - 7)
-10 = (((4 - 5) - 2) - 7)
-10 = ((4 - 7) - (2 + 5))
-10 = ((4 - 7) - (5 + 2))
-10 = ((4 - (2 + 7)) - 5)
-10 = ((4 - (7 + 2)) - 5)
-10 = (((4 - 2) - 7) - 5)
-10.0 = (((4 / 2) - 7) - 5)
-10 = (((4 - 7) - 2) - 5)
-10 = ((5 - 7) - (2 * 4))
-10 = ((5 - 7) - (4 * 2))
-10 = ((4 - (5 + 7)) - 2)
-10 = ((4 * (5 - 7)) - 2)
-10 = ((4 - (7 + 5)) - 2)
-10 = (((4 - 5) - 7) - 2)
-10 = (((4 - 7) - 5) - 2)
-10 = (((5 - 7) * 4) - 2)

      [download]
[reply]
[d/l]
[select]

In Section Seekers of Perl Wisdom