Challenge 339 Task 1 and 2 solutions in Perl by Matthias Muth

5 files changed, 377 insertions, 217 deletions

diff --git a/challenge-339/matthias-muth/README.md b/challenge-339/matthias-muth/README.md
index b9ffca8c78..077f7b2d21 100644
--- a/challenge-339/matthias-muth/README.md
+++ b/challenge-339/matthias-muth/README.md
@@ -1,293 +1,212 @@
-# Higher and Higher
+# Max Complication for Min Brute Force
 
-**Challenge 338 solutions in Perl by Matthias Muth**
+# --- DRAFT Work in Progress ---
 
-## Task 1: Highest Row
+**Challenge 339 solutions in Perl by Matthias Muth**
 
-> You are given a m x n matrix.<br/>
-> Write a script to find the highest row sum in the given matrix.
+## Task 1: Max Diff
+
+> You are given an array of integers having four or more elements.<br/>
+> Write a script to find two pairs of numbers from this list (four numbers total) so that the difference between their products is as large as possible.<br/>
+> In the end return the max difference.<br/>
+> With Two pairs (a, b) and (c, d), the product difference is (a * b) - (c * d).
 >
 > **Example 1**
 >
 > ```text
-> Input: @matrix = ([4,  4, 4, 4],
->                   [10, 0, 0, 0],
->                   [2,  2, 2, 9])
-> Output: 16
+> Input: @ints = (5, 9, 3, 4, 6)
+> Output: 42
 >
-> Row 1: 4  + 4 + 4 + 4 => 16
-> Row 2: 10 + 0 + 0 + 0 => 10
-> Row 3: 2  + 2 + 2 + 9 => 15
+> Pair 1: (9, 6)
+> Pair 2: (3, 4)
+> Product Diff: (9 * 6) - (3 * 4) => 54 - 12 => 42
 > ```
 >
 > **Example 2**
 >
 > ```text
-> Input: @matrix = ([1, 5],
->                   [7, 3],
->                   [3, 5])
+> Input: @ints = (1, -2, 3, -4)
 > Output: 10
+>
+> Pair 1: (1, -2)
+> Pair 2: (3, -4)
 > ```
 >
 > **Example 3**
 >
 > ```text
-> Input: @matrix = ([1, 2, 3],
->                   [3, 2, 1])
-> Output: 6
+> Input: @ints = (-3, -1, -2, -4)
+> Output: 10
+>
+> Pair 1: (-1, -2)
+> Pair 2: (-3, -4)
 > ```
 >
 > **Example 4**
 >
 > ```text
-> Input: @matrix = ([2, 8, 7],
->                   [7, 1, 3],
->                   [1, 9, 5])
-> Output: 17
+> Input: @ints = (10, 2, 0, 5, 1)
+> Output: 50
+>
+> Pair 1: (10, 5)
+> Pair 2: (0, 1)
 > ```
 >
 > **Example 5**
 >
 > ```text
-> Input: @matrix = ([10, 20,  30],
->                   [5,  5,   5],
->                   [0,  100, 0],
->                   [25, 25,  25])
-> Output: 100
+> Input: @ints = (7, 8, 9, 10, 10)
+> Output: 44
+>
+> Pair 1: (10, 10)
+> Pair 2: (7, 8)
 > ```
 
-Nothing spectacular about this solution.
+As usual, I try not to use brute force to solve the task. I will *not* do 'combinations', and *not* go through $\binom{n}{4} = \frac{n!}{4!(n-4)!}$ iterations to choose the right numbers.
 
-For every the row of the matrix, compute the `sum` of the elements in that row.
-Using `map` for this,
-because I find it so much more expressive and concise than a `for` loop.
+Instead, I do will do an analysis to learn which numbers to choose.
 
-As another benefit of `map`,
-we can also feed the resulting set of row sums
-directly into `max` as parameters,
-which directly gives us our return value.  
+My first observation is that for getting the largest difference, the first product has to be as big as possible, and the subtracted number has to be as low as possible. So we can change the task to
 
-So why not use a one-liner if we can?
+> 'Find two pairs that result in the highest possible product and the lowest possible product, respectively.'
 
