This works pretty well so far. But if there other round brackets between this outer brackets, it doesnt find the correct closing bracket this way:

Yes you have to count opening and closing if you need to walk through the string using one loop. You may not have to, you likely have other options.

The speedy simple way for you to do is this: scan the string with a SHORT loop (the inside of the loop has the least number of operations) to find the first (. scan the loop again to find the last. that's all! in ASM language you'd search for the last using reverse direction cpu instruction. an alternate way is to regex the first, regex the last, then analyze the intersection of the matches (worst way?). If "moderately fast" is ok, you can use Position[] or Cases[] and simply take the first and last positions found of each of {), which i think the first responder to the post was trying to suggest.

With a parser you could match () as un-ambiguously parsed expressions (underline un-ambiguous). You have to study parsers to understand what that means: if you don't - you'll end up with code that makes mistakes you handn't imagined were possible. You can consider Position and Cases as un-ambiguous parsers but that their ability to match patterns is limited (they are specialized for matching parsed expressions - which if you learn to use them is good enough for much general parsing work).

Juerg,

First, there is a bug in my code -- I needed to add an "UpTo[]" in the stringTake to handle edge conditions:

findOption4[text_String, option_String] := 
 Module[{possible, opencnt, closecnt, cutoff, 
   subtext = 
    StringDrop[text, StringPosition[text, option ~~ "{"][[1, 2]]]}, 
  cutoff = 100; 
  possible = 
   StringCases[StringTake[subtext, UpTo[cutoff]], 
    StartOfString ~~ x___ ~~ "}" -> x, Overlaps -> All]; 
  opencnt = StringCount[possible, "{"] - StringCount[possible, "\{"];
  closecnt = 
   StringCount[possible, "}"] - StringCount[possible, "\}"];
  option <> "{" <> 
   possible[[Position[opencnt - closecnt, 0][[-1, 1]]]] <> "}"]

The timing test is not representative because the data is always the same and the result is only 4 characters. To generate a random test data set we can do something like this (and check to delete any lines that are too long for the functions)

randTexts = Table["dummy{" <>  StringJoin[Table["{" <> RandomWord[] <> "}", RandomInteger[{1, 10}]]] <>  "}", 1000];
nrandTexts = DeleteCases[randTexts, x_ /; StringLength[x] > 105];
longtexts = Map[
   FromCharacterCode[
      RandomInteger[{97, 122}, RandomInteger[{20, 200}]]] <> # <> 
     FromCharacterCode[
      RandomInteger[{97, 122}, RandomInteger[{20, 200}]]] &, 
   nrandTexts];

As an aside, I tried this with RandomWord[Language->"German"] but only 65% of the strings were short enough to use-- German uses many characters!

Generating the random words takes a long time because it uses the internet but now we can time things

In[100]:= Timing[findOption5[#, "dummy"] & /@ longtexts;]

Out[100]= {0.186421, Null}
In[101]:= Timing[findOption4[#, "dummy"] & /@ longtexts;]

Out[101]= {0.053151, Null}

Certainly you have more control processing strings character by character. At first glance most people would expect your code to be faster because it handles far fewer characters than my code does. The takeaway is that MMA is very inefficient at looping. If you could compile your function (MMA does not compile functions with string arguments) I would expect it to be much faster. (as an exercise you might want to turn your strings into character codes and process the strings as integers and compile the function -- I expect that would be VERY fast.)

This was an interesting example.

Regards,

Neil

Juerg,

Generally, it is better to avoid looping-- there is almost always a list-based approach that is faster. I was not aware that the text strings would be very large. I assumed that since the options are repeating over and over that you would be breaking up the file somehow before running this code snippet. In the case that you are looking for only one option in a large file, the looping code may be a better way.

However, If you can safely assume that there will never be more than 5 or 10 or 15 close brackets in a single option (which seems safe -- or alternatively limit the number of characters in an option), you could modify my list-based routine by cutting the search off at a maximum of, say in this example, 10 brackets. By doing this you would get a significant speedup over the looping code.

Here is a version that only looks 10-deep and runs about 4 times faster than the looping version (I read in your file as text):

findOption3[text_String, option_String] := 
 Module[{possible, opencnt, closecnt, cutoff, 
   subtext = StringDrop[text, StringPosition[text, option ~~ "{"][[1, 2]]]}, 
  cutoff = Last[ StringPosition[subtext, "}", 10]][[1]]; 
  possible = StringCases[StringTake[subtext, cutoff], StartOfString ~~ x___ ~~ "}" -> x, Overlaps -> All]; 
  opencnt = StringCount[possible, "{"] - StringCount[possible, "\{"];
  closecnt =  StringCount[possible, "}"] - StringCount[possible, "\}"];
  option <> "{" <>  possible[[Position[opencnt - closecnt, 0][[-1, 1]]]] <> "}"]

In[30]:= Timing[findOption[text, "\\def\\opa"];]

Out[30]= {0.0056, Null}

In[31]:= Timing[findOption3[text, "\\def\\opa"];]

Out[31]= {0.00156, Null}

Here is a version that allows only 100 characters in an option -- it runs even faster

findOption4[text_String, option_String] := 
 Module[{possible, opencnt, closecnt, cutoff, 
   subtext =  StringDrop[text, StringPosition[text, option ~~ "{"][[1, 2]]]}, 
  cutoff = 100; 
  possible = StringCases[StringTake[subtext, cutoff], StartOfString ~~ x___ ~~ "}" -> x, Overlaps -> All]; 
  opencnt = StringCount[possible, "{"] - StringCount[possible, "\{"];
  closecnt = StringCount[possible, "}"] - StringCount[possible, "\}"];
  option <> "{" <> possible[[Position[opencnt - closecnt, 0][[-1, 1]]]] <> "}"]

In[38]:= Timing[findOption4[text, "\\def\\opa"];]

Out[38]= {0.001267, Null}

Juerg,

It appears that you are parsing LaTeX so I think your code breaks if the square "]" is a "}" or if the Typesetting only has an opening "{" and no closing one.

I think this code should do what you want and ignore typeset "{" or "}" marks. -- and I think it is a bit easier to understand.

findOption2[text_String, option_String] := 
 Module[{possible, opencnt, closecnt}, 
  possible = StringCases[text, option ~~ "{" ~~ x___ ~~ "}" -> x,  Overlaps -> All]; 
  opencnt = StringCount[possible, "{"] - StringCount[possible, "\{"];
  closecnt =  StringCount[possible, "}"] - StringCount[possible, "\}"];
  option <> "{" <>  possible[[Position[opencnt - closecnt, 0][[-1, 1]]]] <> "}"]

The code above avoids looping (looping is generally not "Mathematica Friendly"). I first get all possible close "}" strings for the option. Next I count the open "{" characters and remove any typeset ones "{". Next I count the close "}" characters and remove any typeset ones "}". Lastly I find the strings that have equal number of open "{" and close "}". I take the shortest string among the ones that match open/close brackets to get the option value.

It relies on a subtle behavior of MMA which is that an Overlapping StringCases seems to put the largest strings first. If this is not always true than the code would have to change a bit to find the element in the list that is 0 with the smallest corresponding value in opencnt.

Regards,

Neil