This week, I’m trying something different. I’m going to work on my solution to the task through this blog and then copy-and-paste my solution into a terminal window to see if it works. I’ll walk you through my process, think out loud, and maybe even hit the programming lottery and write something that works on the first try.

Probably not, but maybe…

Think of this as the blogging version of Twitch. Look over my shoulder as I figure things out…

“Missing Members”

You are given two arrays of integers.

Write a script to find out the missing members in each other arrays.

The example given:

Input: @arr1 = (1, 2, 3)
       @arr2 = (2, 4, 6)
Output: ([1, 3], [4, 6])

(1, 2, 3) has 2 members (1, 3) missing in the array (2, 4, 6).
(2, 4, 6) has 2 members (4, 6) missing in the array (1, 2, 3).

OK, that seems “easy” enough. Most things that I think are “easy” to program often have a horrible complication in the second half that I never see coming, though.

That would make for an interesting blog post, at least.

My first thought is that this is something that should just be brute forced. Loop through the arrays, do something with the data, compare the data, print out the solution.

I also think that it’s very likely there’s a module on CPAN that would make this program supremely simple to write. There’s probably a two line solution to this there somehow.

I also bet I could jump over to ChatGPT right now and get an answer. Maybe I’ll try that after my solution, for kicks. The point of this programming exercise, though, is to practice skills, not prompts.

Here’s my first idea:

my @arr1 = (1, 2, 3);
my @arr2 = (2, 4, 6);

my @missing_from_second;
my $match = 0;
foreach my $value_first( @arr1 ) {
  foreach my $value_second( @arr2 ) {
     $match++ if ($value_second == $value_first);
  }
  push(@missing_from_second, $value_first) if ($match == 0);
  $match = 0;
}

We do a nested loop to compare all the values. If there’s a match, we essentially set a flag(*). If there’s no match, that means the number is missing in the second array and we add it to the results array.

Is it elegant? Not really. Is it optimized? Heck, no. I already see one or two things I could do to speed it up. (Two ideas off the top of my head: Short circuiting as soon as a match is found. Sorting the arrays first and short-circuiting once the loop has passed by the number.)

This will only check the first case — how many values are in the first array that aren’t in the second?

It loops over the first array and flags any time a value from there is in the second array as it loops over it. If there is a match, that sets a flag which will cause the value NOT to be added to the list of missing values.

Does it work? I think it might. Let’s write a quick output to check:

print "Array 1 has " . scalar(@missing_from_second) . " members missing in Array 2\n";

Now I’ll do a quick copy-and-paste and check it in the terminal window and run it:

Array 1 has 2 members missing in Array 2

That is correct. 1 and 3 are in the first array, but not the second. My code just worked on the first try.

Thanks for reading my blog. I’m taking my Win and going home.

OK, nevermind, I’ll see this all the way through.

Printing Out The Solution, Wherein the Perl Weekly Newsletter Saves My Bacon

How could we print that final message in a prettier way? We need to print out an array, which means I’ll just use my pretty printer from previous challenges:

sub pretty_print_array {

        my @array = @_;
        my $length = scalar @array;
        my $count = 1;

        print "(";

        foreach my $value(@array) {
                print $value;
                print ", " if $count < $length;
                $count++;
        }

        print ")\n";

        return;
}

Let’s integrate that:

print pretty_print_array(@arr1) . " has " . scalar( @missing_from_second ) . " members " . pretty_print_array(@missing_from_second) . " missing in the array " . pretty_print_array(@arr2) . "\n";

I’ve used that pretty_print_array a lot in recent challenges, but never as much as in this one line. That gives us:

(1, 2, 3)
(1, 3)
(2, 4, 6)
 has 2 members  missing in the array 

That ain’t right.

However, I immediately recognize the problem, since it was fresh in my mind.

The reason for this wackiness was covered in a link from the Perl Weekly newsletter just last week. Check out this Reddit article discussing how the Perl print statement works. It explains everything in graphic detail.

So I made this ugly-looking thing, instead —

print pretty_print_array(@arr1);
print " has ";
print scalar( @missing_from_second ) . " members ";
print pretty_print_array(@missing_from_second);
print " missing in the array ";
print pretty_print_array(@arr2) , "\n";

— and it worked beautifully:

(1, 2, 3) has 2 members (1, 3) missing in the array (2, 4, 6)

I also had to remove the new line at the end of the pretty_print_array() function so everything would be together in a single line.

Again, Functionalize All the Things!

That solves the problem for the first example, but what about the second? How can I structure this code to easily run as many times as I want without having to copy and paste code?

It’s time to Function-ify the code! (I’m going to keep making up new verbs until I find one that I like…)

This is where we’re starting from, minus the pretty_print_array() function:

my @arr1 = (1, 2, 3);
my @arr2 = (2, 4, 6);

my @missing_from_second;
my $match = 0;
foreach my $value_first( @arr1 ) {
  foreach my $value_second( @arr2 ) {
     $match++ if ($value_second == $value_first);
  }
  push(@missing_from_second, $value_first) if ($match == 0);
  $match = 0;
}

print pretty_print_array(@arr1);
print " has ";
print scalar( @missing_from_second ) . " members ";
print pretty_print_array(@missing_from_second);
print " missing in the array ";
print pretty_print_array(@arr2) , "\n";

This should be simple enough. I’m going to make one big function out of the whole thing and then call it with the arrays as the parameters. I would normally separate the print part out at the end into its own statement, but then I’m passing along four different arrays. I don’t want to do that for a simple piece of code like this.

So let’s see the final code with calls from both examples:

