Well basically if some algorithm has time complexity O(x) that means it does amount of basic actions (like adding, subtracting, indexing an array, etc.) that is proportional to x in worst case where x is some function of input size.

For example, if we say n is the size of input string of 0's and 1's, then your solution's time complexity is O(n²) because if the answer is 0 it has to remove "01" or "10" n / 2 times and each removal is done by rebuilding the whole string so it also takes n actions for the first time, n - 2 for the second, n - 4 for the third and so on, which is roughly n² / 4 if summed up (it's actually more). So your solution's amount of basic actions in the worst case is 0.25 * n², which is linearly proportional to n², so its time complexity is O(n²).

So, n's maximum value in the problem is 2 * 10⁵, and your solution does 0.25 * n² in the worst case, so your worst case is 10¹⁰ actions, which is impossible to squeeze into one second (moreover, on C#).

I'm not an expert (though my rank states so), but I can say C# can easily do 10⁶ actions in one second, so probably you should find a solution which time complexity is O(n) so it does about 10⁵ actions and maybe a little more.

UPD: in competitive programming, algorithm's time complexity usually very well represents its speed. In other words, if you plug in your maximum values for input size variables in time complexity's function and see that the number you get is about 10⁶ or less, then you're good to go and your solution will probably pass the time limit. Very rare are cases in which that does not work, because if you came up with a solution which time complexity is the same as the problem's real full solution, then these two are probably the same (and are easiest to come up with)