Add whiteW tym wpisie dodam białe znaki do dużych liczb tak aby były one bardziej czytelne.

Czyli chcemy sformatować liczbę 1000000000 do takiej postaci “1 000 000 000”. Dodatkowo chce dać użytkownikowi możliwość ustalenia co ile znaków ma się pojawiać znak spacji.

Udało mi się opracować dwie metody przy czym druga metoda, która używa wyrażenia regularnego jest trochę wadliwa.

Oto jak wygląda metoda, która używa StringBulider w celach wydajnościowych.

public static string AddWhiteSpaces(string input)
{
    StringBuilder buffer = new StringBuilder(input.Length * 3 / 2);
    
    for (int i = 0; i < input.Length; i++) 
    {
        if ((i > 0) & (i % 3 == 0))
            buffer.Append(" ");
        buffer.Append(input[i]);
    }

    return buffer.ToString();
}

public static string AddWhiteSpaces(string input, int whenAddIndex)
{
    StringBuilder buffer = new StringBuilder(input.Length 
    * whenAddIndex / 2);

    for (int i = 0; i < input.Length; i++) 
    {
        if ((i > 0) & (i % whenAddIndex == 0))
            buffer.Append(" ");
        buffer.Append(input[i]);
    }

    return buffer.ToString();
}

Wszystko wydaje się piękne nieprawdaż. Warto jednak zaznaczyć, że obecnie kod formatuje cyfrę, ale w niewłaściwym kierunku.

static void Main(string[] args)
{
    while (true)
    {
        List<int> list = new List<int>()
                                {
                                    100000000,
                                    9000,
                                    100,
                                    458732,
                                    7771112,
                                    20000,
                                    40000000,
                                    1000000000,
                                    10,
                                    1
                                };

        int when = int.Parse(Console.ReadKey().KeyChar.ToString());

        Console.WriteLine("\nStringBulider: \n \n");
        foreach (var a in list)
        {
            Console.WriteLine(AddWhiteSpaces(a.ToString(), when));
        }
    }

Jak widać formatowanie nie działa prawidłowo.

Console.WriteLine

Oto ilustracja przedstawiająca następujący problem.

Formatowanie napisu

Przyznam, że nie chciało mi się myśleć więc, zamiast modyfikować swój algorytm (o ile to można nazwać algorytmem) postanowiłem po prostu odwrócić napis przed jego działaniem i po. Nie jest to wydajne, ale i tak operuje na napisach maksymalnie 7 znakowych więc co tam.

public static string AddWhiteSpaces(string input)
{
    input = Reverse(input);
    StringBuilder buffer = 
    new StringBuilder(input.Length * 3 / 2);

    for (int i = 0; i < input.Length; i++) 
    {
        if ((i > 0) & (i % 3 == 0))
            buffer.Append(" ");
        buffer.Append(input[i]);
    }

    return Reverse(buffer.ToString());
}

public static string AddWhiteSpaces(string input, 
int whenAddIndex)
{
    input = Reverse(input);
    StringBuilder buffer = new StringBuilder(input.Length
     * whenAddIndex / 2);

    for (int i = 0; i < input.Length; i++) 
    {
        if ((i > 0) & (i % whenAddIndex == 0))
            buffer.Append(" ");
        buffer.Append(input[i]);
    }

    return Reverse(buffer.ToString());
}

public static string Reverse(string s)
{
    char[] charArray = s.ToCharArray();
    Array.Reverse(charArray);
    return new string(charArray);
}

Dodatkowo postanowiłem pobawić się trochę wyrażeniami regularnymi. Dodanie spacji w określonym miejscu przy pomocy ich jest w teorii jeszcze prostsze o ile człowiek wie jakiego wyrażenia regularnego użyć.

public static string AddWhiteSpacesRegex(string input)
{
    input = Reverse(input);

    return Reverse(Regex.Replace(input, @"(.{3})", "$1 "));
}

public static string AddWhiteSpacesRegex(string input,
int whenAddIndex)
{
    input = Reverse(input);

    return Reverse(Regex.Replace(input, 
    @"(.{"+ whenAddIndex.ToString()+"})", "$1 "));
}

Jednak tak jak pisałem wcześniej ta metoda jest wadliwa ponieważ doda ona biały znak w ostatnim znaku napisu co nie jest potrzebne. Prawdopodobnie powinienem zmodyfikować wyrażenie regularne, ale niestety nie jestem guru od tych spraw więc szczerze dodaje ten kod raczej jako ciekawostkę niż rozwiązanie problemu.

while (true)
{
    List<int> list = new List<int>()
                            {
                                100000000,
                                9000,
                                100,
                                458732,
                                7771112,
                                20000,
                                40000000,
                                1000000000,
                                10,
                                1
                            };

    int when = int.Parse(Console.ReadKey().KeyChar.ToString());

    Console.WriteLine("\nStringBulider: \n \n");
    foreach (var a in list)
    {
        Console.WriteLine(AddWhiteSpaces(a.ToString(), when));
    }

    Console.WriteLine("\nRegex: \n \n");
                
    foreach (var a in list)
    {
        Console.WriteLine
        (AddWhiteSpacesRegex(a.ToString(), when));
    }

    Console.ReadKey();
    Console.Clear();

}

Oto rezultat działa metod dla trzech i czterech odstępów

wynik