my @arr1 = (1,2,3);
my @arr2 = (2,4,6);
find_missing_members( \@arr1, \@arr2 );

@arr1 = (1, 2, 3, 3);
@arr2 = (1, 1, 2, 2);
find_missing_members( \@arr1, \@arr2 );

sub find_missing_members {

  my @arr1 = @{ shift() };
  my @arr2 = @{ shift() };

  my @missing_from_second;
  my $match = 0;
  foreach my $value_first( @arr1 ) {
    foreach my $value_second( @arr2 ) {
      $match++ if ($value_second == $value_first);
    }
  push(@missing_from_second, $value_first) if ($match == 0);
  $match = 0;
  }

  print pretty_print_array(@arr1);
  print " has ";
  print scalar( @missing_from_second ) . " members ";
  print pretty_print_array(@missing_from_second); 
  print " missing in the array "; 
  print pretty_print_array(@arr2) , "\n";
}

Turning This Car Around

That works, BUT! I just realized that I haven’t done the comparison in reverse order. We know which members of @arr1 are missing in @arr2, but we don’t yet know which members of @arr2 are missing in @arr1!

I have to admit that I had a moment here where, in my head, I wondered about how I might functionalize the first half of find_missing_members() further to make a generic comparison and then send the arrays in different orders. Or what if I had to — gulp — copy and paste the nested loop to do it again in the other order?

That’s when dummy me realized the much simpler solution: Call the same function I already have, but reverse the order of the arrays I’m sending in:

my @arr1 = (1,2,3);
my @arr2 = (2,4,6);
find_missing_members( \@arr1, \@arr2 );
find_missing_members( \@arr2, \@arr1 );

@arr1 = (1, 2, 3, 3);
@arr2 = (1, 1, 2, 2);
find_missing_members( \@arr1, \@arr2 );
find_missing_members( \@arr2, \@arr1 );

That gives you the answer from the challenge write-up:

(1, 2, 3) has 2 members (1, 3) missing in the array (2, 4, 6)
(2, 4, 6) has 2 members (4, 6) missing in the array (1, 2, 3)
(1, 2, 3, 3) has 2 members (3, 3) missing in the array (1, 1, 2, 2)
(1, 1, 2, 2) has 0 members () missing in the array (1, 2, 3, 3)

Rewrite the Whole Thing? Optimize?

Like I said at the top, this is a brute force solution. Nested loops seem a little much. That means with two 3-value arrays, we go through the loop 9 times.

What if we only had to go through the loop once, and we set up a hash to carry the set of unique values in the second array? Even populating that hash by looping over one array once, we’ll cut down the number of loops from 9 to 3 + 3, or 6.

Like so:

  my @missing_from_second;
  my %second_values;
  map{ $second_values{$_} = 1; } @arr2;

  foreach my $first_value( @arr1 ) {
    push(@missing_from_second, $first_value) if !$second_values{$first_value};
  }

The one bit of trickiness we have here is that we’re hashing the second array, then looping over the first. That’s the correct order to do things. Then we loop over the first array and look for each value as a key in the hash of the second. This means only one comparison per iteration of the loop.

In the first set of input data, that changes the total iterations from 9 to 6. In the second set of data with 4-item arrays, we go from 16 down to 8.

If we had two 100 item arrays, this would cut us back from 10,000 iterations down to 200.

It doesn’t seem like a big difference with the smaller numbers, but the savings pile up quickly.

On the other hand, the nested loops thing feels easier to read. There’s less thinking to do when you’re reading it to understand what’s going on. So long as the arrays don’t grow ridiculously big, will those extra steps really be an issue? Computers are pretty fast these days. Am I being too clever?

On the other, other hand, I like the way I constructed this loop. I love how readable it actually is with the if after the push. (“Push the value onto the missing list if it doesn’t exist in the hash.”)

It would also work as a second map statement:

map{ $second_values{$_} = 1; } @arr2;
map{ push(@missing_from_second, $_) if !$second_values($_);  } @arr1;

Now it’s a one-liner loop that matches the map used to turn the other array into a hash.

Wait, if we’re talking functional programming and that whole second loop there is to filter out a list into an array, shouldn’t we just use grep{} ?!?

map{ $second_values{$_} = 1; } @arr2;

@missing_from_second = grep{
  !$second_values{$_};
} @arr1;

For some, I have no doubt we’re getting even less readable now. However, as a functional programmer wannabe, I love this solution. We ditch the push() command, an if statement, and the foreach() loop and replace it with a grep{} function.

Variable naming also counts here. With this grep we filter just to the values that don’t exist and put them in an array with “missing” in its name. That helps guide the mind in the right direction.

This is also where I get a little frustrated by Perl, because I know other languages have a built-in command to determine if a value is present in an array. Javascript has includes() as an Array method. Python has an “in” command that will work. Elixir has “Enum.member?” as well as an “in” thing of its own. Perl has grep(), but it feels weird to grep() inside a grep{}.

Also, under the hood, I’m sure those other languages are just going a similar thing. (**)

I’m 100% sure there’s a module on CPAN that will do this for me, but I try to stick to core Perl as much as possible. (Honestly, it’s easier at work to use everything built-in than having to fill out a form to get permission to use a new module from the legal and security teams…)

Ask ChatGPT

As promised near the top of this post, I ran the challenge through ChatGPT, which did a better job of printing out the answer and keeping everything in bite-sized chunks.

However, at the core of things, we were fairly close with our functional thinking:

my @missing_in_arr1 = grep { my $num = $_; !grep { $_ == $num } @$arr2 } @$arr1;
my @missing_in_arr2 = grep { my $num = $_; !grep { $_ == $num } @$arr1 } @$arr2;