-```perl
-use v5.36;
-use List::Util qw( sum max );
+Next observation:<br/>
+The largest product can be obtained by multiplying the two largest numbers.<br/>
+This should be an obvious one. But there is a huge BUT:
+
+If we have at least two *negative* numbers in our list, and remembering that 'minus times minus equals plus', we might find that the largest (positive) product is obtained by multiplying the two *lowest* numbers (those with the largest absolute amounts).<br/>
+So we have to consider the products of both the two highest positive numbers and the two lowest negative ones, and use the 'better' one.
+
+Thus, the candidates for **the first product** are these:
+
+* the highest two positive numbers,
+* the lowest two negative numbers (resulting in a positive product).
+
+We need to compare which one is better. If we cannot compute one or the other, we will simply use only the other one.
 
-sub highest_row( $matrix ) {
-    return max( map sum( $_->@* ), $matrix->@* );
+In any case, it will be good to separate the positive and the negative numbers into separate arrays, and have them sorted numerically, so that we can access the highest or lowest positive or negative numbers just by indexing into these arrays.
+
+For the number to subtract, we need to find the *lowest* product possible. But this is different, because now we can be lucky and get a negative product, because negative numbers are 'low'.
+
+So if we have negative numbers at all, we will be happy to use the lowest one available ((that was not used for the first product!), together with the highest positive number available, to get a negative product as far in the negative as possible.
+
+So the candidates for **the second product** are these:
+
+* if we have positive and negative numbers:<br/>
+  the lowest negative number times the highest positive number,<br/>
+  because this results in a number as far in the negative (or as 'low') as possible,
+* if we have no negative numbers:<br/>
+  the product of the lowest two positive numbers, 
+* if we have no positive numbers:<br/>
+  the two negative numbers closest to zero (or zero itself, if we have one). 
+
+There are cases where the choice for the first product reduce the possible choices for the second product in a way that makes the combination of both not the best choice overall. Especially when there are only few numbers, and the choice of one product reduces the availability of numbers to choose from for the second one.
+
+To be sure, my strategy is to try both:
+
+* The two possible candidates for the best first product, as described above,<br/>combined with the second product chosen from what is left, for each of the candidates separately,
+* the best *second* product chosen from all numbers,<br/>combined with the two possible candidates for the best *first* product from what is left.<br/>Actually we need to consider a third candidate for the first product in this case: If we used a positive and a negative number for the second product, it could be that all we have left is only a 'mixed pair' to use for the first product, something that we didn't need to consider in the cases described above for the first product.
+
+
+
+```perl
+sub max_diff() {
+    ...;
 }
 ```
 
-## Task 2: Max Distance
+## Task 2: Peak Point
 
-> You are given two integer arrays, @arr1 and @arr2.<br/>
-> Write a script to find the maximum difference between any pair of values from both arrays.
+> You are given an array of altitude gain.<br/>
+> Write a script to find the peak point gained.
 >
 > **Example 1**
 >
 > ```text
-> Input: @arr1 = (4, 5, 7)
->        @arr2 = (9, 1, 3, 4)
-> Output: 6
->
-> With element $arr1[0] = 4
-> | 4 - 9 | = 5
-> | 4 - 1 | = 3
-> | 4 - 3 | = 1
-> | 4 - 4 | = 0
-> max distance = 5
->
-> With element $arr1[1] = 5
-> | 5 - 9 | = 4
-> | 5 - 1 | = 4
-> | 5 - 3 | = 2
-> | 5 - 4 | = 1
-> max distance = 4
->
-> With element $arr1[2] = 7
-> | 7 - 9 | = 2
-> | 7 - 1 | = 6
-> | 7 - 3 | = 4
-> | 7 - 4 | = 4
-> max distance = 6
->
-> max (5, 6, 6) = 6
+> Input: @gain = (-5, 1, 5, -9, 2)
+> Output: 1
+> 
+> start: 0
+> 1st change:  0 + (-5) = -5
+> 2nd change: -5 + 1    = -4
+> 3rd change: -4 + 5    = 1
+> 4th change:  1 + (-9) = -8
+> 5th change: -8 + 2    = -6
+> 
+> max(0, -5, -4, 1, -8, -6) = 1
 > ```
 >
 > **Example 2**
 >
 > ```text
