# Use strictures and warnings to force declaration of variables and
# catch typos and other errors. This is recommended practice.
#
use strict;
use warnings;

# Use the Data::Dumper standard module to allow us to visualise the
# data structure we have built.
#
use Data::Dumper;

# Initialise the @input array.
#
my @input = qw{
   1200 1300 1200 1000 1100 1200
   1500 1700 2000 2100 3000 2100
   1200 1500 1700 1700
   };

# Assign our groups of unique items to the @groups array; the groups
# are returned as a list of references to arrays by the deDup
# subroutine which is called with a reference to the @input array as
# a parameter.
#
my @groups = deDup( \ @input );

# Print the Data::Dumper representation of our resultant @groups
# array.
#
print Data::Dumper->Dumpxs( [ \ @groups ], [ qw{ *groups } ] );

# Declare the deDup subroutine.
#
sub deDup
{
    # Assign the reference to an array passed as the sole argument
    # to the $raToCheck scalar variable.
    #
    my $raToCheck = shift;

    # Initialise two array references (also known as anonymous arrays)
    # that will hold our unique items and our duplicates. Also declare
    # a hash %seen that we will use to find our duplicates.
    #
    my $raUniq = [];
    my $raDups = [];
    my %seen;

    # This is where we find duplicates. We use @$raToCheck to de-
    # reference the array reference held in the $raToCheck scalar in
    # order to access each element. Each element is passed in turn in
    # the $_ scalar variable by the "for" statement modifier to the
    # code to its left. That code pushes the item onto one of two
    # anonymous arrays depending on whether that item has already
    # been seen or not. If the item has not been seen there will not
    # yet be an element in the %seen hash with a key matching that
    # item so the test $seen{ $_ } ++ ? will be false, the item will
    # be pushed onto @$raUniq then the ++ post-increment will ensure
    # that $seen{ $_ } has a value of 1 so that, if that item is
    # encountered again, the test will now be true and the item will
    # be pushed onto @$raDups;
    #
    push @{ $seen{ $_ } ++ ? $raDups : $raUniq }, $_ for @$raToCheck;

    # This is where the recursion happens. The subroutine returns the
    # reference to the array of unique values and, if the anonymous
    # array of duplicates is not empty, it calls itself with the
    # duplicates as an argument, otherwise an empty list. So the
    # returmed list is of a successively smaller series of anonymous
    # arrays until there are no duplicates to be found.
    # 
    return $raUniq, @$raDups ? deDup( $raDups ) : ();
}
[download]