I like my solution better. It doesn’t work as hard to fit everything into one line, which gives the answer room to breathe and be more easily understandable. It essentially does the same thing, but that’s a lot of stuff on each line in there.

Also, the ChatGPT solution checks in both directions inside the same function. I prefer having one function and calling it twice, just with different parameters.(***)

Annotations

(*) I just realized that back in college, we’d call these “sentinels.” I haven’t heard that term since. Everyone has called them “flags” ever since.

(**) I looked up the source code for Enum.is_member in Elixir. It’s a reduce function using some underlying Erlang code, of course:

{:error, module} ->
        module.reduce(enumerable, {:cont, false}, fn
          v, _ when v === element -> {:halt, true}
          _, _ -> {:cont, false}
        end)
        |> elem(1)

(***) I’m running out of time to publish this, so I’m not going to go look up the difference between parameters and arguments at the moment. Please forgive me if I got it backwards here. I’ll do better next time.

This was the perfect week to try to simplify my Perl code. I’ve said previously that I’m no Perl Golfer, but maybe this is the week to create a one-liner solution. In both challenges, the heart of the answer is, indeed, one line long.

But then I go and mess everything up by making the script run both samples from the challenge and pretty print everything out to the screen. Suddenly, a one-line script has three subroutines and 57 lines supporting the one that does the actual work.

Sorry, I just spoiled Challenge #2.

“Acronym”

You are given an array of strings and a check string.

Write a script to find out if the check string is the acronym of the words in the given array.

In other words, grab the first letter of each word, smash them together, and see if the resulting string is equal to the check string. In my mind, I see a substr() call and a join() and bob’s my uncle.

I added a ternary, a map{}. and a loc() to fill it all out.

Here’s the variable set-up and the single line of code you need to solve this one:

my @string = ("Perl", "Python", "Pascal");
my $chk = "ppp";

print $chk eq join('', map { lc( substr($_, 0, 1) ) } @string ) ? "True" : "False";

Yes, the pipe operator in Elixir would make this prettier. It’s slightly frustrating to read this from the inside out, but it’s not that hard. I’ve grown used to it from years of experience.

• Map over the string
• Grab the first letter of each word
• Convert it to lower case.
• Smash the letters into one big string.
• Compare that string to the check string and print out whether they’re the same.

I know it’s a bit controversial and you shouldn’t use it that much, but I love the $_ in Perl. Yes, it is dangerous and if you’re not careful you might get unexpected results. As with all programming, if you know what’s happening, the magic isn’t so magical. It’s only useful.

Only use the magic where appropriate and it’ll work for you, not against you.

If there were multiple lines inside the map{} function there, I’d turn $_ into a named variable with something that describes better what it is. For a one-liner like this, that’s not a problem.

If we exploded out that one-liner into a series of steps, it would look something like this:

my @firsts = map{ substr($_, 0, 1) } @string;

my $str_compare = join('', @firsts);

$str_compare = lc($str_compare);

if ($str_compare eq $chk) {
    print "True";
} else {
    print "False";
}

The important thing to note here is that Perl’s lowercase function will lowercase the entire word. You don’t need to pass each individual letter through the lc() function to get the desired results. Logically, though, I like the way it reads. I changed it for the exploded example, but kept the lc() call per-character in my main solution.

There’s not much more to it than that, so let’s go to the second challenge.

“Build Array”

I’ll be honest, I stared at this challenge for a long time before I understood it. Thank goodness for the examples given in the write-up:

You are given an array of integers.

Write a script to create an array such that new[i] = old[old[i]] where 0 <= i < new.length.

Basically, loop over the old array. The first position’s value will tell you the position in the old array whose value you want to put in the first position of the new array. Then, you walk straight down the line and fill out the rest of the array.

The simple solution is this:

@new = map{ $old[$_] } @old;

I built everything else up around that. I made a main() and re-used the pretty_print_array() from an earlier challenge, though I did need to modify it to accept an array and not a reference to an array. I suppose there’s a lesson here about not bothering to send a reference to an array when it’s just a one parameter thing.

I’ll throw the whole thing in here next, but then I’m calling it a week.

Happy coding!

#!/usr/bin/perl
use strict;
use warnings;

main( (0, 2, 1, 5, 3, 4) );
print "\n";
main( (5, 0, 1, 2, 3, 4) );


sub main {

    my @int = @_;

    print "Input: ";
    pretty_print_array( @int );
    print "Output: ";
    pretty_print_array( build_array( @int ) );

}



sub build_array {

    my @int = @_;

    return map{ $int[$_] } @int;

}


sub pretty_print_array {

    ## I copied-and-pasted this from my solution for Task 1.
    ## If I copy-and-paste it again, by law I need to turn
    ## it into a library. ;-)

        my @array = @_;
        my $length = scalar @array;
        my $count = 1;

        print "(";

        foreach my $value(@array) {
                print $value;
                print ", " if $count < $length;
                $count++;
        }

        print ")\n";

        return;
}

That’s a lot of boilerplate for a one line piece of code, isn’t it?

JavaScript Same String

Once again, I created a main() function like some kind of crazy C programmer just to have a function that can run each new set of arrays through the paces.

Most of this should look familiar:

// Same String

main(["ab", "c"], ["a", "bc"]);
main(["ab", "c"], ["ac", "b"]);
main(["ab", "cd", "e"], ["abcde"]);


