Just for fun:

use strict;
use warnings;

my $raw = join '-', 1 .. 30;
my @ranges = ([5, 10], [14, 18], [22, 27]);

$raw =~ s/(\d+)/(grep {$1 >= $_->[0] && $1 <= $_->[1]} @ranges) ? 'X' 
+: $1/eg;

my @parts = split /((?:-X)+-)/, $raw;
my $sub = 'A';

for my $part (@parts) {
    next if $part =~ /X/;
    $part =~ s/\d+/$sub/g;
    $sub = 'A' if ++$sub eq 'C';
}

print join('', @parts), "\n";
[download]

Prints:

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

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

my @ranges = ('5-10', '14-18', '22-27');
my $in     = '1-2-3-4-5-6-7-8-9-10-11-12-13-14-15-16-17-18-19-20-21-22
+-23-24-25-26-27-28-29-30';
my $exp    = 'A-A-A-A-X-X-X-X-X-X-B-B-B-X-X-X-X-X-A-A-A-X-X-X-X-X-X-B-
+B-B';

use Test::More tests => 1;

my $replace = 'A';
my $out     = $in;
my $in_range;

while ($in =~ /([0-9]+)/g) {
    my $i = $1;
    if (! $in_range && grep /^$i-/, @ranges) {
        $in_range = 1;
    }
    $out =~ s/[0-9]+/$in_range ? 'X' : $replace/e;
    if ($in_range && grep /-$i$/, @ranges) {
        undef $in_range;
        $replace = $replace eq 'A' ? 'B' : 'A';
    }
}

is $out, $exp;
[download]

Thank you @choroba, this works excellent! Much appreciated!!

That's a nice problem. :) You may also want to show the code you've used to solve the first part of the problem, since I'm sure the Monks would relish the opportunity to see if they can come up with better/faster/cleaner solutions to that.

For the second part, my approach would be to model it as a state machine. There are two states: state 0 "we're looking at a section of numbers", and state 1 "we're looking at a section of X's". In state 0 we want to replace the number with the appropriate letter A or B; in state 1 we want to leave the X as X; and at one of the transitions - I've chosen the "up" transition from state 0 to state 1 - we want to flip the letter we will replace with between A and B:

# transition:      -up-       -down-   -up-      -down-   -up-        
+-down-
# state:     0 0 0 0 1 1 1 1 1 1 0  0  0  1 1 1 1 1 0  0  0  1 1 1 1 1
+ 1 0  0
my $input = "1-2-3-4-X-X-X-X-X-X-11-12-13-X-X-X-X-X-19-20-21-X-X-X-X-X
+-X-28-29";
my $output = part2($input);
print "$output\n";

sub part2 {
  my($input) = @_;
  my $state = 1;
  my @replace = ("A", "B");
  my $replace_index = 0;  # start at 'A'

  $input =~ s{
    ( \d+ | X ) (?# match a number or X)
    (?= - | \z) (?# followed by '-' or end of string)
  }{
    # capture the old state, to detect transitions
    my $prev_state = $state;

    # decide the new state
    $state = ($1 eq 'X') ? 1 : 0;

    if ($state == 0) {
      # state 0: return the replacement character
      $replace[$replace_index];
    } else {
      # state 1: did we transition?
      if ($prev_state == 0) {
        # flip the replacement character between 'A' and 'B'
        $replace_index = 1 - $replace_index;
      }
      # return the matched value, ie don't change anything
      $1;
    }
  }exg;
  return $input;
}
[download]

Note that I initialize the state machine to be in state 1, so that if the input starts with a section of Xs we will still use "A" as the first replacement character - "X-2" will be translated to "X-A". If I had started in state 0, the initial X would be seen as a transition so we would immediately flip the replacement character to be B, and "X-2" would be translated to "X-B". (This is also the reason I chose to flip on the 0-to-1 transition rather than on the 1-to-0 transition.) If you would rather have "X-2" become "X-B", then just change the initial state to be 0.

#!/usr/bin/perl

use strict; # https://perlmonks.org/?node_id=11147549
use warnings;

my $ranges = '5-10,14-18,22-27';
my $replace = 'B';
my $in = join '-', 1 .. 30;
my $want = 'A-A-A-A-X-X-X-X-X-X-B-B-B-X-X-X-X-X-A-A-A-X-X-X-X-X-X-B-B-
+B';

my %X = map { $_ => 'X' } map { /-/ and $` .. $' } split /,/, $ranges;
my $out = $in =~ s!\d+! $X{$&} // $& !ger =~
  s/[-0-9]{2,}/ $replace ^= 'A'^'B'; $& =~ s|\d+|$replace|gr /ger;

print "ranges $ranges\n   out $out\n  want $want\n";
$out eq $want or die "**Mismatch**";
[download]

Outputs:

ranges 5-10,14-18,22-27
   out A-A-A-A-X-X-X-X-X-X-B-B-B-X-X-X-X-X-A-A-A-X-X-X-X-X-X-B-B-B
  want A-A-A-A-X-X-X-X-X-X-B-B-B-X-X-X-X-X-A-A-A-X-X-X-X-X-X-B-B-B
[download]