Collect your data in a hash of arrays, pushing on the data as it is seen,

my %hash;
while (<IN>) {
    chomp;
    my @foo = split /, /;
    push @{$hash{$foo[0]}}, 0+$foo[1];
}
for (sort keys %hash) {
    print OUT join ', ', $_, @{$hash{$_}};
    print OUT $/;
}
[download]

use strict;

my $prev;
while (<DATA>) {
  next if /^\s*$/;
  chomp (my ($curr, $val) = split /,\s+/);
  print $prev ? "\n" : "", $prev = $curr if $curr ne $prev;
  print ", $val";
}
print "\n";

__DATA__
a, 1
aa, 3
aa, 5
aa, 8
b, 2
b, 3
bb, 5
[download]

Hey Roger,

Can you enlighten on the purpose of '\s+' in the split expression?

\s means match a single space, \s+ means match one or more spaces.

In the example below:


use strict;
use Data::Dumper;

my $string = 'a, 1, 2,  3';

my @split_comma = split /,/, $string;
print "\@split_comma =>", Dumper(\@split_comma);

my @split_comma_space = split /,\s+/, $string;
print "\@split_comma_space =>", Dumper(\@split_comma_space);
[download]

Notice in the output -


@split_comma =>$VAR1 = [
          'a',
          ' 1',
          ' 2',
          '  3'
        ];
@split_comma_space =>$VAR1 = [
          'a',
          '1',
          '2',
          '3'
        ];
[download]

Splitting with comma only leaves spaces in array elements, while splitting with comma+space leaves no spaces in array elements.

What split /,\s+/ does is to set the separator as comma followed by 1 or more spaces, thus eliminating the spaces from the result.

my %all;
while(<>)
{
 my ($k,$v)=split/,/;
 $all{$k}.=",$v";
}
print map { "$_, $all{$_} "} keys %all;
[download]

This leads to possibly ugly output as there will be an extra comma in the output

Also will a value appear more than once, and should the values be sorted as well? Im thinking a HoH might be overkill, but another (better?) way to do it.

my %all;
while (<>) {
   s/\s+//g;
   my($k, $v) = split /,/;
   next unless defined $k and defined $v;
   $all{$k}{$v}++;
}

for ( sort keys %all ) {
   print "$_, ", join(', ', sort keys %{ $all{$_} }), "\n";
}
[download]

use perl;

or, getting sillier...

while (<DATA>) {
  print /(\d+)/ ? ", $1" : $s{$_}++ ? '' : $a++ ? "\n$_" : $_ for spli
+t /\s*,\s*/;
}
print "\n";
__DATA__
a, 1
aa, 3
aa, 5
aa, 8
b, 2
b, 3
bb, 5
[download]

#!/usr/bin/perl -w

use strict;

my $someDatFile = 'datfile.dat';    #the file you need read in

open( DATFILE, $someDatFile ) or die "Cannot open $someDatFile";

my $currentPrefix;
while( <DATFILE> )
{
    my( $prefix, $postfix ) = split ( /,/, $_ );
    &cleanUp( \$prefix );
    &cleanUp( \$postfix );

    if( ( !$currentPrefix ) or ( $currentPrefix ne $prefix ) )
    {
        if( $currentPrefix )
        {
            print "\n";
        }
        $currentPrefix = $prefix;
        print "$prefix, $postfix";
    }
    else
    {
        print ", $postfix";
    }
}

print "\n";

close( DATFILE );

sub cleanUp
{
    my $ref = shift;
    $$ref =~ s/^\s*//;
    $$ref =~ s/\s*$//;
}
[download]

my %hash;
while (<DATA>) {
    chomp ( my ( $key, $val ) = split /,\s+/ );
    push @{$hash{$key}}, $val;
}
print "$_ ", join( ", ", @{$hash{$_}} ), "\n" foreach sort keys %hash;
[download]