function main( arr1, arr2 ) {

    // 0
    console.log('Input 1:')
    console.log('@arr1 = (' + arr1 + ')')
    console.log('@arr2 = (' + arr2 + ')')

    // 1
    const arr1_string = combine_list(arr1)
    const arr2_string = combine_list(arr2)

    const result = compare_strings(arr1_string, arr2_string)

    console.log('Output: ' + result)
    console.log('')

}

// 2
function combine_list( arr ) {
    return arr.reduce((acc, str) => acc + str)
}

// 3
function compare_strings( str1, str2 ) {
    return ( str1 == str2 ) ? true : false
}

0. I’m following the exercise writeup in prepending the array name with an encircled “A” to indicate it’s an array. Perl type checking, baby! I regret nothing.

1. I went back and forth on whether I should store the results of this function into a new variable and then use that as the arguments in the function on the next line. You could just as easily put this short function call inside the parenthesis in the compare_strings() call and be done with it.

I just thought this way of reading the code was a little easier, so I did it this way.

2. The reducer function is inside a function all its own. I thought it looked ugly to inline that function twice in main(), so it went to the side on its own. I love a good reducer. You just pass the item you’re iterating over with the accumulator, itself, and a function to do the dirty work. Voila!

3. Yes! A ternary operator! Come at me. I’m fine with it. A lot of people hate ternaries, but there’s nothing wrong with them when used right. This is a prime example of “right.” It only gets ugly when you have a complicated “if” statement or you start nesting ternaries, but for a simple true/false test like this, it makes perfect sense. I didn’t need one in Elixir because I was using pattern matching. I used it as an option in Perl, but I should have committed to it. Maybe I’ll go back and fix the script on Github…

“Same String” Simplified: Python Edition

I’m forcing myself to learn Python, because I need it for work. With a few tweaks, it’s just Perl/Ruby/Javascript with white space that counts. I keep bouncing between languages and forgetting which ones use [] for arrays/lists versus (). Also, this is the fourth version of this code I’ve written, so maybe I’m just getting tired?

The good news is, Python does have a built-in reducer function, but you do need to import it from a core library. I know Perl has things like this, too, but it’s always happening for me in Python. I’m always having to import something from a core library to use in my scripts, and that feels clunky.

I get it — why waste memory on lots of libraries if you don’t need them, but can’t the language automatically include them when it seems they are being used? It’s still better than having to install them, but it does annoy me.

Let’s get right to the code:

from functools import reduce

def show_inputs(arr1, arr2):
    print( "Input: @arr1 = ", arr1 )
    print( "       @arr2 = ", arr2 )


def reduce_string(arr):
    return reduce(lambda x, y: x + y, arr)

## 1
def compare_strings(str1, str2):
    return "true" if str1 == str2 else "false"

def show_output(final_answer):
    print( "Output: ", final_answer, "\n" )

## 2
def run_everything(arr1, arr2):
    show_inputs(arr1, arr2)
    str1 = reduce_string(arr1) ## 3
    str2 = reduce_string(arr2)
    show_output( compare_strings(str1, str2) )

## Run process with example data
run_everything(["ab", "c"], ["a", "bc"] )
run_everything(["ab", "c"], ["ac", "b"] )
run_everything(["ab", "cd", "e"], ["abcde"] )

I like how compact this code feels. It’s very thin. It gets straight to the point and doesn’t waste a lot of space. The reduce function with the lambda will take some getting used to, but it does the job.

1. You can display a boolean in Python in a print statement by using the str() function. But why bother when, for the sake of this exercise, I just need a string to print out? That’s why I’m returning the string here instead of the Boolean. Note that booleans in Python start with a capital letter, but my strings here do not.
2. Is there a Pep yet for a pipe operator? That might clean some of this up.
3. Since there is no pipeline operator, there’s really no reason to call a single function with two arrays to get back a tuple or an array of two arrays back, right? So I call directly into the reducer here, instead of the middle step of having a function do that twice.

It is also at about this point that I realized my quest to finish the first challenge in four different languages means I never did the second challenge of the week.

Better luck next week, me!

There’s a fine line between Best Practices and Let’s Push This As Far As We Can.

To be honest, I’m still not sure if I went too far with this one, or not far enough.

This is an exercise that’s made for Perl. It’s string manipulation. It’s perfect for the Practical Extraction and Report Language. As I wrote it, though, I also noticed that it’s a great bit of functional coding — extract the data, transform it into something else, and report the results. Use a series of functions to morph the beginning data into the end data you want.

That meant that I had to do it in Elixir, also.

I thought I’d just write the Perl script and then transform it into Elixir, but then things took on a life of their own.

“Same String”: Perl Edition

You are given two arrays of strings.

Write a script to find out if the word created by concatenating the array elements is the same.

For example, is an array of “ab” and “c” the same as “a” and “bc” after their parts have been smashed together? Yes, both are “abc”.

You could program this straight through. Wouldn’t need a single subroutine in the code at all. For the purposes of testing this, though, I put everything into a main() that we could call with all three sets of arrays provided in the challenge. And I re-used my pretty_print_array() subroutine from the last challenge.

Here’s the code to run the first test, minus pretty_print_array() which you can find in last week’s writeup at the link in the last paragraph:

my @arr1 = ("ab", "c");
my @arr2 = ("a", "bc");
main(\@arr1, \@arr2);

sub main {

    my @arr1 = @{ shift() };
    my @arr2 = @{ shift() };

    print 'Input: @arr1 = ' . ( pretty_print_array(\@arr1) ) . "\n";
    print 'Input: @arr2 = ' . ( pretty_print_array(\@arr2) ) . "\n";

    my $combined_string1 = '';
    my $combined_string2 = '';

    map{ $combined_string1 .= $_; } @arr1;
    map{ $combined_string2 .= $_; } @arr2;

    print "Output: ";

    if (  $combined_string1 eq $combined_string2 ) {
        print "true\n";
    } else {
        print "false\n";
    }

}

