Thêm dấu phân cách vào chuỗi ở mỗi N ký tự?

Tôi có một chuỗi chứa các chữ số nhị phân. Làm thế nào để tách chuỗi sau mỗi chữ số 8?

Giả sử chuỗi là:

string x = "111111110000000011111111000000001111111100000000";

Tôi muốn thêm dấu phân tách như, (dấu phẩy) sau mỗi 8 ký tự.

đầu ra phải là:

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

Sau đó, tôi muốn gửi nó vào danh sách <> 8 ký tự cuối cùng đầu tiên rồi đến 8 ký tự trước đó (ngoại trừ,), v.v.

Tôi có thể làm cái này như thế nào?

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

Nếu bạn muốn một mảng gồm tám ký tự, thì cách sau có lẽ dễ dàng hơn:

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

sẽ chỉ chia chuỗi tại các điểm có bội số tám ký tự đứng trước nó.

Thử cái này:

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

... hoặc trường cũ:

public static List<string> splitter(string in, out string csv)
{
     if (in.length % 8 != 0) throw new ArgumentException("in");
     var lst = new List<string>(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;
}

Xấu xí nhưng ít rác hơn:

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);
}

Quá tải chuỗi:

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);
}

Có một cách tiếp cận Regex khác:

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

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

Nếu tôi hiểu chính xác yêu cầu cuối cùng của bạn (tôi không rõ liệu bạn có cần chuỗi phân cách bằng dấu phẩy ở giữa hay không), bạn có thể thực hiện điều này:

var enumerable = "111111110000000011111111000000001111111100000000".Batch(8).Reverse();

Bằng cách sử dụng morelinq .

Một cách sử dụng LINQ:

string data = "111111110000000011111111000000001111111100000000";
const int separateOnLength = 8;

string separated = new string(
    data.Select((x,i) => i > 0 && i % separateOnLength == 0 ? new [] { ',', x } : new [] { x })
        .SelectMany(x => x)
        .ToArray()
    );

Đây là hai xu nhỏ của tôi nữa. Triển khai sử dụng StringBuilder:

        public static string AddChunkSeparator (string str, int chunk_len, char separator)
        {
            if (str == null || str.Length < chunk_len) {
                return str;
            }
            StringBuilder builder = new StringBuilder();
            for (var index = 0; index < str.Length; index += chunk_len) {
                builder.Append(str, index, chunk_len);
                builder.Append(separator);
            }
            return builder.ToString();
        }

Bạn có thể gọi nó như thế này:

string data = "111111110000000011111111000000001111111100000000";
string output = AddChunkSeparator(data, 8, ',');

Tôi đã làm điều đó bằng cách sử dụng Pattern & Matcher theo cách sau:

fun addAnyCharacter(input: String, insertion: String, interval: Int): String {
  val pattern = Pattern.compile("(.{$interval})", Pattern.DOTALL)
  val matcher = pattern.matcher(input)
  return matcher.replaceAll("$1$insertion")
}

Ở đâu:

inputcho biết chuỗi đầu vào. Kiểm tra phần kết quả.

insertioncho biết Chèn chuỗi giữa các ký tự đó. Ví dụ: dấu phẩy (,), bắt đầu (*), băm (#).

interval cho biết bạn muốn thêm ký tự chèn vào khoảng thời gian nào.

inputcho biết chuỗi đầu vào. Kiểm tra phần kết quả. Kiểm tra phần kết quả; ở đây tôi đã thêm chèn vào mỗi ký tự thứ 4.

Các kết quả:

I / P: 1234XXXXXXXX5678 O / P: 1234 XXXX XXXX 5678

I / P: 1234567812345678 O / P: 1234 5678 1234 5678

I / P: ABCDEFGHIJKLMNOP O / P: ABCD EFGH IJKL MNOP

Hi vọng điêu nay co ich.

Điều này nhanh hơn nhiều mà không cần sao chép mảng (phiên bản này chèn khoảng trắng mỗi 3 chữ số nhưng bạn có thể điều chỉnh nó theo nhu cầu của mình)

public string GetString(double valueField)
{
    char[] ins = valueField.ToString().ToCharArray();
    int length = ins.Length + (ins.Length / 3);
    if (ins.Length % 3 == 0)
    {
        length--;
    }
    char[] outs = new char[length];

    int i = length - 1;
    int j = ins.Length - 1;
    int k = 0;
    do
    {
        if (k == 3)
        {
            outs[i--] = ' ';
            k = 0;
        }
        else
        {
            outs[i--] = ins[j--];
            k++;
        }           
    }
    while (i >= 0);

    return new string(outs);
}

Đến bữa tiệc hơi muộn, nhưng đây là biểu thức LINQ được đơn giản hóa để chia một chuỗi đầu xvào thành các nhóm được nphân tách bằng một chuỗi khác sep:

string sep = ",";
int n = 8;
string result = String.Join(sep, x.InSetsOf(n).Select(g => new String(g.ToArray())));

Tóm tắt nhanh những gì đang xảy ra ở đây:

• xđang được coi là một IEnumberable<char>, đó là nơi InSetsOfphương thức mở rộng xuất hiện.
• InSetsOf(n)nhóm các ký tự thành một IEnumerabletrong số IEnumerable- mỗi mục nhập trong nhóm bên ngoài chứa một nhóm nký tự bên trong .
• Bên trong Selectphương thức, mỗi nhóm nký tự được chuyển trở lại thành một chuỗi bằng cách sử dụng hàm String()tạo nhận một mảng chars.
• Kết quả của Selectbây giờ là an IEnumerable<string>, được chuyển vào String.Joinđể xen vào sepchuỗi, giống như bất kỳ ví dụ nào khác.

Tôi đã muộn với câu trả lời của mình nhưng bạn có thể sử dụng câu trả lời sau:

    static string PutLineBreak(string str, int split)
    {
        for (int a = 1; a <= str.Length; a++)
        {
            if (a % split == 0)
                str = str.Insert(a, "\n");
        }

        return str;
    }

Đối với mỗi 1 ký tự, bạn có thể thực hiện một chữ lót sau:

string.Join(".", "1234".ToArray()) //result: 1.2.3.4