Añadir separador a la cadena en cada N caracteres?

Tengo una cadena que contiene dígitos binarios. ¿Cómo separar una cuerda después de cada 8 dígitos?

Supongamos que la cadena es:

string x = "111111110000000011111111000000001111111100000000"; 

Quiero agregar un separador como, (coma) después de cada 8 caracteres.

salida debe ser:

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

Entonces quiero enviarlo a una lista los últimos 8 caracteres primero y luego los 8 caracteres anteriores (excepto,) y así sucesivamente.

¿Cómo puedo hacer esto?

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

Si desea una matriz de cadenas de ocho caracteres, probablemente la siguiente sea más fácil:

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

que dividirá la cadena solo en puntos donde un múltiplo de ocho caracteres lo preceden.

Prueba esto:

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

Si entiendo correctamente tu último requisito (no me queda claro si necesitas la cadena delimitada por comas intermedias o no), podrías hacer esto:

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

Al utilizar morelinq .

Feo pero menos basura:

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

Sobrecarga de cadena:

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

Hay otro enfoque Regex:

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

Una forma de usar 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() ); 

… o la vieja escuela:

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

Esto es mucho más rápido sin copiar array (esta versión inserta espacio cada 3 dígitos pero puede ajustarlo a sus necesidades)

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

Un poco tarde para la fiesta, pero aquí hay una expresión LINQ simplificada para dividir una cadena de entrada x en grupos de n separados por otra cadena sep :

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

Un resumen rápido de lo que está sucediendo aquí:

  • x está siendo tratado como IEnumberable , que es donde InSetsOf método de extensión InSetsOf .
  • InSetsOf(n) agrupa los caracteres en un IEnumerable de IEnumerable : cada entrada en la agrupación externa contiene un grupo interno de n caracteres.
  • Dentro del método Select , cada grupo de n caracteres se vuelve a convertir en una cadena utilizando el constructor String() que toma una matriz de chars .
  • El resultado de Select ahora es una IEnumerable , que se pasa a String.Join para intercalar la cadena sep , al igual que en cualquier otro ejemplo.

Por cada 1 personaje, podrías hacer esto de una sola línea:

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

Aquí mis dos pequeños centavos también. Una implementación usando StringBuilder:

  public static string AddChunkSeparator (string str, int chunk_len, char separator) { 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(); } 

Puedes llamarlo así:

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

Estoy más que tarde con mi respuesta, pero puedes usar esta:

  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; } 
    Intereting Posts