Is it elegant and reusable and the kind of thing I’d put up on CPAN? Nah.

Does it solve the challenge? Yes.

However, I saw what was happening here:

• Print the array to the screen
• Combine the parts of the arrays into strings
• Compare those two strings I just created.
• Print out the results of that comparison

One bullet point basically feeds into the next. We’re taking a piece of data, transforming it in some way, and then sending it to the next step to transform it again and pass it along.

This is perfect for Elixir’s pipe operator.

More Functions, More Fun

First, though, let’s functionalist the &$%# out of this in Perl:

#!/usr/bin/perl
use warnings;
use strict;

my @arr1 = ("ab", "c");
my @arr2 = ("a", "bc");
main(\@arr1, \@arr2);

sub main {

    my @arr1 = @{ shift() };
    my @arr2 = @{ shift() };

    show_inputs(\@arr1, \@arr2);
    my $combined1 = combine_arrays(\@arr1);
    my $combined2 = combine_arrays(\@arr2);
    my $results = compare_strings($combined1, $combined2);
    show_output( $results );

}

sub show_inputs {

    my @arr1 = @{ shift() };
    my @arr2 = @{ shift() };

    print "Input: \@arr1 = " . ( pretty_print_array(\@arr1) ) . "\n";
    print "Input: \@arr2 = " . ( pretty_print_array(\@arr2) ) . "\n";

    return;

}

sub show_output {

    my $final_results = shift();
    print "Output: " . $final_results . "\n\n";

}


sub combine_arrays {

    my @arr = @{ shift() };
    my $combined_string = '';
    map{ $combined_string .= $_; } @arr;

    return $combined_string;
}

sub compare_strings {

    my ($str1, $str2) = @_;

    return 'true' if  $str1 eq $str2;
    return 'false';

    # Or, in ternary fashion:
    # return $str eq $str2 ? "true" : "false";


}

This will work whether there is one value in each array, or an insanely large number that fits in memory. It’s still only going to work with two arrays, but I’m not going to worry about that bit of craziness.

But each step from that bullet point list I wrote out above is now solved with a subroutine. One feeds into the next. Send data in, get data in, pass that new data onto the next one. Some of it is purely functional and some of it is just for displaying information to the screen.

Here’s how it breaks down:

• Print the array to the screen ( show_inputs() )
• Combine the parts of the arrays into strings ( combine_arrays() )
• Compare the strings ( compare_strings() )
• Print out the results of that comparison ( show_output() )

It’s also super easy to test this now. Every step can be tested independently.

This kind of programming of chaining functions together and letting one feed the next is the perfect program to write in a functional language. Let’s look at this in Elixir.

“Same String”: Elixir Edition

Take the same bullet points. Run a data point through them. See what happens.

I’ll create a module named SameString to put all the functions in. I’ll start with the brains behind the whole operation and then add the individual functions above it as we go.

defmodule SameString do

    def run_everything(tuple_of_lists) do

        tuple_of_lists
        |> show_inputs()
        |> combine_lists()
        |> compare_strings()
        |> show_output()

    end
end

That might look a little familiar already. I did a little renaming, since Elixir uses lists instead of arrays, but it’s the same function (née subroutine) names.

If you’re not familiar with Elixir, I’ll try to explain how the pipe operator works: The expression or output of the function just before it is passed as the first argument to the function after it. I’ve constructed these functions to only require one parameter, so you never have to see anything besides the function names. The output of tuple_of_lists/1 is sent directly into show_inputs/1, then the output from that function is sent as the first argument to the next function, combine_lists/1, etc.

The pipe operator is super cool. The only other Elixir feature in the core language that comes close is pattern matching. We’ll be using that, too. Stick around.

To make this more concrete, here’s how we’ll be calling this function:

SameString.run_everything( {["ab", "c"], ["a", "bc"]} )

The data structure I’ve chosen is a tuple with two lists in it. You could just as easily make it a list of two lists, but I liked adding in an extra data structure for the exercise of it all.

The run_everything/1 function receives it as tuple_of_lists and then pipes it into show_inputs. As you might imagine, that function shows the inputs to the screen:

   def show_inputs({list1, list2}) do
        IO.puts "Input: List1 = "
        IO.inspect list1

        IO.puts "Input: List2 = "
        IO.inspect list2

        {list1, list2}
    end

Three things to look out for here: I’m cheating a bit by returning the tuple of lists back out of this function so we can continue the pipe chain.

Second, in my attempt to be descriptive of the function by listing out the parameters the function takes, I’ve created a pattern-matching element. If I tried to pass in a single string or a number or even a map, this function would never run and the whole program would die then and there. Anything other than a tuple (indicated with curly braces) with two variables of some kind in it will fail to match and this function would never run.

Third, you need to use IO.inspect to print out an array, rather than IO.puts. It’s a long story, but trust me on that one.

From there, the tuple of lists gets passed to the next function:

def combine_lists({list1, list2}) do

        string1 = reduce_string(list1)
        string2 = reduce_string(list2)

        {string1, string2}

end

Here’s where things shift a bit from Perl. Rather than mapping over the array and concatenating the pieces into a string, I want to run a reducer to boil the array down to one long string.

    def reduce_string( list_of_strings ) do

        Enum.reduce(list_of_strings, "", fn characters, acc ->
            acc <> characters
        end)

    end

This takes each element of the array and concatenates it to an accumulator. Enum.reduce naturally returns that last generated value.

