Question

I have a string of text chunked into phrases, with each phrase surrounded by square brackets:

[pX textX/labelX] [pY textY/labelY] [pZ textZ/labelZ] [textA/labelA]

Sometimes a chunk does not start with a p-character (like the last one above).

My problem is I need to capture each chunk. That’s okay under normal circumstances, but sometimes this input is mis-formatted, for example, some chunks might have only one bracket, or none. So it might look like this:

 [pX textX/labelX] pY textY/labelY] textZ/labelZ

But it ought to come out like this:

 [pX textX/labelX] [pY textY/labelY] [textZ/labelZ]

The problem does not include nested brackets. After diving into loads of different people’s regex solutions like never before (I’m new at regex), and downloading cheat-sheets and getting a Regex tool (Expresso) I still don’t know how to do this. Any ideas? Maybe regex doesn’t work. But how is this problem solved? I imagine it’s not a very unique problem.

Edit

Here is a specific example:

$data= "[VP sysmH/VBD_MS3] [PP ll#/IN_DET Axryn/NNS_MP] ,/PUNC w#hm/CC_PRP_MP3] [NP AEDA'/NN] ,/PUNC [PP b#/IN m$Arkp/NN_FS] [NP >HyAnA/NN] ./PUNC";

This is a great compact solution from @FailedDev:

while ($data =~ m/(?:\[[^[]*?\]|[^[ ].*?\]|\[[^[ ]*)/g) { # matched text = $& }

but I think two points need to be added for emphasis in the problem:

1. some chunks have no brackets at all
2. ,/PUNC and w#hm/CC_PRP_MP3] are separate chunks that need to be separated.

However, since this case is a fixed one (ie. a PUNCTUATION mark followed by a text/label pattern that has only one square bracket on the right), I kind of hard-coded it into the solution like this:

my @stuff;
while ($data =~ m/(?:\[[^[]*?\]|[^[ ].*?\]|\[[^[ ]*)/g) {
    if($& =~ m/(^[\S]\/PUNC )(.*\])/) # match a "./PUNC" mark followed by a "phrase]"
    {
        @bits = split(/ /,$&); # split by space
        push(@stuff, $bits[0]); # just grab the first chunk before space, a PUNC
        push(@stuff, substr($&, 7)); # after that space is the other chunk
    }
    else { push(@stuff, $&); } 
}
foreach(@stuff){ print $_; }

Trying the example I added in the edit, this works just fine except for one problem. The last ./PUNC gets left out, so the output is:

[VP sysmH/VBD_MS3]
[PP ll#/IN_DET Axryn/NNS_MP]
,/PUNC
w#hm/CC_PRP_MP3]
[NP AEDA'/NN]
,/PUNC
[PP b#/IN m/NN_FS]
[NP >HyAnA/NN]

How can I keep the last chunk?

Answer 1

You could use this

/(?:\[[^[]*?]|[^[ ].*?]|\[[^[ ]*)/

Assuming your string is something like :

[pX textX/labelX] pY textY/labelY]  pY textY/labelY]  pY textY/labelY]  [pY textY/labelY] [3940-823490-2 [30-94823049 [32904823498]

It will not work with this for example : pY [[[textY/labelY]

Perl specific solution :

while ($subject =~ m/(?:\[[^[]*?\]|[^[ ].*?\]|\[[^[ ]*)/g) {
    # matched text = $&
}

Update :

/(?:\[[^[]*?]|[^[ ].*?]|\[[^[ ]*|\s+[^[]+?(?:\s+|$))/

This works with your updated string, but you should trim the whitespace of the results, if you need to.

Update : 2

/(\[[^[]*?]|[^[ ].*?]|\[[^[ ]*|\s*[^[]+?(?:\s+|$))/

I suggest opening a different question, because your original question is totally different than the last one.

"
(                 # Match the regular expression below and capture its match into backreference number 1
                     # Match either the regular expression below (attempting the next alternative only if this one fails)
      \[                # Match the character “[” literally
      [^[]              # Match any character that is NOT a “[”
         *?                # Between zero and unlimited times, as few times as possible, expanding as needed (lazy)
      ]                 # Match the character “]” literally
   |                 # Or match regular expression number 2 below (attempting the next alternative only if this one fails)
      [^[ ]             # Match a single character NOT present in the list “[ ”
      .                 # Match any single character that is not a line break character
         *?                # Between zero and unlimited times, as few times as possible, expanding as needed (lazy)
      ]                 # Match the character “]” literally
   |                 # Or match regular expression number 3 below (attempting the next alternative only if this one fails)
      \[                # Match the character “[” literally
      [^[ ]             # Match a single character NOT present in the list “[ ”
         *                 # Between zero and unlimited times, as many times as possible, giving back as needed (greedy)
   |                 # Or match regular expression number 4 below (the entire group fails if this one fails to match)
      \s                # Match a single character that is a “whitespace character” (spaces, tabs, line breaks, etc.)
         *                 # Between zero and unlimited times, as many times as possible, giving back as needed (greedy)
      [^[]              # Match any character that is NOT a “[”
         +?                # Between one and unlimited times, as few times as possible, expanding as needed (lazy)
      (?:               # Match the regular expression below
                           # Match either the regular expression below (attempting the next alternative only if this one fails)
            \s                # Match a single character that is a “whitespace character” (spaces, tabs, line breaks, etc.)
               +                 # Between one and unlimited times, as many times as possible, giving back as needed (greedy)
         |                 # Or match regular expression number 2 below (the entire group fails if this one fails to match)
            $                 # Assert position at the end of the string (or before the line break at the end of the string, if any)
      )
)
"