how do I shorten strings by removing pairs of identical letters correctly?

I am trying to build a program where it should be given a string of lowercase letters and will search for pairs of identical letters closest to the start and end of the string and remove them.

So for example helloworld the first and last 'l' would be removed, and the 'o' would be removed. The final output would be "helwrd".

here is what I coded so far:

string[] testdata = { "helloworld" };
//string[] testdata = { "aaa" };
//string[] testdata = { "abaccbaabbaabcc" };
//string[] testdata = { "pepperonipizza" };
//string[] testdata = { "thequickbrownfoxjumpedoverthelazydog" };
string data = "helloworld";
foreach (string test in testdata)
{
   
        for (int i = 0; i < data.Length - 1; i++)
        {
            /*if (data[i] == data[i + 1])
            {
                data = data.Remove(i, 2);
                
            */
            for(int di = data.Length - 1; di != i; di--)
        {
            if (data[i] == data[di])
            {
                data = data.Remove(di, 1);
                data = data.Remove(i, 1);
                i = 0;
                
                break;
            }
        }
        }
Console.WriteLine(data);
}

The problem I am facing

For other phrases such as "pepperonipizza" the final result should be rona but it comes up with eerona.

The same problem is present with "thequickbrownfoxjumpedoverthelazydog" the final result should be qickbwnfxjmpvlazyg but it comes up with hqickbwnfxjmpvhlazyg.

I looked at the Watch window whilst debugging and the last identical letters won't delete. so the final result in the watch debugger and the terminal will be eerona and hqickbwnfxjmpvhlazyg.

Argument                             : Expected           : Actual
----------------------------------------------------------------------
helloworld                           : helwrd             :
aaa                                  : a                  :
abaccbaabbaabcc                      : b                  :
pepperonipizza                       : rona               : eerona
thequickbrownfoxjumpedoverthelazydog : qickbwnfxjmpvlazyg : hqickbwnfxjmpvhlazyg

Try this:

    string data = "pepperonipizza";
    foreach (string test in testdata)
    {
        for (int i = 0; i < data.Length - 1; i++)
        {
            for (int j = data.Length - 1; j > i; j--)
            {
                if (data[i] == data[j])
                {
                    data = data.Remove(j, 1);
                    data = data.Remove(i, 1);
                    i--;
                    break;
                }
            }
        }
        Console.WriteLine(data);
        Console.In.Read();
    }

If you have a long text you may want a linear time algorithm - O(n) without nested loops. The approach is not that complex:

1. Compute frequency of each symbol (freq) and let counts be count of each symbol
2. Then we scan text, letter after letter.
3. If frequency of letter is even, drop it
4. If frequency of letter is odd, keep just one of it, that has (freq[letter] + 1) / 2 count

Code (Fiddle):

using System.Linq;
using System.Collections.Generic;

...

private static string MySolution(string text) {
  var freqs = text
    .GroupBy(item => item)
    .ToDictionary(group => group.Key, group => group.Count());

  var counts = freqs
    .ToDictionary(pair => pair.Key, pair => pair.Value);

  var sb = new StringBuilder(26);

  foreach (char letter in text)
    if (freqs[letter] % 2 != 0 && freqs[letter] == (counts[letter] -= 1) * 2 + 1)
      sb.Append(letter);

  return sb.ToString();
}

Time Complexity: O(n)

Space Complexity: O(1)

Let's have a look:

string[] tests = new string[] {
  "helloworld",
  "aaa",
  "abaccbaabbaabcc",
  "pepperonipizza",
  "thequickbrownfoxjumpedoverthelazydog",
};
	  
var result = string.Join(Environment.NewLine, tests
  .Select(test => $"{test,50} :: {MySolution(test)}"));  
	  
Console.WriteLine(result);  

Output:

                                        helloworld :: helwrd
                                               aaa :: a
                                   abaccbaabbaabcc :: b
                                    pepperonipizza :: rona
              thequickbrownfoxjumpedoverthelazydog :: qickbwnfxjmpvlazyg

Stress test:

Random random = new Random(1234);

// String with million random characters
string text = string.Concat(Enumerable
  .Range(0, 1_000_000)
  .Select(_ => (char)('a' + random.Next(26))));
 
string result = MySolution(text);

Console.WriteLine(result);

Outcome (after fraction of second):

tljszwafhn

A simple solution is to iterate from the beginning of the string, if the number of a character is even, it will be removed. If it is odd, we find the middle index and store it in a list. Finally, we join the list:

string input = "pepperonipizza";
string[] chars = new string[input.Length];
for(int i=0;i< input.Length;i++)
{
   int count= input.Count(c => c == input[i]);
    if (count % 2 == 1)
    {
        var indexes =input.Select((b, ind) => b.Equals(input[i]) ? ind : -1).Where(ind => ind != -1).ToList();
        chars[indexes[indexes.Count / 2]] = input[i].ToString();
    }
}
Console.WriteLine(string.Join("", chars.Where(item => item != null)));

result:

> "helloworld" ==> "helwrd"
>
> "pepperonipizza" ==> "rona"