And then combine_lists/1 sends back out a tuple of the two new strings.

The pipe operator neatly sends that tuple over to compare_strings/1. If you’re not used to pattern matching, this is where things get interesting. There are two different functions named compare_strings/1 here:

    def compare_strings({string1, string1}) do
        true
    end

    def compare_strings({_, _}) do
        false
    end

Elixir is doing pattern matching. If the two values inside the tuple being passed into the function are the same, it returns true. Otherwise, it returns false.

In the second function, you replace the parameters with underscores to indicate that you’re not going to do anything with the values that are coming in here. Elixir is serious about this – it’ll give you a warning if you run the script with named variables you never use.

There’s one more way to shorten this up even more:

    def compare_strings({string1, string1}), do: true
    def compare_strings({_, _}), do: false

Slightly different syntax, but it’s well-suited for the one-liner structure for short functions.

That true or false value then gets passed into show_output/1, and I’ll do some one-liners and pattern matching here, too:

    def show_output(true), do: IO.puts "Output: True"
    def show_output(false), do: IO.puts "Output: False"

Part of the fun of Elixir is writing complete programs without ever touching an if statement. Use pattern matching and the rest will follow.

And done. That’s the end of the pipeline.

It’s a nifty bit of code that feels right, reads easily, and (again) could be easily tested.

To see the final script, check out my Github repo.

But, wait! Let’s program this in two more languages! Stay tuned….

Other Solutions

I’m not good at Perl Golf. It’s not something I’ve practiced or worked on, either, but it’s always entertaining to watch someone who is skilled at it. Check out W. Luis Mochán’s one-liner solution on his blog.

Recursion? I love recursion! And you know what else I love? Elixir! So let’s solve the Weekly Challenge in Elixir next!

Elixir: A Prelude

It’s worthy of another essay entirely, but I love Elixir.

I don’t use it regularly. In fact, it had been years since I wrote a line of Elixir code before sitting down to write this script. I had to breeze through some documentation first to jog my memory of the syntax.

As a functional language, Elixir screams out to solve this challenge in a quick, logical, and readable way.

Let’s get to it.

Short But Sweet

I got my B.A. in Computer Science in college. I took one class that used a functional language, and that was Scheme. I remember little of that class besides that we coded aspects of the board game, Clue, as our programming projects. (Oh, and all the parenthesis!) The lessons learned in writing recursive functions always stuck around.

The number one rule: The recursive equation will continue until it hits its base case. Never forget the base case, and you’ll have a chance to be successful.

An accumulator often helps, too.

As a reminder, the challenge for Running Sum is this:

Write a script to return the running sum of the given array. The running sum can be calculated as sum[i] = num[0] + num[1] + …. + num[i].

As an example, the array (1, 1, 1, 1, 1) will return (1, 2, 3, 4, 5).

(I’ll bounce back and forth between array and list here. The challenge is written with Perl in mind, so that’s an array. This solution is in Elixir, which uses lists. We don’t need to nit-pick on this point, for the purposes of this exercise.)

I’ll jump straight to my code:

defmodule Runner do

    def running_sum([head | tail], new_list, sum) do
        sum = sum + head
        running_sum(tail, new_list ++ [sum], sum)
    end

    def running_sum([], new_list, _) do
        new_list
    end
end

Super simple: Pass in the full array ( (1, 1, 1, 1, 1) in the example above) along with the new list (which starts empty) and the running total (which starts as 0).

When that first list is empty, return the new list. The end.

Elixir’s pattern matching is a whole different way to think about functions if you’re used to the kind of functions you use in scripting languages like Perl, Python, Javascript, Ruby, etc. It’s such a cool feature that they’re all working on implementing it. (Raku included it in the language.)

The same goes for the pipeline operator in Elixir, which I didn’t have a use for with this challenge. Maybe next time!

Also, you’ll notice this line:

sum = sum + head

I said in a previous write-up that I love a good += operator, so why didn’t I use it here? Elixir doesn’t have it. It’s an immutable language. The equals symbol doesn’t exactly work the way you think it does. There’s a re-binding thing going on here and a pattern-matching thing happening and — I’m not the right person to explain it all. Just trust me on this.

Also, I could avoid this entire explanation by moving that line into the parameters of the running_sum/3 call on the next line and not assigning it to anything:

running_sum(tail, new_list ++ [sum + head], sum + head)

I just hate that duplication. There’s a way around it entirely that we’ll explore two sections from now, though. Keep scrolling down!

Let It Run!

I ran the three examples given in the challenge with this bit of copy-and-past brilliance:

IO.puts 'Exercise 1: '
list_of_numbers = [1, 2, 3, 4, 5]
IO.inspect list_of_numbers
IO.inspect Runner.running_sum(list_of_numbers, [], 0)

IO.puts 'Exercise 2: '
list_of_numbers = [1, 1, 1, 1, 1]
IO.inspect list_of_numbers
IO.inspect Runner.running_sum(list_of_numbers, [], 0)

IO.puts 'Exercise 3: '
list_of_numbers = [0, -1, 1, 2]
IO.inspect list_of_numbers
IO.inspect Runner.running_sum(list_of_numbers, [], 0)

Note that I’m using IO.inspect to print out the list. For very good reasons, IO.puts doesn’t work here for what we want. It translates the numbers into character codes and makes a mess of things. It’s a common gotcha for new Elixirists. ( And for those who haven’t written it in a while, as it turns out.)

That produces the following results:

