Ajouter un séparateur à la chaîne à chaque N caractères?

Question

J'ai une chaîne de caractères qui contient des chiffres binaires. Comment séparer la chaîne après chaque groupe de 8 chiffres ?

Supposons que la chaîne soit :

string x = "111111110000000011111111000000001111111100000000";

Je veux ajouter un séparateur comme une virgule (,) après chaque groupe de 8 caractères.

Le résultat devrait être :

"11111111,00000000,11111111,00000000,11111111,00000000,"

Ensuite, je veux l'envoyer à une liste<> en commençant par les 8 derniers caractères, puis les 8 caractères précédents (en excluant la virgule) et ainsi de suite.

Comment puis-je faire cela ?

Answer 1

Regex.Replace(myString, ".{8}", "$0,");

Si vous voulez un tableau de chaînes de huit caractères, alors ce qui suit est probablement plus simple:

Regex.Split(myString, "(?<=^(.{8})+)");

qui divisera la chaîne uniquement aux points où un multiple de huit caractères le précède.

Answer 2

Essayez ceci :

var s = "111111110000000011111111000000001111111100000000";
var list = Enumerable
    .Range(0, s.Length/8)
    .Select(i => s.Substring(i*8, 8));
var res = string.Join(",", list);

Answer 3

Il existe une autre approche Regex :

var str = "111111110000000011111111000000001111111100000000";
# pour .NET 4
var res = String.Join(",",Regex.Matches(str, @"\d{8}").Cast());

# pour .NET 3.5
var res = String.Join(",", Regex.Matches(str, @"\d{8}")
            .OfType()
            .Select(m => m.Value).ToArray());

Answer 4

...ou à l'ancienne :

public static List splitter(string in, out string csv)
{
     if (in.length % 8 != 0) throw new ArgumentException("in");
     var lst = new List(in/8);

     for (int i=0; i < in.length / 8; i++) lst.Add(in.Substring(i*8,8));

     csv = string.Join(",", lst); //This we want in input order (I believe)
     lst.Reverse(); //As we want list in reverse order (I believe)

     return lst;
}

Answer 5

Laide mais moins de déchets:

private string InsertStrings(string s, int insertEvery, char insert)
{
    char[] ins = s.ToCharArray();
    int length = s.Length + (s.Length / insertEvery);
    if (ins.Length % insertEvery == 0)
    {
        length--;
    }
    var outs = new char[length];
    long di = 0;
    long si = 0;
    while (si < s.Length - insertEvery)
    {
        Array.Copy(ins, si, outs, di, insertEvery);
        si += insertEvery;
        di += insertEvery;
        outs[di] = insert;
        di ++;
    }
    Array.Copy(ins, si, outs, di, ins.Length - si);
    return new string(outs);
}

Surchage de chaînes:

private string InsertStrings(string s, int insertEvery, string insert)
{
    char[] ins = s.ToCharArray();
    char[] inserts = insert.ToCharArray();
    int insertLength = inserts.Length;
    int length = s.Length + (s.Length / insertEvery) * insert.Length;
    if (ins.Length % insertEvery == 0)
    {
        length -= insert.Length;
    }
    var outs = new char[length];
    long di = 0;
    long si = 0;
    while (si < s.Length - insertEvery)
    {
        Array.Copy(ins, si, outs, di, insertEvery);
        si += insertEvery;
        di += insertEvery;
        Array.Copy(inserts, 0, outs, di, insertLength);
        di += insertLength;
    }
    Array.Copy(ins, si, outs, di, ins.Length - si);
    return new string(outs);
}