@a = (1);
for (1..10) {
  print "@a\n";
  @na=();
  for (@a) 
    { $na[-1] == $_ ? $na[-2]++ : push @na, (1, $_) }
  @a=@na;
}
[download]

I first have to say that I really enjoyed this problem. It took me a little while to come up with a working algorithm, unfortunately it wasn't at elegant as yours. I thought I would play with your version to see if I could improve upon it a bit. The only thing I could do was add the use of references which reduces the memcopy time on larger lists. Below is a script that benchmarked the old 'non_ref' vs. the new 'ref'. Not necessarily staggering, but an improvement. I compacted the for loop for flipping it around and putting the for statement at the end of the conditional line.

#!/usr/bin/perl
use Benchmark;
my $count = 100;
 
my $end = 30;
sub ref {
  my $a = [1];
 
  for(1..$end){
#    print "@$a\n";
 
    my @na;
    ($na[-1] == $_ ? $na[-2]++ : push @na, (1, $_)) for @$a;
    $a = \@na;
  }
}
 
sub no_ref {
  my @a = (1);
 
  my @na;
  for (1..$end){
#    print "@a\n";
 
    @na = ();
    ($na[-1] == $_ ? $na[-2]++ : push @na, (1, $_)) for @a;
 
    @a = @na;
  }
}
timethese($count, { 'no_ref' => \&no_ref , 'ref' => \&ref} );
[download]

Benchmark: timing 100 iterations of no_ref, ref...
    no_ref: 11 wallclock secs (11.12 usr +  0.04 sys = 11.16 CPU)
       ref:  9 wallclock secs ( 8.34 usr +  0.06 sys =  8.40 CPU)  

# fastest
my @a = (1);
for (1..10) {
  my $s = @a;
  while ($s-- and my $e = shift @a) {
    push @a, 1, $e;
    $a[-2]++, $s--, shift @a while $a[0] == $e and $s;
  }
}

# shortest
my @a = (1);
for (1..10) {
  my $i;
  @a = map $i++ % 2 : length : $_, join("", @a) =~ /((\d)\2*)/g;
}
[download]

#!/usr/local/bin/perl

@a=split(//,"1");  #easier to make test strings this way. :)
for (1..10) {
  print "@a\n";
  @b=();
  $a=join("",@a);
  while ( $a =~ /((.)\2*/cg ) {
    push (@b, (length $1, $2));
  }
  @a=@b
}
[download]

That is more or less identical to my regex solution. Very nice, though.

$_="goto+F.print+chop;\n=yhpaj";F1:eval

#!/usr/local/bin/perl

use Benchmark;

$t0 = new Benchmark;
for (my $x = 0; $x < 500; $x++) {
my $numb = 1;
for (my $x = 0; $x < 10; $x++) {
        my @numb = split(//, $numb);

        my $count = 1;
        my $newnumb = "";

        for(my $x = 1; $x <= length($numb); $x++) {
                if ($numb[$x-1] ne $numb[$x]) {
                        $newnumb .= "$count$numb[$x-1]";
                        $count = 1;
                }
                else { $count++; }
        }
        $numb = $newnumb;
}
}

$t1 = new Benchmark;

$td = timediff($t1,$t0);

print timestr($td), "\n";
[download]

Why don't you post your code so we can benchmark against it in a meaningful comparison. Raw time numbers (like I posted above) mean nothing cause I could have written really bad code, but benchmarked it on a Cray....

1-10, 500x:  2 secs ( 1.13 usr  0.00 sys =  1.13 cpu) (printing)
1-10, 500x:  1 secs ( 0.48 usr  0.00 sys =  0.48 cpu) (not printing)
1-35m  10x: 26 secs (26.53 usr  0.00 sys = 26.53 cpu) (printing)
1-35,  10x: 15 secs (15.05 usr  0.00 sys = 15.05 cpu) (not printing)
[download]

$x = 1;
for(1..10){
        $x =~ s/((.)\2*)/length($1).$2/ge;
        #print "@{[split//,$x]}\n";
    }
[download]

Here's how I did it. Have no idea how this does on time.

#!perl
$total=10; ## Set to 1000 and watch your memory drain away! :)

@a=qw(1);
for (1..$total) {
  print "@a\n";
  my @all;
  $count=1; $x=0;
  {
    if ($a[$x] != $a[$x+1]) {
      push(@all, $count); push(@all, $a[$x]);
      $count=0;
    }
    last unless ++$count and $a[$x++];
    redo;
  }
  *a=\@all;
}
[download]

times not implemented at foo.pl line ...
[download]

The Benchmark module works on NT, and will provide useful comparisons.