Exercise 1: 
[1, 2, 3, 4, 5]
[1, 3, 6, 10, 15]
Exercise 2: 
[1, 1, 1, 1, 1]
[1, 2, 3, 4, 5]
Exercise 3: 
[0, -1, 1, 2]
[0, -1, 0, 2]

Works for me! Short, but sweet.

Wait! Can We Do It Another Way?

It bothered me that I had to set so much stuff up. I had to pass in a blank array and a starting sum of 0 to kick things off. Could I rewrite this with only 2 parameters to the function?

Yes, it’s possible. However, I don’t like the solution. I’m curious what you think.

defmodule Runner do

    ## First iteration
    def running_sum([head | tail], []) do
        running_sum(tail, [head])
    end

    ## Everything inbetween
    def running_sum([head | tail], new_list) do
        new_list = new_list ++ [head + List.last(new_list)]
        running_sum(tail, new_list)
    end

    ## Base Case
    def running_sum([], new_list) do
        new_list
    end

end

IO.puts 'Exercise 1: '
list_of_numbers = [1, 2, 3, 4, 5]
IO.inspect Runner.running_sum(list_of_numbers, [])

We end up with three functions (with an arity of 2 now) to handle the job. The base case happens when the initial list has been drained dry. Nothing changes there.

But there is now a starting function. When the accumulator (new_list) is passed in as empty, the first function is kicked off. It calculates the sum by adding the first value (head) from whatever is left of the initial list to the latest value in the new_list. Then, it adds that to the end of new_list.

Intellectually, this makes more sense to me. It lets the functions do the work. It doesn’t require an extra parameter to be around. I never have to reassign the sum variable in the middle of a function.

But it also seems like more work. That long line in the second function takes too long to break down and understand for a first-time reader of the code.

I prefer the tradeoff of one extra value to kick things off to the “simplicity” of a function/2 over a function/3.

I only submitted running_sum/3 in the end.

The Weekly Challenge Meta Note

I doubt I’m the first person to do a Weekly Challenge in Elixir. I see the stats include “Erlang” solutions, but I’m not sure if that’s a catch-all for both Elixir and Erlang.

I think I’ll be doing more in Elixir in any case, just to keep my functional mind sharp.

You can find the full script from this challenge on Github.

Today, things get real. We’re talking recursion, global variables, and nested sorting.

Whoa, boy.

Part Two: Sort For Your Life!

You are given an array of positive integers. Write a script to sort the given array in increasing order with respect to the count of steps required to obtain a single-digit number by multiplying its digits recursively for each array element. If any two numbers have the same count of steps, then print the smaller number first.

To truly understand this one, you need to see the examples. At least, I did.

This was one of those cases where a simple sort command wasn’t going to work. I’d have to sort by a custom function. Fine, let’s do that.

The solution I came up with was to first create a hash that stores the number of times the digits in a number need to be multiplied together to get to a single-digit number.

