A couple of general tips.

• When modifying a global for local use (e.g. $_), localize it first.
• I don't see $i declared. Is strict on?
• Almost always, C-style loops are much harder to read and maintain then their Perl equivalents.
  Consider using for my $i (a..b) instead of for (my $i=a; $i<=b; $i++).
• If you want to hide a warn, why not just hide *that* warning. e.g. no warnings 'uninitialized';

$i was previously declared, I should have mentioned that. This is a snippet of the entire code. Like I said, I only just learned Perl. I learned C last semester and the stuff I do at my work is a lot of string-manipulation stuff so that's why I switched. I wrote the initial thing when I was still making the transition from C to Perl -- I'd basically write C code with Perl. I'm getting much better at coding Perl-style-Perl but it's been a month. I also did not know I could hide specific warnings. Thanks.

The reason I mentioned $i is that you reuse the variable (not just the name). I typically view that as bad, especially when it's trivial to declare it for the loop itself.

    ||
    vv
for my $i (1..5) {
   ...
}
[download]

Here's an implementation with simpler calculations, with fewer special cases and which can easily be extended to four columns.

It also fixes some bug in yours. Yours skips the 17th element ($dupes[16]) when you have 23 elements (@dupes == 23). I didn't track down the cause of the error.

The idea is simple: Pretend the array is a 2d array, then combine the row and col indexes into one.

my @dupes = qw( a b c d e f g h i j k l m n o p q r s t u v w );

my $num_cols = int( @dupes / 10 ) + 1;
if ($num_cols > 3) {
   $num_cols = 3;
}

my $num_rows = int( $#dupes / $num_cols ) + 1;

for my $r ( 0 .. $num_rows-1 ) {
   for my $c ( 0 .. $num_cols-1 ) {
      my $i = $r + $c * $num_rows;
      last if $i > $#dupes;
      print("\t$dupes[$i]");
   }
   print("\n");
}
[download]

Update: Added "The idea ..." paragraph.

This looks perfect. Thanks so much for your help!

It helps to write a function that prints the array in a defined number of columns:

sub print_in_n_cols {
    my ($count, @items) = @_;
    while (@items){
        for (1 .. $count){
            print "\t", shift @items;
            last unless @items;
        }
        print "\n";
    }
}
[download]

Now you can call that, based on the number of dupes:

if (@dupes <= 10){
    print_in_n_cols(1, @dupes);
} elsif (@dupes <= 20){
    print_in_n_cols(2, @dupes);
} ...
[download]

Actually I don't why you want this behaviour, it feels more natural to me to always print in four columns - but of course that's your choice.

You changed the output from

a  e  i
b  f  j
c  g
d  h
[download]

to

a  b  c
d  e  f
g  h  i
j
[download]

That's exactly the issue I had when I tried to approach it the first time by just popping/shifting stuff off like the subroutine above..

I just looked at the C source code to this utility, and it's an ugly mess. Small and efficient, possibly, but not particularly literate. It looks like someone thought that a robo-indenting tool made code readable, because everything is indented consistently but there's nary a comment to explain how it works.

This is something I thought I had seen on CPAN, but I guess Text::Table is a bit different in purpose.

One advantage of ls's method (and presumably column's) is that it resizes the columns to fit what will be placed in them and takes into account the width of the terminal.