N 번째 문자 / 숫자마다 문자열 / 숫자 분할?

N 번째 문자 / 숫자마다 문자열 / 숫자 분할?

---

예를 들어 숫자를 짝수로 분할해야합니다.
32427237은
324272 37이 되어야합니다.

나는 숫자를 다음으로 바꿀 수 있다고 확신하지만,이 숫자의 문자를 놓치고 싶지 않기 때문에 더 효율적인 방법이 있다고 확신합니다. 숫자 자체는 어떤 길이라도 될 수 있습니다. 1234567890이 부분으로 나누고 싶습니다 123456789 0

나는 파이썬 등과 같은 다른 언어로 예제를 보았지만 C #으로 변환하기에 충분히 이해하지 못합니다-문자를 반복하고 세 번째에서 이전을 얻은 다음 해당 인덱스를 가져와 문자열 섹션을 가져올 수 있습니다. 그러나 나는 이것을 더 잘 수행하는 방법에 대한 제안에 열려 있습니다.

---

코드의 여러 위치에서이를 수행해야하는 경우 멋진 확장 메서드를 만들 수 있습니다.

static class StringExtensions {

  public static IEnumerable<String> SplitInParts(this String s, Int32 partLength) {
    if (s == null)
      throw new ArgumentNullException("s");
    if (partLength <= 0)
      throw new ArgumentException("Part length has to be positive.", "partLength");

    for (var i = 0; i < s.Length; i += partLength)
      yield return s.Substring(i, Math.Min(partLength, s.Length - i));
  }

}

그런 다음 다음과 같이 사용할 수 있습니다.

var parts = "32427237".SplitInParts(3);
Console.WriteLine(String.Join(" ", parts));

출력은 324 272 37원하는대로입니다.

---

간단한 for 루프를 사용하여 n 번째 위치마다 공백을 삽입 할 수 있습니다.

string input = "12345678";
StringBuilder sb = new StringBuilder();
for (int i = 0; i < input.Length; i++)
{
    if (i % 3 == 0)
        sb.Append(' ');
    sb.Append(input[i]);
}
string formatted = sb.ToString();

---

LINQ 규칙 :

var input = "1234567890";
var partSize = 3;

var output = input.ToCharArray()
    .BufferWithCount(partSize)
    .Select(c => new String(c.ToArray()));

업데이트 :

string input = "1234567890";
double partSize = 3;
int k = 0;
var output = input
    .ToLookup(c => Math.Floor(k++ / partSize))
    .Select(e => new String(e.ToArray()));

---

이 작업을 수행하는 매우 간단한 방법 중 하나입니다 (가장 효율적이지는 않지만 가장 효율적인 방법보다 느리지는 않음).

    public static List<string> GetChunks(string value, int chunkSize)
    {
        List<string> triplets = new List<string>();
        while (value.Length > chunkSize)
        {
            triplets.Add(value.Substring(0, chunkSize));
            value = value.Substring(chunkSize);
        }
        if (value != "")
            triplets.Add(value);
        return triplets;
    }

여기에 대안

    public static List<string> GetChunkss(string value, int chunkSize)
    {
        List<string> triplets = new List<string>();
        for(int i = 0; i < value.Length; i += chunkSize)
            if(i + chunkSize > value.Length)
                triplets.Add(value.Substring(i));
            else
                triplets.Add(value.Substring(i, chunkSize));

        return triplets;
    }

---

반년 늦었지만 :

int n = 3;
string originalString = "32427237";
string splitString = string.Join(string.Empty,originalString.Select((x, i) => i > 0 && i % n == 0 ? string.Format(" {0}", x) : x.ToString()));

---

분할 방법 :

public static IEnumerable<string> SplitInGroups(this string original, int size) {
  var p = 0;
  var l = original.Length;
  while (l - p > size) {
    yield return original.Substring(p, size);
    p += size;
  }
  yield return original.Substring(p);
}

공백으로 구분 된 문자열로 다시 결합하려면 :

var joined = String.Join(" ", myNumber.SplitInGroups(3).ToArray());

편집 : 나는 Martin Liversage 솔루션을 더 좋아합니다. :)

편집 2 : 버그 수정.

편집 3 : 문자열을 다시 결합하는 코드가 추가되었습니다.

---

나는 다른 방법이 있다고 확신하지만 이와 같은 것을 할 것입니다. 꽤 잘 수행되어야합니다.

public static string Format(string number, int batchSize, string separator)
{      
  StringBuilder sb = new StringBuilder();
  for (int i = 0; i <= number.Length / batchSize; i++)
  {
    if (i > 0) sb.Append(separator);
    int currentIndex = i * batchSize;
    sb.Append(number.Substring(currentIndex, 
              Math.Min(batchSize, number.Length - currentIndex)));
  }
  return sb.ToString();
}

---

나는 이것이 매우 효율적이지는 않지만 시원하기 때문에 좋아합니다.

var n = 3;
var split = "12345678900"
            .Select((c, i) => new { letter = c, group = i / n })
            .GroupBy(l => l.group, l => l.letter)
            .Select(g => string.Join("", g))
            .ToList();

---

이 시도:

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

---

If you know that the whole string's length is exactly divisible by the part size, then use:

var whole = "32427237!";
var partSize = 3;
var parts = Enumerable.Range(0, whole.Length / partSize)
    .Select(i => whole.Substring(i * partSize, partSize));

But if there's a possibility the whole string may have a fractional chunk at the end, you need to little more sophistication:

var whole = "32427237";
var partSize = 3;
var parts = Enumerable.Range(0, (whole.Length + partSize - 1) / partSize)
    .Select(i => whole.Substring(i * partSize, Math.Min(whole.Length - i * partSize, partSize)));

In these examples, parts will be an IEnumerable, but you can add .ToArray() or .ToList() at the end in case you want a string[] or List<string> value.

---

A nice implementation using answers from other StackOverflow questions:

"32427237"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" ");  // "324 272 37"

"103092501"
    .AsChunks(3)
    .Select(vc => new String(vc))
    .ToCsv(" "); // "103 092 501"

AsChunks(): https://stackoverflow.com/a/22452051/538763

ToCsv(): https://stackoverflow.com/a/45891332/538763

---

This might be off topic as I don't know why you wish to format the numbers this way, so please just ignore this post if it's not relevant...

How an integer is shown differs across different cultures. You should do this in a local independent manner so it's easier to localize your changes at a later point.

int.ToString takes different parameters you can use to format for different cultures. The "N" parameter gives you a standard format for culture specific grouping.

steve x string formatting is also a great resource.

---

For a dividing a string and returning a list of strings with a certain char number per place, here is my function:

public List<string> SplitStringEveryNth(string input, int chunkSize)
    {
        var output = new List<string>();
        var flag = chunkSize;
        var tempString = string.Empty;
        var lenght = input.Length;
        for (var i = 0; i < lenght; i++)
        {
            if (Int32.Equals(flag, 0))
            {
                output.Add(tempString);
                tempString = string.Empty;
                flag = chunkSize;
            }
            else
            {
                tempString += input[i];
                flag--;
            }

            if ((input.Length - 1) == i && flag != 0)
            {
                tempString += input[i];
                output.Add(tempString);
            }
        }
        return output;
    }

참고URL : https://stackoverflow.com/questions/4133377/splitting-a-string-number-every-nth-character-number