Regular expression for grep to extract lines with exact ocurrences of a symbol

Having a text data file containing SMILES strings like these:

CN1CCC2OC(C)(CO)C3=C(NN=C3)N=C12
BrC1=CC(=O)N2C=NC(CC(=O)C#N)=CC2=C1

how it would be a regular expression to extract the lines containing only 4 carbon atoms, meaning 4 Cs and no other capital letter, while numbers, parenthesis, = and # are allowed.

Update:

1. small C is also allowed, then 4 Cs or cs
2. grep -E '([^C]*C){4}' filename extracts lines with at least 4 Cs
3. square brackets, - and @ must be also discarded
4. check out some examples here

First thoughts

I thought about my suggestions in the comments, using some negative
lookaheads and lookbehinds, but it's often not handled by some regex engines.

So we'll forget C(?![laroudsnemf])|(?<![STMA])c which was used to
match carbon with a lowercase version for rings. It would have worked
with grep -P to enable the PCRE engine, but I prefer avoiding it.

But this can be replaced by setting up a pattern that will consume
the other elements in the same time as the ignored characters:

• According to
  Wikipedia's page about SMILES,
  the ignored chars list is quite big, leading to "-", "+", ".", "=",
  "#", "$", "@", "(", ")", "[", "]", "/", "\", ":", "%". We finally
  get this pattern : [-+.=#$@()\[\]\/\\:%0-9]
• All 2-chars elements starting with a "C": C[laroudsnemf]
• All 2-chars elements finishing with a "c": [STMA]c
• Any single-char element but not "C": [HBNOFPSKVYIWU]
• Any other 2-chars element without "C" or "c": [ABD-Z][abd-z]
  Here we are clearly not very precise, as some combinations of
  upper and lowercase chars won't be existing elements. Never mind,
  it should not be a problem.

Edit: thanks to the comment of @David542, he saw that "Sc"
wasn't detected as the scandium element, but "S" was taken for
sulphur and then "c" as the carbon (in a ring). To solve that, I
finally forced the pattern to be possessive (greedy) by replacing
the * by *+.

Setting up the pattern

• I'll use the x flag in order to add some comments in the
  pattern.
• I don't want to copy-paste or repeat patterns, so I'll use
  sub-patterns which I will name, in order to make things clear.
  This can be done with the help of named capturing groups
  (?<group_name>...) where ... is your pattern.
• In PCRE, you can use the (?(DEFINE)...) construct to declare
  sub-patterns without using them. It's like creating functions for
  a later use.

Putting it all together:

/
(?(DEFINE)

  # Match a carbon atom only. It can be a uppercase "C" or lowercase
  # "c" (for rings). We'll avoid negative lookahead and lookbehind and
  # instead let the "ignored" pattern consume these other elements.
  (?<carbon>[cC])

  # Ignored other elements and syntax chars.
  # This pattern should be greedy with *+ instead of *. This will make
  # the pattern consume "Sc" or "Tc" so that we cannot match the "c"
  # as a carbon atom. This solution is to avoid using negative lookbehind
  # and lookahead inside the carbon sub-pattern just above.
  (?<ignored>
    (?:                  # Non-capturing just for the "or" operator.
      [-+.=\#$@()\[\]\/\\:%0-9] # ignored chars.
      |
      C[laroudsnemf]     # Cx Elements: Cl, Ca, Cr, Co, Cu, etc
      |
      [STMA]c            # Xc Elements: Sc, Tc, Mc and Ac
      |
      [HBNOFPSKVYIWU]    # Any single-letter element, but not C.
      |
      [ABD-Z][abd-z]     # 2-chars Elements (not very precise but short)
    )*+                  # The ignored items can be 0 or n times, in a possessive way.
  )

)

# The pattern is carbon surounded by ignored elements and chars, 4 times.
^(?:\g<ignored>\g<carbon>\g<ignored>){4}$

/gmx

In action: https://regex101.com/r/88zReK/4

If you need to remove the comments to use it with grep, here's the
compressed version where backslashes have to be escaped to create
a correct string to pass to grep:

grep -P "(?(DEFINE)(?<carbon>[cC])(?<ignored>(?:[-+.=#$@()\\[\\]/\\\\:%0-9]|C[laroudsnemf]|[STMA]c|[HBNOFPSKVYIWU]|[ABD-Z][abd-z])*+))^(?:\\g<ignored>\\g<carbon>\\g<ignored>){4}$"

If you need to reproduce the compact pattern again, you can
use a tool I made for my personal use on codepen.io.

EDIT: wrong final thoughts and POC to solve also the meaning of digits

<del>Personally, I would not ignore numbers as "CH2" means two
hydrogen atoms, so why not trying to handle something like
"C4"&nbsp;? I don't even know if this is possible or not, but I
think it's worth trying to handle it.</del>

This was a wrong assumption! Numbers after "C" are not the
number of atoms like it's the case for "H2". It's the label of the
ring. So the PHP code below to replace "C4" by "CCCC" is totally
worthless. I'll just leave it here because it might be helpful for
other users having to process some data with a bit more power than
the simple usage of grep&nbsp;:

<?php

const INPUT_FILE = 'smiles_input.txt';

// Read all the file in one go into an array of lines. If the file is too large,
// you'll have to open it and read it line by line to avoid running out of memory.
// We will also get rid of attached new line chars at the end of each line.
$input_lines = file(INPUT_FILE, FILE_IGNORE_NEW_LINES);

// A pattern to match only carbon elements, in upper or lowercase, followed by
// a number. We use negative lookbehind and lookahead to avoid matching other
// elements containing the letter "C" or "c".
const PATTERN_C_AND_NUMBER = '/(?<carbon>C(?![laroudsnemf])|(?<![STMA])c)(?<number>\d+)/';

// The pattern to match a molecule containing 4 carbon elements.
// I use Nowdoc string format to avoid having to escape everything.
const PATTERN_4_C_MOLECULE = <<<'END_OF_STRING'
/
(?(DEFINE)

  # Match a carbon atom only. It can be a uppercase "C" or lowercase
  # "c" (for rings). We'll avoid negative lookahead and lookbehind and
  # instead let the "ignored" pattern consume these other elements.
  (?<carbon>[cC])

  # Ignored other elements and syntax chars.
  # This pattern should be greedy with *+ instead of *. This will make
  # the pattern consume "Sc" or "Tc" so that we cannot match the "c"
  # as a carbon atom. This solution is to avoid using negative lookbehind
  # and lookahead inside the carbon sub-pattern just above.
  (?<ignored>
    (?:                  # Non-capturing just for the "or" operator.
      [-+.=\#$@()\[\]\/\\:%0-9] # ignored chars.
      |
      C[laroudsnemf]     # Cx Elements: Cl, Ca, Cr, Co, Cu, etc
      |
      [STMA]c            # Xc Elements: Sc, Tc, Mc and Ac
      |
      [HBNOFPSKVYIWU]    # Any single-letter element, but not C.
      |
      [ABD-Z][abd-z]     # 2-chars Elements (not very precise but short)
    )*+                  # The ignored items can be 0 or n times, in a greedy way.
  )

)

# The pattern is carbon surounded by ignored elements and chars, 4 times.
^(?:\g<ignored>\g<carbon>\g<ignored>){4}$

/x
END_OF_STRING;

foreach ($input_lines as $line_nbr => $molecula) {
	// Replace all occurrences of C followed by a number, by the C char repeated
	// the correct number of times. Ex: "C4" will be replaced by "CCCC".
	$changed_molecula = preg_replace_callback(
		PATTERN_C_AND_NUMBER,
		function ($matches) {
			return str_repeat($matches['carbon'], (int)$matches['number']);
		},
		$molecula
	);
	
	// Check if the molecula has only 4 carbon elements.
	if (preg_match(PATTERN_4_C_MOLECULE, $changed_molecula)) {
		print ($line_nbr + 1) . ": " . $molecula . PHP_EOL;
	}
}

Run it here: https://onlinephp.io/c/6f062

There is a discrepancy within your constraints.

> "4 Cs and no other capital letter ..."

Yet, the provided regex101.com examples all include additional capital letters&mdash;so, none of those will match.

The following will match when there are no other capital letters.

If you're looking to match, exactly 4

(?i)^(?:[^C]*C){4}[^C]*$

If you're looking to match, at least, 4, use the following.

(?i)^(?:[^C]*C){4,}[^C]*$

And, if you're looking to match, at most, 4, use this

(?i)^(?:[^C]*C){1,4}[^C]*$

This is such a wonderful question and reminds me of taking chemistry classes in high school. This is trickier than it seems. Conceptually, here is what we want to do:

• We want to capture: a C that is not followed by a lowercase letter. This must be captured exactly 4 times.
• And we want to skip any (a) numbers, (b) the punctuation #, =, (, and ), (c) any uppercase letter except C (such as F), (d) Any uppercase letter followed by one or more lowercase letters (such as Ca or Fe).

If we convert it into a regex we have:

• Capture: (C(?![a-z]))
• Skip: [#=()\dABD-Z]|[A-Z][a-z]

Putting it all together with anchors and repetitions we get the following.

• ^(?:[#=()\dABD-Z]|[A-Z][a-z])*(C(?![a-z]))(?:[#=()\dABD-Z]|[A-Z][a-z])*\1(?:[#=()\dABD-Z]|[A-Z][a-z])*\1(?:[#=()\dABD-Z]|[A-Z][a-z])*\1(?:[#=()\dABD-Z]|[A-Z][a-z])*$

Obviously there's a lot of copy-paste here, and other than using \1 to repeat the C, I don't see a way to simplify this regex too much more in a non-trivial sense.

Updated with the following changes you asked for in the Skip condition: [, ], -, and @ allowed.

• ^(?:[#=()[\]\dABD-Z@-]|[A-Z][a-z])*(C(?![a-z]))(?:[#=()[\]\dABD-Z@-]|[A-Z][a-z])*\1(?:[#=()[\]\dABD-Z@-]|[A-Z][a-z])*\1(?:[#=()[\]\dABD-Z@-]|[A-Z][a-z])*\1(?:[#=()[\]\dABD-Z@-]|[A-Z][a-z])*$

And updated with the simplification suggested by @Patrick (thank you!) to use \g for the captured pattern. Note this pattern does not address: (a) lowercase-C for carbon; or (b) multipliers in atoms, such as C4 to mean CCCC:

• ^((?<ignored>(?:[#=()[\]\dABD-Z@-]|[A-Z][a-z])*)(?<carbon>C(?![a-z]))){4}\g<ignored>$