Chia chuỗi thành danh sách các chuỗi có độ dài bằng cách sử dụng LINQ

Question

Tôi biết khái niệm String.Split đã được giải quyết trước với vô số các cách tiếp cận khác nhau, nhưng tôi đặc biệt quan tâm đến giải pháp LINQ cho câu hỏi này.

Tôi đã cố gắng viết một lớp mở rộng để xử lý việc chia tách, nhưng cả hai lần thử đều có một số vấn đề lớn. Vì vậy, sau:

string s = "ABCDEFGHIJKLMNOPQRSTUVWX"; 
var results = s.SplitEvery(4); 

tôi muốn một danh sách như: { "ABCD", "EFGH", "IJKL", "MNOP", "QRST", "UVWX"}

đây là lớp mở rộng của tôi:

public static class Extensions 
{ 
    public static List<string> SplitEvery(this string s, int n) 
    { 
     List<string> list = new List<string>(); 

     var Attempt1 = s.Select((c, i) => i % n== 0 ? s.Substring(i, n) : "|").Where(x => x != "|").ToList(); 

     var Attempt2 = s.Where((c, i) => i % n== 0).Select((c, i) => s.Substring(i, n)).ToList(); 

     return list; 
    } 
} 

Cố gắng 1 chèn một chuỗi giả "|" mỗi khi điều kiện không được đáp ứng, sau đó loại bỏ tất cả các trường hợp của chuỗi giả để tạo danh sách cuối cùng. Nó hoạt động, nhưng việc tạo ra các chuỗi xấu có vẻ như một bước bổ sung không cần thiết. Hơn nữa, nỗ lực này thất bại nếu chuỗi không chia hết cho n. Cố gắng 2 là tôi đang cố gắng để lựa chọn chỉ nền mà chỉ số có thể chia hết cho N, nhưng giá trị 'i' trong câu lệnh Select không tương ứng với giá trị 'i' trong câu lệnh Where, vì vậy tôi nhận được kết quả như: {"ABCD", "BCDE", v.v ...}

Tôi cảm thấy mình gần gũi với một giải pháp tốt, nhưng có thể sử dụng hướng di chuyển hữu ích đúng hướng. Bất kỳ đề xuất?

[Chỉnh sửa]

tôi đã kết thúc đi với một sự kết hợp những gợi ý để xử lý tôi chuỗi-splitter. Nó có thể không phải là nhanh nhất, nhưng như là một newbie để LINQ, thực hiện này là gọn gàng nhất và dễ dàng cho tôi để hiểu.

public static List<string> SplitEvery(this string s, int size) 
{ 
    return s.Select((x, i) => i) 
     .Where(i => i % size == 0) 
     .Select(i => String.Concat(s.Skip(i).Take(size))).ToList(); 
} 

Cảm ơn tất cả các đề xuất tuyệt vời.

Answer 1

Dưới đây là một giải pháp:

var result = s.Select((x, i) => i) 
       .Where(i => i % 4 == 0) 
       .Select(i => s.Substring(i, s.Length - i >= 4 ? 4 : s.Length - i)); 

Answer 2

string s = "ABCDEFGHIJKLMNOPQRSTUVWX"; 
var results = s.Select((c, i) => new { c, i }) 
      .GroupBy(x => x.i/4) 
      .Select(g => String.Join("",g.Select(y=>y.c))) 
      .ToList(); 

---

Bạn cũng có thể sử dụng morelinq's batch

var res = s.Batch(4).Select(x => String.Join("", x)).ToList(); 

---

Nếu bạn không nhớ sử dụng tác dụng phụ, điều này có thể quá

var res2 = s.SplitEvery(4).ToList(); 

public static IEnumerable<string> SplitEvery(this string s, int n) 
{ 
    int index = 0; 
    return s.GroupBy(_=> index++/n).Select(g => new string(g.ToArray())); 
} 

---

Và Dĩ nhiên mỗi chuỗi hoạt động câu hỏi xứng đáng là một câu trả lời Regex :)

var res3 = Regex.Split(s, @"(?<=\G.{4})"); 

Answer 3

Điều này dường như làm việc:

public static IEnumerable<string> SplitEvery(this string s, int n) { 
    var enumerators = Enumerable.Repeat(s.GetEnumerator(), n); 
    while (true) { 
     var chunk = string.Concat(enumerators 
      .Where(e => e.MoveNext()) 
      .Select(e => e.Current)); 
     if (chunk == "") yield break; 
     yield return chunk; 
    } 
} 

Answer 4

Dưới đây là một vài LINQy cách để làm điều đó:

public static IEnumerable<string> SplitEvery(this IEnumerable<char> s , int n) 
{ 
    StringBuilder sb = new StringBuilder(n) ; 
    foreach (char c in s) 
    { 
    if (sb.Length == n) 
    { 
     yield return sb.ToString() ; 
     sb.Length = 0 ; 
    } 
    sb.Append(c) ; 
    } 
} 

Hoặc

public static IEnumerable<string> SplitEvery(this string s , int n) 
{ 
    int limit = s.Length - (s.Length % n) ; 
    int i = 0 ; 

    while (i < limit) 
    { 
    yield return s.Substring(i,n) ; 
    i+=n ; 
    } 

    if (i < s.Length) 
    { 
    yield return s.Substring(i) ; 
    } 

} 

Answer 5

Substring sẽ ổn nếu chọn các phần gồm 4 ký tự của chuỗi. Bạn chỉ cần phải cẩn thận với phần cuối cùng:

new Func<string, int, IEnumerable<string>>(
     (string s, int n) => 
      Enumerable.Range(0, (s.Length + n-1)/n) 
      .Select(i => s.Substring(i*n, Math.Min(n, s.Length - i*n)))) 
("ABCDEFGHIJKLMNOPQRSTUVWX", 4) 

Lưu ý: nếu câu trả lời này được chuyển thành hoạt động trên generic đếm được nó sẽ phải lặp bộ sưu tập nhiều lần (Count() và Substring chuyển đổi sang Skip(i*n).Take(n)).

Answer 6

public static IEnumerable<string> SplitEvery(this string s, int length) 
{ 
    return s.Where((c, index) => index % length == 0) 
      .Select((c, index) => String.Concat(
       s.Skip(index * length).Take(length) 
      ) 
      ); 
} 

Ban giám khảo sẽ ra liệu new String(chars.ToArray()) sẽ nhanh hơn hoặc chậm hơn cho điều này là String.Concat(chars).

Bạn có thể khóa thêm .ToList() để trả lại Danh sách thay vì IEnumerable.

Answer 7

Bạn có thể sử dụng phương pháp mở rộng này, mà thực hiện với chuỗi đơn giản nhận được (Tôi tin rằng nó là nhanh hơn, hơn liệt kê trên nhân vật và tham gia chúng thành chuỗi):

public static IEnumerable<string> SplitEvery(this string s, int length) 
{ 
    int index = 0; 
    while (index + length < s.Length) 
    { 
     yield return s.Substring(index, length); 
     index += length;     
    } 

    if (index < s.Length) 
     yield return s.Substring(index, s.Length - index); 
} 

Answer 8

cũng này hoạt động, nhưng đòi hỏi 'unwrapping' một IGrouping<x,y>:

public static IEnumerable<String> Split(this String me,int SIZE) { 
    //Works by mapping the character index to a 'modulo Staircase' 
    //and then grouping by that 'stair step' value 
    return me.Select((c, i) => new { 
    step = i - i % SIZE, 
    letter = c.ToString() 
    }) 
    .GroupBy(kvp => kvp.step) 
    .Select(grouping => grouping 
    .Select(g => g.letter) 
    .Aggregate((a, b) => a + b) 
); 
} 

EDIT: Sử dụng cơ chế thẩm định lười biếng LINQ của (yield return) bạn cũng có thể đạt được điều này sử dụng đệ quy

public static IEnumerable<String> Split(this String me, int SIZE) {  
    if (me.Length > SIZE) { 
    var head = me.Substring(0,SIZE); 
    var tail = me.Substring(SIZE,me.Length-SIZE); 
    yield return head;   
    foreach (var item in tail.Split(SIZE)) { 
     yield return item; 
    } 
    } else { 
    yield return me; 
    } 
} 

Mặc dù, cá nhân tôi, tôi tránh xa Substring vì nó khuyến khích mã nhà nước-ful (quầy, chỉ số, vv trong cha mẹ hoặc phạm vi toàn cầu).