Matching line without and with lower-case letters

I want to match two consecutive lines, with the first line having no lower-case letter and the second having lower-case letter(s), e.g.

("3.2 A MEMORY ABSTRACTION: ADDRESS SPACES 177" "#205")
("3.3.1 Paging 187" "#215")

Why would the Regex ^(?!.*[:lower:]).*$\n^(.*[:lower:]).*$ match each of the following two-line examples?

("1.3.3 Disks 24" "#52")
("1.3.4 Tapes 25" "#53")

("1.5.4 Input/Output 41" "#69")
("1.5.5 Protection 42" "#70")

("3.1 NO MEMORY ABSTRACTION 174" "#202")
("3.2 A MEMORY ABSTRACTION: ADDRESS SPACES 177" "#205")

("3.3.1 Paging 187" "#215")
("3.3.2 Page Tables 191" "#219")

Thanks and regards!

ADDED:

For a example such as:

("3.1 NO MEMORY ABSTRACTION 174" "#202")
("3.2 A MEMORY ABSTRACTION: ADDRESS SPACES 1开发者_Go百科77" "#205")
("3.3.1 Paging 187" "#215")
("3.3.2 Page Tables 191" "#219")

How shall I match only the middle two lines not the first three lines or all the four lines?

To use a POSIX "character class" like [:lower:], you have to enclose it in another set of square brackets, like this: [[:lower:]]. (According to POSIX, the outer set of brackets form a bracket expression and [:lower:] is a character class, but to everyone else the outer brackets define a character class and the inner [:lower:] is obsolete.)

Another problem with your regex is that the first part is not required to consume any characters; everything is optional. That means your match can start on the blank line, and I don't think you want that. Changing the second .* to .+ fixes that, but it's just a quick patch.

This regex seems to match your specification:

^(?!.*[[:lower:]]).+\n(?=.*[[:lower:]]).*$

But I'm a little puzzled, because there's nothing in your sample data that matches. Is there supposed to be?

Using Rubular, we can see what's matched by your initial expression, and then, by adding a few excess capturing groups, see why it matches.

Essentially, the negative look-ahead followed by .* will match anything. If you merely want to check that the first line has no lower-case letters, check that explicitly, e.g.

^(?:[^a-z]+)$

Finally, I'd assuming you want the entire second line, you can do this for the second part:

^(.*?(?=[:lower:]).*?)$

Or to match your inital version:

^(.*?(?=[:lower:])).*?$

The reluctant qualifiers (*?) seemed to be necessary to avoid matching across lines.

The final version I ended up with, thus, is:

^(?:[^a-z]+)$\n^(.*?(?=[:lower:]).*?)$

This can be seen in action with your test data here. It only captures the line ("3.2 A MEMORY ABSTRACTION: ADDRESS SPACES 177" "#205").

Obviously, the regex I've used might be quite specific to Ruby, so testing with your regex engine may be somewhat different. There are many easily Google-able online regex tests, I just picked on Rubular since it does a wonderful job of highlighting what is being matched.

Incidentally, if you're using Python, the Python Regex Tool is very helpful for online testing of Python regexes (and it works with the final version I gave above), though I find the output visually less helpful in trouble-shooting.

After thinking about it a little more, Alan Moore's point about [[:lower:]] is spot on, as is his point about how the data would match. Looking back at what I wrote, I got a little too involved in breaking-down the regex and missed something about the problem as described. If you modify the regex I gave above to:

^(?:[^[:lower:]]+)$\n^(.*?(?=[[:lower:]]).*?)$

It matches only the line ("3.3.1 Paging 187" "#215"), which is the only line with lowercase letters following a line with no lowercase letters, as can be seen here. Placing a capturing group in Alan's expression, yielding ^(?!.*[[:lower:]]).+\n((?=.*[[:lower:]]).*)$ likewise captures the same text, though what, exactly, is matched is different.

I still don't have a good solution for matching multiple lines.