It's simpler if you sort the indexes instead of the values.

my $portion = 0.20;
my @array = (2, 4, 3, 8, 9, 12, 13, 20, 18, 7);

my $keep = int(@array * $portion);
my @sorted_idxs = sort { $array[$a] <=> $array[$b] } 0..$#array;

my @final = ('-') x @array;
$final[$sorted_idxs[$_]] = 'B' for 0..$keep-1;
$final[$sorted_idxs[$_]] = 'A' for -$keep..-1;

print("@final\n");
[download]

B - B - - - - A A -
[download]

Update: Fixed off-by-one error.

This works better for the given elements. It gives the result as you need. Refer splice to know about it.

my @array = (2 ,4, 3, 8, 9, 12, 13, 20, 18, 7 );

my $percent = (scalar @array * 0.20);
my (@resultA, @resultB);

my @ordered = sort {$a <=> $b} @array;

@resultB = splice(@ordered, 0, $percent);
@resultA = splice(@ordered, (scalar @ordered - $percent));
print "@array", "\n";

for (my $i=0; $i < scalar @array; $i++)  {
    if ( grep { $array[$i] eq $_ } @resultA ) {
        $array[$i] = 'A';
    }
    elsif ( grep { $array[$i] eq $_ } @resultB ) {
        $array[$i] = 'B';
    }
    else  {
        $array[$i] = '-';
    }
}

print "@array", "\n";
[download]

Thanks, easy to implement and easy to understand.

@array = (2 ,4, 3, 8, 9, 12, 13, 20, 18, 7 );

my $c=0;
@sort_a_pos = sort {$a->[1]<=>$b->[1]} map { [$c++ => $_] } @array;

$pct = @array  / 10;

$_->[1] = "B" for @sort_a_pos[0 .. $pct];
$_->[1] = "-" for @sort_a_pos[$pct+1 .. $#array-$pct-1];
$_->[1] = "A" for @sort_a_pos[$#array-$pct .. $#array];

@finalarray  = map {$_->[1] } sort { $a->[0] <=> $b->[0] } @sort_a_pos
+;

print "@finalarray";
[download]

$_->[1] = "B" for @sort_a_pos[0 .. $pct];
$_->[1] = "-" for @sort_a_pos[$pct+1 .. $#array-$pct-1];
$_->[1] = "A" for @sort_a_pos[$#array-$pct .. $#array];
[download]

should be

$_->[1] = "B" for @sort_a_pos[0 .. $pct-1];
$_->[1] = "-" for @sort_a_pos[$pct .. $#array-$pct-1];
$_->[1] = "A" for @sort_a_pos[$#array-$pct .. $#array];
[download]

You probably got confused (like me) by the OP's weird math of 10 * 10% = 2. The output he gave was for 20%.

Note that your logic may fail if there are duplicate entries in the array. You may get "A"s, "B"s or "-"s more/less than required percentage depending on your implementation.

Good point, Thanks

I will try Ikegami or codeacrobat solutions (below). seems more reliable. I was thinking the index sorting is the way to go too but not smart enough to finish the task.

The 10 percent is hypothetical can be any percentage.

or 100%
  or 99%...

Good point. Also, the last two solutions do not work well if the number of array elements are odd. For instance, if we have 11 unique numbers it 5 should be A, 5 B and 1 dash. But both of them print 6 "A"s and 4 "B"s and no dash. I tried to play around with the ranges but could not resolve it. I think 50% is the maximum that we want to go to be able to divide the population of numbers into two categories. Therefore, I am not worry about 75% or higher unless there is another use for this little script.