No attempt a golf, but clear I think.

#! perl -sw
use strict;

while (<DATA>) {
    chomp;
    print sprintf('%-20s', $_),
        (/^[a-z][a-z-]+?[a-z]$/i and not /--/)
        ? ' is '
        : ' is not ',
        'a valid word according to the rules specified.', $/;
}

__DATA__
brian0
brian-
-brian
bri--an
Bria-n
br-i-an
brian
[download]

P.S. There's no need to put the whole question in the title:)

This will fail on valid edge cases words like 'Oh no I no go OK' as your minimum valid word length is 3 chars. A small bit of modification will cover all cases:

my @data = sort grep { /^[a-z][a-z-]*[a-z]$/i && ! /--/ || /^[a-z]$/i 
+} <DATA>;
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

I'm sure at least one of the solutions offered thus far works but I'm offering the following regex because it matches exactly what you want rather than trying to exclude things you don't want.

my @sorted = sort grep /^[a-z](?:[^-]|-(?!-))*(?<=[a-z])$/i, @words;
[download]

Here's the explanation:

/^[a-z]       # Start with a letter. 
 (?:          # Start grouping.
   [^-]         # Anything other than a hyphen
    |           # Or
   -(?!-)       # A hyphen not followed by another hyphen
 )*           # End group. Match 0 or more of those groups.  
 (?<=[a-z])$  # The end, as long as it is preceded by a letter.
/ix           # Match case insensitively and allow comments.
[download]

I almost posted this with a different regex:

/^[a-z](?:[^-]|-(?!-))*[a-z]$/i
[download]

-sauoq
"My two cents aren't worth a dime.";

Y%o*u a|\r/'e of co(ur)se t!ot^&a*lly co&^><,.rre~###Ct.

Much better:^)

---

Nah! You're thinking of Simon Templar, originally played (on UKTV) by Roger Moore and later by Ian Ogilvy

If you have them in an array, then all it would seem you would need to do would be:

1. filter out any words that didn't start with a letter (/^\w/)
2. take the above array, then filter for words not ending with a letter (/\w$/)
3. take the resultant array, and filter any words containing characters other than word characters (\w) or hyphen (! /\w(\w\-)+\w$/ maybe)
4. take resulting array, and filter out words containing hyphen 2 or more {2,} times (! /\-{2,}/ maybe).

I thought up about 6 lines of code to do each step, but thought the code (untested and untried) was not so good, so I removed it from being visible....

Update: Sounds like, if you're using grep or a match, you need to look at anchoring the match you're trying to find if it matches beginning with a hyphen by either doing /^\w/ to match beginning with a word character, or /^\-/ to match against a leading dash.

see, i'm new to this and i don't understand how to check if a word begins with a hyphen.. i've got my sort down to the point where it just keeps words with letters and hyphens. The making sure there's a letter, hyphen then letter is my problem.

 
@sorted = sort grep { /^[a-z].*[a-z]$/i and not /-{2,}/ } @orig
[download]

update: In case you want a case-folded sort (so that "amen" can be placed between "Amen" and "Amenable") add this block between the "sort" and "grep" above (this is copied from "perldoc -f sort"):

{uc($a) cmp uc($b)}
[download]

@newarray=sort grep /^[a-zA-Z]([a-zA-Z]*|-[a-zA-Z])*$/,@array;
[download]

this is my code, can i not do this? it doesn't seem to filter any words out when i do.

foreach $word (split){
   if($word =~ /^[a-zA-Z]([a-zA-Z]*|-[a-zA-Z])*$/){
           $count{$word};
}
[download]

}

Try $count{$word}=1;....

@out = sort grep !/^[^a-z]|[^a-z]\Z|--/i, @in;
[download]

use strict;

sub do_it_for_anonymous_monk {
    my @words = @_;
    my $word;
    my @results;
    foreach $word (@words) {
        if (($word =~ m/^[a-z|A-Z].*[a-z|A-Z]$/) && ($word !~ /--/)) {
             push @result, $word;
        }
    }
    return @results;
}

my @words = ("br-ian", "bri--an", "br-i-an", "brian", "brian0", "brian
+o", "2sdha");
do_it_for_anonymous_monk(@words);
[download]

This appears to work as requested, and it's a whole lot easier to read than some of the other options. :-)

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

my @words = qw( brian0 brian- -brian bri--an Bria-n br-i-an brian ) ;

print map { "[$_]" } @words ;
print "\n" ;

my @good = grep { 
                     /^[[:alpha:]]/ # Starts with a letter
                  && /[[:alpha:]]$/ # Ends with a letter
                  && ! /--/         # No consecutive hyphens
                } @words ;

print map { "[$_]" } @good ;
print "\n" ;
[download]

Those who know that they are profound strive for clarity. Those who
would like to seem profound to the crowd strive for obscurity.
            --Friedrich Nietzsche