Removing a double brackets

Question

Its pretty basic, I have some data in the form : (xxxxx) . To remove the brackets I do :

long len = strlen(data);
for (int  i = 0; i < len - 2; ++i )
    data[i] = data[i + 1];
data[len - 2] = '\0';

Which works. I would like to also take care of another case which is ((xxxxxx)) , and removing the double "((" at start and end . (and not removing the middle occurrence ) .

Assuming that for every (( , there is also )) at the end.

Is there a simple way to modify this code(or another code) to do that with high efficiency ?

EDIT: It is a data parsing, where there are 3 options :

xxxxxx, (xxxxx), ((xxxxx)

Usually I check if the first character is "(" , and apply this function, Now I need that function to also make sure there is not another "(", and if there is , to remove it automatically for me. I can not apply the function twice because If I have only 1 "(" I will loose data.

Answer 1

Assuming your data is always longer than 3 chars...maybe something like this?

long len = strlen(data);
int ini = 0, end = 0;
// you know it starts with parenthesis
if ( data[0] == '(') {
    // check if it has double parenthesis at the beginning
    if ( data[1] == '(') {
        ini = 2;
        end = len - 2;
    }
    else {
        // It had only one parenthesis
        ini = 1;
        end = len -1;
    }
    // replace the data you need
    int  i = 0;
    for ( ; ini < end; ++i, ini++ )
        data[i] = data[ini];
    // "close" the "string"
    data[i] = '\0';
}

EDIT: Thanks chqrlie, missed that part

Answer 2

Assuming this is only for parens at the start and end of the string...

• Stop if there's less than two characters.
• Check for balanced parens.
  • Nudge the string in at both ends.
  • Recurse.

char *strip_parens(char *string) {
    size_t len = strlen(string);
    if( len < 2 ) {
        return string;
    }

    char start = string[0];
    char end   = string[len-1];

    if( start == '(' && end == ')' ) {
        string[len-1] = '\0';
        string += 1;

        return strip_parens(string);
    }
    else {
        return string;
    }
}

This avoids having to copy the whole string, but the original pointer has to be retained for deallocation else it will leak memory. This is most useful when the string is large and the stripped version is only for temporary use.

char *stripped = strip_parens(string);

/* do something with stripped */

free(string);  /* not stripped */

Alternatively you can put them both into a struct and manage the struct.

Anything more complicated and you should look into using regular expressions or a grammar.

Answer 3

Look at the beginning and at the end of the string for a pair of (). Keep looking until a pair is not found. (or limit to 2 matches if desired)

Efficiency: 1 run down the string to finds its length, 1 call to shift the interior of the string. O(n)

char *C_RemoveOuterBrackets(char *data) {
  char *src = data;
  size_t len = strlen(src);
  // Matching pair of () found
  while (src[0] == '(' && src[len - 1] == ')') {
    src++;
    len -= 2;
  }
  memmove(data, src, len);
  data[len] = '\0';
  return data;
}

Handles "(())", "" and does not need to assume the ends are matched (extra parens remain).

Answer 4

You could have a function to count the parenthesis. So it will give a desired (I guess) answer for even more parenthesis.

int countPar(char *s)
{
    int num = 0, i;
    for(i = 0; (i < strlen(s)) && (s[i] == '('); i++)
        num++;
    return num;
}

Then you just do the following

num = countPar(data)
for (int  i = 0; i < strlen(data) - 2 * num; ++i )
    data[i] = data[i + num];
data[len - 2 * num] = '\0';

feel free to correct me, I did not actually try it, just counted.

Answer 5

According to EOF comment :

void strip()
{

long len = strlen(data);
for (int  i = 0; i < len - 2; ++i )
    data[i] = data[i + 1];
data[len - 2] = '\0';

//RECURSIVE
if( data[0] == '(' )
 strip();


}

Answer 6

Here's the most elegant way (I can think of right now) to do so:

int
main()
{
  char *data = strdup("((hello))");
  char *whead, *wtail;
  size_t len;

  len = strlen(data);
  whead = data;
  wtail = data + len - 1;
  while (*whead == '(' && *wtail == ')')
    {
      *wtail = '\0';
      whead++;
      wtail--;
      len--;
    }
  memmove(data, whead, len + 1);
  printf("%s\n", data);
  return (0);
}

If you're sure you have at least as many closing parentheses as you have opening ones, you can go with the following code:

int
main()
{
  char *data = strdup("((hello))");
  size_t i;
  size_t len;

  len = strlen(data);
  for (i = 0; data[i] == '('; i++)
    ;
  memmove(data, data + i, len - (i * 2));
  data[len - (i * 2)] = '\0';
  printf("%s\n", data);
  return (0);
}