Remove part of string until nth occurrence of a character

Question

I have a string that always returns in any of these formats:

"0001>0002>0003>0004>0005"
"abcdef>ghi>jkl>mnopqr>stuvx"

Always has the character > dividing something.

There’s a way I could erase everything after the third >?

For example, I have "0001>0002>0003>0004>0005" and I just want to "0001>0002>0003".

Or do I have "abcdef>ghi>jkl>mnopqr>stuvx" and I just want to "abcdef>ghi>jkl".

Answer 1

The right and efficient way to do this:

using static System.Console;
public class Program {
    public static void Main() {
        var texto = "0001>0002>0003>0004>0005";
        var posicao = -1;
        for (var i = 0; i < 3; i++) {
            posicao = texto.IndexOf(">", posicao + 1);
            if (posicao == -1) break;
        }
        if (posicao > -1) texto = texto.Substring(0, posicao);
        WriteLine(texto);
        texto = "0001>0002";
        posicao = -1;
        for (var i = 0; i < 3; i++) {
            posicao = texto.IndexOf(">", posicao + 1);
            if (posicao == -1) break;
        }
        if (posicao > -1) texto = texto.Substring(0, posicao);
        WriteLine(texto);
    }
}

Behold working in the ideone. And in the .NET Fiddle. Also put on the Github for future reference.

The other ways are quite inefficient by generating multiple memory allocations by pressing the Garbage Collector and creating pauses in the application. People do without thinking later complain that they do not know because the application is slow, consuming a lot of memory.

It is still possible to avoid the only allocation that is made using Span. I did not use it because it can only be used in certain situations and what the AP put in the question is not enough to know if his situation is candidate or not for its use. If it is the Span can take the substring right in the string original without any allocation, which is the best of worlds.

Answer 2

Among so many alternatives, I made one more, I did not validate its efficiency in relation to the others, but it follows anyway:

string dados = "0001>0002>0003>0004>0005";
//string dados = "0001>0002>0003";

if (dados.Split('>').Length > 3)
{
    int index = dados.IndexOf('>', dados.IndexOf('>', dados.IndexOf('>') + 1) + 1);

    string antes = dados.Substring(0, index);
    string depois = dados.Substring(index + 1);
    Console.WriteLine(antes);
    Console.WriteLine(depois);
}
else
    Console.WriteLine(dados);

the IndexOf, within the various overloads, has one that is first the desired character and then from which position it will "validate"

Validation was also performed to identify if there are at least 3 occurrences of ">"

Answer 3

Implement the following method to generalize the behavior you want:

private string DevolvePartes(string strTexto, int intPartes, string strSeparador)
{
    return string.Join(strSeparador, strTexto.Split(
        new string[] { strSeparador }, StringSplitOptions.RemoveEmptyEntries).Take(intPartes));
}

Then just use, in any circumstances, as follows:

string strTexto = "0001>0002>0003>0004>0005";
string strTextoPartido = DevolvePartes(strTexto, 3, ">");

This way you can use other separators, not just ">", and separate by the parts you understand.

Answer 4

I’m sorry the taxpayers who used the method overloads String.Split, or other devices, but using a Regex.Match is the simplest and most efficient way to address this problem. Where:

^[^>]*>([^>]*>)([^>]*)

is the default to generate the required match to capture.

Detailed pattern search code:

// string entrada = "0001>0002>0003>0004>0005";
string entrada = "abcdef>ghi>jkl>mnopqr>stuvx";

// Cria o Regex com o seu padrão de busca
Regex reg = new Regex("^[^>]*>([^>]*>)([^>]*)"); 

// Faz a busca e guarda em correspondencia. 
Match correspondencia = reg.Match(entrada);

// se houve sucesso na busca guarda o padrão em resultado senão guarda a string "nada foi encontrado."
string resultado = (correspondencia.Success)? correspondencia.Value : "nada foi encontrado.";

//Exibe o resultado da busca.
Console.WriteLine(resultado);

Same code only as a function:

// Inicie o Regex dentro da classe e fora da função já que vai ser reutilizado varias vezes.
Regex reg = new Regex("^[^>]*>([^>]*>)([^>]*)");

public string Busca(string entrada) 
{
    Match correspondencia = reg.Match(entrada);
    return (correspondencia.Success) ? correspondencia.Value : "";
}

Answer 5

One more solution:

var texto = "0001>0002>0003>0004>0005";

for (int i = texto.Length - 1, sinal = 0; i >= 0 && sinal < 2; i--)
{
    sinal += texto[i] == '>' ? 1 : 0;
    texto = texto.Substring(0, i);
}

Console.WriteLine(texto);
Console.ReadKey();

This removes characters from the string...

Answer 6

With Array

class Program
{
    static void Main(string[] args)
    {
        string test = "0001>0002>0003>0004>0005";

        var testSplit = test.Split('>');

        string testJoin = string.Empty;

        for (int i = 0; i < 3; i++)
        {
            testJoin += testSplit[i] + ">";
        }

        Console.WriteLine(testJoin.Trim('>'));

        Console.ReadKey();
    }
}

If you can turn it into a list, it’s easier

class Program
{
    static void Main(string[] args)
    {
        string test = "0001>0002>0003>0004>0005";

        List<string> list = new List<string>(test.Split('>'));

        list.RemoveRange(3, list.Count - 3);

        Console.WriteLine(string.Join(">", list));

        Console.ReadKey();
    }
}

Answer 7

As his string will always be divided by the character >, we can say that we have a pattern, with this, we can divide using the method Split().

// Aqui temos nossa string original dividida pelo caractere '>'
string padrao = "0001>0002>0003>0004>0005";
// Aqui nós dividimos em um array de strings que ficará no seguinte formato:
// "0001"
// "0002"
// "0003"
// "0004"
// "0005"
string[] padraoDividido = padrao.Split('>');

Now that we have everything divided, we will check if we have more than 3 characters, we will concatenate the strings:

string padraoFormatado = string.Empty;

if (padraoDividido.Length >= 3)
    padraoFormatado = string.Format("{0}>{1}>{2}", padraoDividido[0], padraoDividido[1], padraoDividido[2]);