C#
StringCollection resultList = new StringCollection();
Regex outerRegex = new Regex("<b>(.*?)</b>", RegexOptions.Singleline);
Regex innerRegex = new Regex(@"\d+");
// Odnajdujemy pogrubiony fragment.
Match outerMatch = outerRegex.Match(subjectString);
while (outerMatch.Success) {
    // Odnajdujemy dopasowania w ramach tego fragmentu.
    Match innerMatch = innerRegex.Match(outerMatch.Groups[1].Value);
    while (innerMatch.Success) {
        resultList.Add(innerMatch.Value);
        innerMatch = innerMatch.NextMatch();
    }
    // Odnajdujemy nastpny pogrubiony fragment.
    outerMatch = outerMatch.NextMatch();
}


VB.NET
Dim ResultList = New StringCollection
Dim OuterRegex As New Regex("<b>(.*?)</b>", RegexOptions.Singleline)
Dim InnerRegex As New Regex("\d+")
'Odnajdujemy pogrubiony fragment.
Dim OuterMatch = OuterRegex.Match(SubjectString)
While OuterMatch.Success
    'Odnajdujemy dopasowania w ramach tego fragmentu.
    Dim InnerMatch = InnerRegex.Match(OuterMatch.Groups(1).Value)
    While InnerMatch.Success
        ResultList.Add(InnerMatch.Value)
        InnerMatch = InnerMatch.NextMatch
    End While
    OuterMatch = OuterMatch.NextMatch
End While


Java
Iteracyjne przeszukiwanie z wykorzystaniem dwch obiektw dopasowujcych jest wyjtkowo proste (to rozwizanie mona stosowa w Javie 4 i nowszych):
List<String> resultList = new ArrayList<String>();
Pattern outerRegex = Pattern.compile("<b>(.*?)</b>", Pattern.DOTALL);
Pattern innerRegex = Pattern.compile("\\d+");
Matcher outerMatcher = outerRegex.matcher(subjectString);
while (outerMatcher.find()) {
    Matcher innerMatcher = innerRegex.matcher(outerMatcher.group());
    while (innerMatcher.find()) {
        resultList.add(innerMatcher.group());
    }
}

List<String> resultList = new ArrayList<String>();
Pattern outerRegex = Pattern.compile("<b>(.*?)</b>", Pattern.DOTALL);
Pattern innerRegex = Pattern.compile("\\d+");
Matcher outerMatcher = outerRegex.matcher(subjectString);
Matcher innerMatcher = innerRegex.matcher(subjectString);
while (outerMatcher.find()) {
    innerMatcher.region(outerMatcher.start(), outerMatcher.end());
    while (innerMatcher.find()) {
        resultList.add(innerMatcher.group());
    }
}


JavaScript
var result = [];
var outerRegex = /<b>([\s\S]*?)<\/b>/g;
var innerRegex = /\d+/g;
var outerMatch = null;
while (outerMatch = outerRegex.exec(subject)) {
    if (outerMatch.index == outerRegex.lastIndex)
        outerRegex.lastIndex++;
    var innerSubject = subject.substr(outerMatch.index,
                         outerMatch[0].length);
    var innerMatch = null;
    while (innerMatch = innerRegex.exec(innerSubject)) {
        if (innerMatch.index == innerRegex.lastIndex)
            innerRegex.lastIndex++;
        result.push(innerMatch[0]);
    }
}


PHP
$list = array();
preg_match_all('%<b>(.*?)</b>%s', $subject, $outermatches,
                 PREG_PATTERN_ORDER);
for ($i = 0; $i < count($outermatches[0]); $i++) {
    if (preg_match_all('/\d+/', $outermatches[0][$i], $innermatches,
                         PREG_PATTERN_ORDER)) {
        $list = array_merge($list, $innermatches[0]);
    }
}


Perl
while ($subject =~ m!<b>(.*?)</b>!gs) {
    push(@list, ($& =~ m/\d+/g));
}


Python
list = []
innerre = re.compile(r"\d+")
for outermatch in re.finditer("(?s)<b>(.*?)</b>", subject):
    list.extend(innerre.findall(outermatch.group(1)))


Ruby
list = []
subject.scan(/<b>(.*?)<\/b>/m) {|outergroups|
    list += outergroups[0].scan(/\d+/)
}