-> Input: @arr1 = (2, 3, 5, 4)
->        @arr2 = (3, 2, 5, 5, 8, 7)
-> Output: 6
->
-> With element $arr1[0] = 2
-> | 2 - 3 | = 1
-> | 2 - 2 | = 0
-> | 2 - 5 | = 3
-> | 2 - 5 | = 3
-> | 2 - 8 | = 6
-> | 2 - 7 | = 5
-> max distance = 6
->
-> With element $arr1[1] = 3
-> | 3 - 3 | = 0
-> | 3 - 2 | = 1
-> | 3 - 5 | = 2
-> | 3 - 5 | = 2
-> | 3 - 8 | = 5
-> | 3 - 7 | = 4
-> max distance = 5
->
-> With element $arr1[2] = 5
-> | 5 - 3 | = 2
-> | 5 - 2 | = 3
-> | 5 - 5 | = 0
-> | 5 - 5 | = 0
-> | 5 - 8 | = 3
-> | 5 - 7 | = 2
-> max distance = 3
->
-> With element $arr1[3] = 4
-> | 4 - 3 | = 1
-> | 4 - 2 | = 2
-> | 4 - 5 | = 1
-> | 4 - 5 | = 1
-> | 4 - 8 | = 4
-> | 4 - 7 | = 3
-> max distance = 4
->
-> max (5, 6, 3, 4) = 6
+> Input: @gain = (10, 10, 10, -25)
+> Output: 30
+> 
+> start: 0
+> 1st change:  0 + 10    = 10
+> 2nd change: 10 + 10    = 20
+> 3rd change: 20 + 10    = 30
+> 4th change: 30 + (-25) = 5
+> 
+> max(0, 10, 20, 30, 5) = 30
 > ```
 >
 > **Example 3**
 >
 > ```text
-> Input: @arr1 = (2, 1, 11, 3)
->        @arr2 = (2, 5, 10, 2)
-> Output: 9
->
-> With element $arr1[0] = 2
-> | 2 - 2  | = 0
-> | 2 - 5  | = 3
-> | 2 - 10 | = 8
-> | 2 - 2  | = 0
-> max distance = 8
->
-> With element $arr1[1] = 1
-> | 1 - 2  | = 1
-> | 1 - 5  | = 4
-> | 1 - 10 | = 9
-> | 1 - 2  | = 1
-> max distance = 9
->
-> With element $arr1[2] = 11
-> | 11 - 2  | = 9
-> | 11 - 5  | = 6
-> | 11 - 10 | = 1
-> | 11 - 2  | = 9
-> max distance = 9
->
-> With element $arr1[3] = 3
-> | 3 - 2  | = 1
-> | 3 - 5  | = 2
-> | 3 - 10 | = 7
-> | 3 - 2  | = 1
-> max distance = 7
->
-> max (8, 9, 9, 7) = 9
+> Input: @gain = (3, -4, 2, 5, -6, 1)
+> Output: 6
+> 
+> start: 0
+> 1st change:  0 + 3    = 3
+> 2nd change:  3 + (-4) = -1
+> 3rd change: -1 + 2    = 1
+> 4th change:  1 + 5    = 6
+> 5th change:  6 + (-6) = 0
+> 6th change:  0 + 1    = 1
+> 
+> max(0, 3, -1, 1, 6, 0, 1) = 6
 > ```
 >
 > **Example 4**
 >
 > ```text
-> Input: @arr1 = (1, 2, 3)
->        @arr2 = (3, 2, 1)
-> Output: 2
->
-> With element $arr1[0] = 1
-> | 1 - 3 | = 2
-> | 1 - 2 | = 1
-> | 1 - 1 | = 0
-> max distance = 2
->
-> With element $arr1[1] = 2
-> | 2 - 3 | = 1
-> | 2 - 2 | = 0
-> | 2 - 1 | = 1
-> max distance = 1
->
-> With element $arr1[2] = 3
-> | 3 - 3 | = 0
-> | 3 - 2 | = 1
-> | 3 - 1 | = 2
-> max distance = 2
->
-> max (2, 1, 2) = 2
+> Input: @gain = (-1, -2, -3, -4)
+> Output: 0
+> 
+> start: 0
+> 1st change:  0 + (-1) = -1
+> 2nd change: -1 + (-2) = -3
+> 3rd change: -3 + (-3) = -6
+> 4th change: -6 + (-4) = -10
+> 
+> max(0, -1, -3, -6, -10) = 0
 > ```
 >
 > **Example 5**
 >
 > ```text