sub multiply_numbers_recursively {

    # Recursion Rocks

    my $number = shift();
    my $count  = shift();

    my @list_of_numbers = split(//, $number);
    return $count if scalar(@list_of_numbers) == 1;

    my $running_total = 1;
    map{ $running_total *= $_ } @list_of_numbers;

    return multiply_numbers_recursively($running_total, ++$count);
}

Ah, the glories of recursion! In my last write-up, I mentioned how much I love map{} and grep{}, but recursion is right up there, too.

This function keeps multiplying until you get down to the number you need, tracking the number of iterations in an accumulator named $count.

I split the number as if it were a string of characters to get a list of numbers. I went with “//”, but you can also use ‘undef’ or an empty string like ” there to do the same thing.

Having created this hash with all the information I need, I can run my custom sort and arrange the numbers in the correct order: first, by the number of multiplications, and secondarily in increasing value of the numbers.

sub persistence_sort {

    my @array = @{ shift() };

    foreach my $value( @array ) {
        my @array_of_numbers = split(//, $value);
        $steps{$value} = multiply_numbers_recursively($value, 0);
    }

    my @final_results = sort compare keys %steps;

    return @final_results;

}

sub compare {

    ## The two level sort function
    ## The reason I have a global variable.

    if($steps{$a} < $steps{$b}) {
        return -1;
    } elsif ($steps{$a} == $steps{$b}) {
        return 1 if $a > $b;
        return -1;
    } else {
        return 1
    }

}

persistence_sort() loops over the positive integers in the array that the program is given. It runs multiply_numbers_recursively() to do all the multiplying necessary of the individual digits in a number until their sum is less than 10. The number of rounds it took to get there is stored in the %steps hash.

Now, you can sort the keys of the hash by (1) how many rounds of multiplication it took and then, when the number of loops is equal for multiple values, (2) how big the original number is.

Gasp! The Horrors!

There is one ugly bit of business that this solution has, though. A global variable. %steps has to be global for this to work. I ran out of time to try to work it out with that. I have a feeling there’s a way to pass %steps into the sort that will make things get very ugly very quickly. Or, I’d have to include the sort function directly inside the sort command line.

Finally, I copied-and-pasted that pretty printer from the last exercise, wrote a bit of script to loop over the two sample arrays, and got back these results:

BEFORE: (15, 99, 1, 34)
AFTER: (1, 15, 34, 99)

BEFORE: (50, 25, 33, 22)
AFTER: (22, 33, 50, 25)

That’s nothing too fancy, but it gets the job done.

Again, the global variable bites back as I had to make sure to blank that out after each iteration:

## Test Values:
my @first  = (15, 99, 1, 34);
my @second = (50, 25, 33, 22);
my @tests = ( \@first, \@second );

## Runner:
foreach my $array_ref( @tests ) {

    print "BEFORE: ";
    pretty_print_array( $array_ref);

    my @results = persistence_sort( $array_ref );

    print "AFTER: ";
    pretty_print_array(\@results);

    print "\n";

    ## The price I pay for the global
    %steps = ();

}

When I didn’t restart the hash, it would continue to add in all the values from the next test. It sorts it correctly, at least, but that’s not what I was trying to do.

Next week, I’ll follow this up by using a GOTO statement!

You can find my final script on Github.

Running Sum

This week’s challenge is to write a script that takes an array and outputs an array where each value is a sum of the numbers before it.

For example:

Input: (1, 2, 3, 4, 5)
Output: (1, 3, 6, 10, 15)

This one is fairly straightforward. You can loop right over it and add the numbers as you go pretty quickly:

use Data::Dumper qw/Dumper/;
my @array = (1, 2, 3, 4, 5);
my $sum = 0;
my @sum_array = map{ $sum += $_; } @array;
print Dumper \@sum_array;

That’s pretty simple, I think. I also have a “use strict” and “use warnings” bit at the top, but didn’t think it was necessary for this presentation.

The variable names are pretty direct, also. In a real world scenario, I wouldn’t name an array @array, but in a challenge like this, it’s fine.

I love using Data::Dumper to easily print out all kinds of variables in Perl, but especially hashes of hashes and arrays of hashes and all that second level kind of craziness.

I spent just enough time learning functional programming to take any excuse to use map{} or grep{} in Perl. In my first version of this script, I was updating @sum_array inside the map statement. Then I realized how silly that was. If you’re mapping over something, the map command will produce a new array — just capture that!

There is some advice out there about not using map in place of a for or foreach loop. It’s meant as a data filter. I don’t always follow that advice, but I try to. That’s what I did here.

Two related hills I’ll die on: Don’t take the increment/decrement counter away from me, and let me have “+=” and “*=” and all the rest. It always throws me off when a language doesn’t have that.

Refactor for Prettiness

Having solved the issue, I took the challenge literally. Data::Dumper doesn’t print out an array like this:

(1, 3, 6, 10, 15)

It shows it like this:

$VAR1 = [
          1,
          3,
          6,
          10,
          15
        ];

So I had to create a prettier printer. While I’m sure there are a hundred good Perl modules I could download from CPAN to do it, I wanted to code something myself for this challenge.

That’s how I ended up with this code at the end, including a bit of code to run all three examples from the challenge:

# Test Data:
my @test1 = (1, 2, 3, 4, 5);
my @test2 = (1, 1, 1, 1, 1);
my @test3 = (0, -1, 1, 2);
my @array_examples = (\@test1, \@test2, \@test3);


print "Running Sum Code Results:\n";
print "=========================\n\n";

foreach my $array_ref (@array_examples) {

    print "Array: " ;
    pretty_print_array( $array_ref );

    my @results = show_running_sum($array_ref);

    print "Results: ";
    pretty_print_array(\@results);
   
    print "\n";

}

##
## Subroutines
##

sub show_running_sum {

    ## Ultimately, this is the heart of the solution

    my @array = @{ shift() };
    my $sum = 0;

    return map{ $sum += $_ } @array;

}

sub pretty_print_array {

        ## Total overkill, but I'm new and over-enthusiastic.
        ## In reality, I'd find something on CPAN for this.


        my @array = @{ shift() };
        my $length = scalar @array;
        my $count = 1;

        print "(";

        foreach my $value(@array) {
                print $value;
                print ", " if $count < $length;
                $count++;
        }

        print ")\n";

        return;
}

Turns out, making the final output look prettier took more coding than the challenge, itself. Such is life sometimes…

I’m also sure there are shorter, less readable ways to do it. I’ll take this way. I’ll take readability over Perl Golf, though I do enjoy those efforts.

Putting everything in new neat subroutines makes testing easier, also, though I didn’t test for this example. I’m sure I’ll do some TDD in a future weekly challenge, though.

You can find the full script on my Github.

I also solved this challenge in Elixir, in case you are functionally-curious.

If it wasn’t built that way, then they’ll graft something on to the language to confuse newbies and help some users pretend like they’re typing their language. In reality, they’re just making Visual Studio Code happy.

Or they’ll create a new language that compiles down or transpiles to the original language, which leads to the creation of new build processes and increased waits and more annoyances.

Hello, TypeScript, whose users really just want better autocomplete.

At the same time, Perl is a reviled language that nailed types from the offset. A scalar variable is preceded by an s-looking “$”, an array is preceded by an a-looking “@”, and a hash gets the “%” which is a slight reach, but is still H-looking enough. If you’re looking at one item in that array, you refer to it as a scalar with an “$”.

You don’t need Visual Studio Code to help you figure out what “@items” is, because it’s right there in the name.

It’s basic typing in the language. If you use the wrong sigil, you get the wrong results or an error message.

And everyone called it unreadable and laughed at it.

You hypocrites.

In reality, it was just thirty years ahead of its time.

Javascript is scrambling to figure out how best to add all of Typescript into the core language. Ruby bolted something on a couple of years ago. Elixir just announced that it’s starting to add types.

Even the amazing and nigh-perfect Python skipped that typing step and is now scrambling to add one in somewhere, somehow. I should submit a Pep suggesting a “$” prefix for string types, but that leaves Sets without the obvious prefix. Lists can have the “£” character, which means it’ll be easier for British programmers to type. I’ll let someone else figure out Dictionary and Tuple types.

TLDR

Types are mostly important to make Visual Studio Code handier. Perl continues to set the standard other languages strive for, even while being the subject of all the barbs. Welcome to my blog.