(Warning: untested code ahead)

sub roll {
    my ($max) = @_;
    return 1 + int rand $max;
}

sub sum {
    my $sum = 0;
    $sum += $_ for @_;
    return $sum;
}

my @dice;

ROLL: for (1..4) {
    push @dice, roll 6;
    pop @dice and redo ROLL if $dice[-1] == 1; 
}

# Discard lowest
@dice = sort { $a <=> $b } @dice;
unshift @dice;

my $sum = sum @dice;
[download]

44696420796F7520732F2F2F65206F
7220756E7061636B3F202F6D736720
6D6521203A29202D2D204A75657264

use strict;
my @rolls;
foreach (0..3){
    my $roll = 1;
    
    while ($roll == 1) {
         $roll = int(rand(6) + 1) ;
    } 
 
 $rolls[$_]= $roll;
}
@rolls =reverse sort @rolls;
pop @rolls;
print @rolls;

&AddRolls(\@rolls);
[download]

C-.

#!/usr/bin/perl -w

use strict;

srand;
my $numtimes = 6;

for (
    my $rollattempt = 0 ;
    $rollattempt < $numtimes ;
    $rollattempt++
  )
{
    my $numdice  = 4;
    my $numsides = 6;
    my $sumof    = 3;
    my $highest  = 1;
    my @excludes = (1);
    print(
        "Roll attempt: ",
        $rollattempt,
        "\n",
        "\t",
        "Sum: ",
        &exclude_and_sum(
            $numdice, $numsides, $sumof,
            $highest, @excludes
        ),
        "\n"
    );
}

sub exclude_and_sum {
    my ( $nd, $ns, $so, $high, @excl ) = @_;
    my @droll    = ();
    my @temproll = ();
    my $sum      = 0;

    for ( my $dice = 0 ; $dice < $nd ; $dice++ ) {
        push ( @droll, int( rand($ns) + 1 ) );
    }
    @temproll = sort(@droll);
    @droll    = ();
    while ( my $d = pop (@temproll) ) {
        $d = int( rand($ns) + 1 )
          if ( scalar( grep( $d, @excl ) ) );
        push ( @droll, $d );
    }
    if ($high) {
        @droll = sort(@droll);
    }
    else {
        @droll = sort( { $b <=> $a } @droll );
    }
    for ( my $count = 0 ; $count < $so ; $count++ ) {
        $sum += pop (@droll);
    }

    return ($sum);
}
[download]

Roll attempt: 0
	Sum: 12
Roll attempt: 1
	Sum: 10
Roll attempt: 2
	Sum: 10
Roll attempt: 3
	Sum: 11
Roll attempt: 4
	Sum: 9
Roll attempt: 5
	Sum: 12

As I envision it, this code (barring any unforeseen logic errors) should allow an array of excluded numbers to be set, and allow for the number of values in the sum, the number and sides of the dice, and which numbers (highest or lowest) to be in the sum to be easily selectable. However, I can't guarantee this code free of errors in logic, so please comment if you see any. And, as always, I look forward to the comments of others, so we may each our wisdom increase.

#!/usr/bin/perl
use warnings;
use strict;

#Die Roller: uses 4d6 discarding the lowest number
#rerolling any roll of 1

my $roll = 6;
my @sums;

until ($roll == 0) {
    my @d6;
    chomp $roll;
    $roll--;
    $d6[0] = int(rand(6) + 1);
    $d6[1] = int(rand(6) + 1);
    $d6[2] = int(rand(6) + 1);
    $d6[3] = int(rand(6) + 1);
    @d6 = sort @d6;
    $d6[0] = int(rand(6) + 1); #reroll lowest number
    my $sum = $d6[0] + $d6[1] + $d6[2] + $d6[3];
    push(@sums, $sum);

    print "$d6[0], $d6[1], $d6[2], $d6[3] : $sum\n\n";
}

@sums = sort @sums;
my $three_highest = $sums[3] + $sums[4] + $sums[5]; #add three highest
+ numbers in array
print "total of three highest roles : $three_highest";
[download]

#!perl
use strict;
use warnings;

print roll_die(4, 6, 2, 3), "\n" for (0..5);

sub roll_die {
    my ($number, $sides, $min, $keep) = @_;

    # With arrays, 'x' operator will fill with that many elements
    my @rolls = ( 0 ) x $number;
    
    # For each die, roll better than number
    # In for's, $_ is automagically local'ed
    for (@rolls) {
        while ($_ < $min) { $_ = int(rand($sides) + 1 )}
    };
    
    # Now sort and select (Numerically, but in reverse order.)
    @rolls = sort {$b <=> $a} @rolls;
    splice @rolls, $keep;
    
    # And finally, return the value
    return eval(join('+', @rolls));
}
[download]