-> Input: @arr1 = (1, 0, 2, 3)
->        @arr2 = (5, 0)
-> Output: 5
->
-> With element $arr1[0] = 1
-> | 1 - 5 | = 4
-> | 1 - 0 | = 1
-> max distance = 4
->
-> With element $arr1[1] = 0
-> | 0 - 5 | = 5
-> | 0 - 0 | = 0
-> max distance = 5
->
-> With element $arr1[2] = 2
-> | 2 - 5 | = 3
-> | 2 - 0 | = 2
-> max distance = 3
->
-> With element $arr1[3] = 3
-> | 3 - 5 | = 2
-> | 3 - 0 | = 3
-> max distance = 3
->
-> max (4, 5, 3, 3) = 5
+> Input: @gain = (-10, 15, 5)
+> Output: 10
+> 
+> start: 0
+> 1st change:   0 + (-10) = -10
+> 2nd change: -10 + 15    = 5
+> 3rd change:   5 + 5     = 10
+> 
+> max(0, -10, 5, 10) = 10
 > ```
 
-A lot of explicit examples for a simple task.
-But the more examples the better, because the more *tests* the better.
-
-A short reflection tells us that the maximum distance between any two numbers
-in the arrays can only be between the lowest number of the first array
-and the highest one of the second, or vice versa.
 
-So the easiest way to solve this is not to try each and every combination of numbers
-of the two arrays,
-but to first extract the lowest and highest number of each array,
-and then return the larger difference.
 
-There is a function called `minmax`
-that returns the minimum *and* the maximum of the parameter list
-at the same time (available from `List::SomeUtils` on CPAN).<br/>
-`minmax` can optimize the performance a bit,
-because instead of running through each arrays two times,
-using $2\cdot(n-1) = 2n -2$ comparisons,
-we only need $\frac{3}{2}n - 2$ comparisons.
 
-Whether that's worth it or not,
-I think it also makes the code a bit more readable:
 
 ```perl
 use v5.36;
-use List::SomeUtils qw( minmax );
-use List::Util qw( max );
+use List::Util qw( reductions max );
 
