Bdtjtk

I have simplify some latex math formula within text, for example

This is ${text{BaFe}}_{2}{text{As}}_{2}$ crystal

I want to transform this into

This is BaFe2As2 crystal

That is to concatenate only content within inner most bracket.

I figure out that I can use regex pattern

{[^{}]*}

to match those inner most bracket. But the problem is how to concatenate them together?

I don't know if this could be done in notepad++ regex replacement. If notepad++ is not capable, I can also accept perl one-liner solution.

There may clearly be multiple such equations (the markup between two $s) in the document. So while you need to assemble text between all {}, this also need be constrained within a $ pair. Then all such equations need be processed.

Matching that in a single pattern results in a rather complex regex. Instead, we can first extract everything within a pair of $s and then gather text within {}s from that, simplifying regex a lot. This makes two passes over each equation but a Latex document is small for computational purposes and the loss of efficiency can't be noticed.

use warnings;

use strict;

use feature 'say';



my $text = q(This is ${text{BaFe}}_{2}{text{As}}_{2}$ crystal,)

         . q( and ${text{Some}}{mathbf{More}}$ text);



my @results;



while ($text =~ /$(.*?)$/g) { 

    my $eq = $1; 

    push @results, join('', $eq =~ /{([^{}]+)}/g);

} 



say for @results;

This prints lines BaFe2As2 and SomeMore.

The regex in the while condition captures all chars between two $s. After the body of the loop executes and the condition is checked again, the regex continues searching the string from the position of the previous match. This is due to the "global" modifier /g in scalar context, here imposed on regex by the loop condition. Once there are no more matches the loop terminates.

In the body we match between {}, and again due to /g this is done for all {}s in the equation. Here, however, the regex is in the list context (as it is assigned to an array) and then /g makes it return all matches. They are joined into a string, which is added to the array.

In order to replace the processed equation, use this in a substitution instead

$text =~ s{ $(.*?)$ }{ join('', $1 =~ /{([^{}]+)}/g) }egx;

where the modifier e makes it so that the replacement part is evaluated as Perl code, and the result of that used to replace the matched part. Then in it we can run our regex to match content of all {} and join it into the string, as explained above. I use s{}{} delimiters, and x modifier so to be able to space things in the matching part as well.

Since the whole substitution has the g modifier the regex keeps going through $text, as long as there are equations to match, replacing them with what's evaluated in the replacement part.

I use a hard-coded string (extended) from the question, for an easy demo. In reality you'd read a file into a scalar variable ("slurp" it) and process that.

This relies on the question's premise that text of interest in an equation is cleanly between {}.

Missed the part that a one-liner is sought

perl -0777 -wnE'say join("", $1=~/{([^{}]+)}/g) while /$(.*?)$/g' file.tex

With -0777 the file is read whole ("slurped"), and as -n provides a loop over input lines it is in the $_ variable; the regex in the while condition works by default on $_. In each interation of while the contents of the captured equation, in $1, is directly matched for {}s.

Then to replace each equation and print out the whole processed file

perl -0777 -wne's{$(.*?)$}{join "", $1=~/{([^{}]+)}/g}eg; print' file.tex

where I've removed extra spaces and (unnecessary) parens on join.

Use this regex in Notepad++. I have tried to match everything which is NOT present between the innermost curly brackets and then replaced the match with a blank string.

[^{}]*{|}[^{}]*

Click for Demo

Explanation:

• 
  [^{}]*{ - matches 0+ occurrences of any character that is neither { nor } followed by {
  


• 
  | - OR


• 
  }[^{}]* - matches } followed by 0+ occurrences of any character that is neither { nor }
  

Before Replacement:

After Replacement:

UPDATE:

Try this updated regex:

$?(?=[^$]*$[^$]*$)(?:[^{}]*{|}[^{}]*)(?=[^$]*$[^$]*$)$?

Click for Demo