-sub max_distance( $arr1, $arr2 ) {
-    my ( $arr1_min, $arr1_max ) = minmax $arr1->@*;
-    my ( $arr2_min, $arr2_max ) = minmax $arr2->@*;
-    return max( $arr2_max - $arr1_min, $arr1_max - $arr2_min );
+sub peak_point( @gain ) {
+    return max( reductions { $a + $b } 0, @gain );
 }
 ```
 
diff --git a/challenge-339/matthias-muth/blog.txt b/challenge-339/matthias-muth/blog.txt
new file mode 100644
index 0000000000..eab9198997
--- /dev/null
+++ b/challenge-339/matthias-muth/blog.txt
@@ -0,0 +1 @@
+https://github.com/MatthiasMuth/perlweeklychallenge-club/tree/muthm-339/challenge-339/matthias-muth#readme
diff --git a/challenge-339/matthias-muth/perl/ch-1.pl b/challenge-339/matthias-muth/perl/ch-1.pl
new file mode 100755
index 0000000000..0f94b1e290
--- /dev/null
+++ b/challenge-339/matthias-muth/perl/ch-1.pl
@@ -0,0 +1,139 @@
+#!/usr/bin/env perl
+#
+#       The Weekly Challenge - Perl & Raku
+#       (https://theweeklychallenge.org)
+#
+#       Challenge 339 Task 1: Max Diff
+#
+#       Perl solution by Matthias Muth.
+#
+
+use v5.36;
+use builtin qw( true false );
+
+use List::Util qw( product max first );
+
+sub max_diff( @ints ) {
+    my @positives = sort { $b <=> $a } grep $_ >= 0, @ints;
+    my @negatives = sort { $b <=> $a } grep $_ < 0, @ints;
+
+    my @cases;
+
+    # Try the highest two positive numbers as the first product,
+    # with the second product as small as possible after having used
+    # those two positive numbers:
+    if ( @positives >= 2 ) {
+        push @cases, [ "case 1",
+            [ @positives[0,1] ],
+            @negatives
+                ? @positives >= 3
+                    ? [ $positives[2], $negatives[-1] ]
+                    : [ @negatives[0,1] ]
+                : [ @positives[-2,-1] ]
+        ];
+    }
+
+    # Try the lowest two negative numbers as the first product:
+    # with the second product as small as possible after having used
+    # those two negative numbers:
+    if ( @negatives >= 2 ) {
+        push @cases, [ "case 2",
+            [ @negatives[-2,-1] ],
+            @negatives >= 3
+                ? @positives
+                    ? [ $positives[0], $negatives[-3] ]
+                    : [ @negatives[0,1] ]
+                : [ @positives[-2,-1] ]
+        ];
+    }
+
+    # Try the lowest *second* product first,
+    # with the three options for the first product after that.
+    if ( @negatives ) {
+        if ( @positives ) {
+            # We have negatives and positives.
+            # Use the best possible mixed pair for the second product.
+            # For the first product, we then have one less positive and
+            # one less negative available.
+            my $got_positive_first_product = false;
+            if ( @positives >= 3 ) {
+                push @cases, [ "case 3",
+                    [ @positives[1,2] ],
+                    [ $positives[0], $negatives[-1] ],
+                ];
+                $got_positive_first_product = true;
+            }
+            if ( @negatives >= 3 ) {
+                push @cases, [ "case 4",
+                    [ @negatives[-3,-2] ],
+                    [ $positives[0], $negatives[-1] ],
+                ];
+                $got_positive_first_product = true;
+            }
+            # In case we couldn't create either of the two cases above,
+            # we have to use a 'mixed pair' for the first product:
+            unless ( $got_positive_first_product ) {
+                push @cases, [ "case 5",
+                    [ $positives[1], $negatives[-2] ],
+                    [ $positives[0], $negatives[-1] ]
+                ];
+            }
+        }
+        else {
+            # Only negatives, no positives.
+            push @cases, [ "case 6",
+                [ @negatives[-2,-1] ],
+                [ @negatives[0,1] ]
+            ];
+        }
+    }
+    else {
+        # Only positives, no negatives.
+        push @cases, [ "case 7",
+            [ @positives[0,1] ],
+            [ @positives[-2,-1] ],
+        ];
+    }
+
+    my $maximum =
+        max( map product( $_->[1]->@* ) - product( $_->[2]->@* ), @cases );
+
+    return
+        wantarray
+        ? do {
+            # Additional output for tests, debugging and documenting
+            # (only if called in list context):
+            # The first two pairs of numbers from @cases that result in
+            # the maximum.
+            ( $maximum,
+                map $_->@[1,2],
+                    first { 
+                        product( $_->[1]->@* ) - product( $_->[2]->@* )
+                            == $maximum
+                    } @cases
+            )
+        }
+        : $maximum;
+}
+
+unless ( caller ) {
+
+    use Test2::V0 qw( -no_srand );
+
+    my @tests = (
+        [ "Example 1", [ 5, 9, 3, 4, 6 ], 42 ],
+        [ "Example 2", [ 1, -2, 3, -4 ], 10 ],
+        [ "Example 3", [ -3, -1, -2, -4 ], 10 ],
+        [ "Example 4", [ 10, 2, 0, 5, 1 ], 50 ],
+        [ "Example 5", [ 7, 8, 9, 10, 10 ], 44 ],
+    );
+
+    for ( @tests ) {
+        my ( $test_name, $input, $expected ) = $_->@*;
+        my $descr = "$test_name:"
+            . " max_diff( " . join( ", ", $input->@* ) . " ) == $expected";
+        is max_diff( $input->@* ), $expected, $descr;
+    }
+
+    done_testing;
+}
diff --git a/challenge-339/matthias-muth/perl/ch-2.pl b/challenge-339/matthias-muth/perl/ch-2.pl
new file mode 100755
index 0000000000..7592eabff5
--- /dev/null
+++ b/challenge-339/matthias-muth/perl/ch-2.pl
@@ -0,0 +1,32 @@
+#!/usr/bin/env perl
+#
+#       The Weekly Challenge - Perl & Raku
+#       (https://theweeklychallenge.org)
+#
+#       Challenge 339 Task 2: Peak Point
+#
+#       Perl solution by Matthias Muth.
+#
+
+use v5.36;
+
+use List::Util qw( reductions max );
+
+sub peak_point( @gain ) {
+    return max( reductions { $a + $b } 0, @gain );
+}
+
+use Test2::V0 qw( -no_srand );
+
+is peak_point( -5, 1, 5, -9, 2 ), 1,
+    'Example 1: peak_point( -5, 1, 5, -9, 2 ) == 1';
+is peak_point( 10, 10, 10, -25 ), 30,
+    'Example 2: peak_point( 10, 10, 10, -25 ) == 30';
+is peak_point( 3, -4, 2, 5, -6, 1 ), 6,
+    'Example 3: peak_point( 3, -4, 2, 5, -6, 1 ) == 6';
+is peak_point( -1, -2, -3, -4 ), 0,
+    'Example 4: peak_point( -1, -2, -3, -4 ) == 0';
+is peak_point( -10, 15, 5 ), 10,
+    'Example 5: peak_point( -10, 15, 5 ) == 10';
+
+done_testing;
diff --git a/challenge-339/matthias-muth/perl/t/ch-1.t b/challenge-339/matthias-muth/perl/t/ch-1.t
new file mode 100755
index 0000000000..e1c5b3d32e
--- /dev/null
+++ b/challenge-339/matthias-muth/perl/t/ch-1.t
@@ -0,0 +1,69 @@
+#!/usr/bin/env perl
+#
+#       The Weekly Challenge - Perl & Raku
+#       (https://theweeklychallenge.org)
+#
+#       Challenge 339 Task 1: Max Diff
+#
+#       test-ch-1.pl - test script for ch-1.pl.
+#
+
+use v5.36;
+use builtin qw( true false );
+
+use lib qw( . .. );
+require "./ch-1.pl";
+
+use Test2::V0 qw( -no_srand );
+
+my @tests = (
+    [ "Test 0", [ +5, +4, +3, +2 ], 14 ],
+    [ "Test 1", [ -5, +4, +3, +2 ], 26 ],
+    [ "Test 2", [ +5, -4, +3, +2 ], 26 ],
+    [ "Test 3", [ -5, -4, +3, +2 ], 14 ],
+    [ "Test 4", [ +5, +4, -3, +2 ], 26 ],
+    [ "Test 5", [ -5, +4, -3, +2 ], 14 ],
+    [ "Test 6", [ +5, -4, -3, +2 ], 14 ],
+    [ "Test 7", [ -5, -4, -3, +2 ], 26 ],
+    [ "Test 8", [ +5, +4, +3, -2 ], 26 ],
+    [ "Test 9", [ -5, +4, +3, -2 ], 14 ],
+    [ "Test 10", [ +5, -4, +3, -2 ], 14 ],
+    [ "Test 11", [ -5, -4, +3, -2 ], 26 ],
+    [ "Test 12", [ +5, +4, -3, -2 ], 14 ],
+    [ "Test 13", [ -5, +4, -3, -2 ], 26 ],
+    [ "Test 14", [ +5, -4, -3, -2 ], 26 ],
+    [ "Test 15", [ -5, -4, -3, -2 ], 14 ],
+
+    [ "Test 16 (201 numbers)", [ -100..+100 ], 19702 ],
+
+    [ "Example 1", [ 5, 9, 3, 4, 6 ], 42 ],
+    [ "Example 2", [ 1, -2, 3, -4 ], 10 ],
+    [ "Example 3", [ -3, -1, -2, -4 ], 10 ],
+    [ "Example 4", [ 10, 2, 0, 5, 1 ], 50 ],
+    [ "Example 5", [ 7, 8, 9, 10, 10 ], 44 ],
+);
+
+for ( @tests ) {
+    my ( $test_name, $input, $expected ) = $_->@*;
+    my $descr = "$test_name:"
+        . " max_diff( " . join( ", ", $input->@* ) . " ) == $expected";
+    my ( $maximum, $pair_1, $pair_2 ) = max_diff( $input->@* );
+    is $maximum, $expected, $descr
+        and $pair_1 && $pair_2 && do {
+            # Explain the correct solution.
+            my $product_1 = $pair_1->[0] * $pair_1->[1];
+            my $product_2 = $pair_2->[0] * $pair_2->[1];
+            my $result = $product_1 - $product_2;
+            note "            Pair 1: ( $pair_1->[0], $pair_1->[1] )";
+            note "            Pair 2: ( $pair_2->[0], $pair_2->[1] )";
+            note "            Product Diff: ",
+                "( $pair_1->[0] * $pair_1->[1] )",
+                    " - ( $pair_2->[0] * $pair_2->[1] )",
+                " => ( ", $product_1 >= 0 ? $product_1 : "($product_1)",
+                    " - ", $product_2 >= 0 ? $product_2 : "($product_2)", " )",
+                " => $result";
+            note "";
+        }
+}
+
+done_testing;