Чи є простий спосіб повернути рядок, повторений X кількість разів?

Я намагаюся вставити певну кількість відступів перед рядком на основі глибини елементів, і мені цікаво, чи є спосіб повернути рядок, повторений X разів. Приклад:

string indent = "---";
Console.WriteLine(indent.Repeat(0)); //would print nothing.
Console.WriteLine(indent.Repeat(1)); //would print "---".
Console.WriteLine(indent.Repeat(2)); //would print "------".
Console.WriteLine(indent.Repeat(3)); //would print "---------".

Якщо ви маєте намір повторити один і той же символ, ви можете використовувати конструктор рядків, який приймає знак та кількість разів, щоб повторити його new String(char c, int count).

Наприклад, повторити тире п’ять разів:

string result = new String('-', 5);
Output: -----

Якщо ви використовуєте .NET 4.0, ви можете користуватися string.Concatразом із Enumerable.Repeat.

int N = 5; // or whatever
Console.WriteLine(string.Concat(Enumerable.Repeat(indent, N)));

Інакше я б пішов з чимось на кшталт відповіді Адама .

Причина, яку я взагалі не радив би використовувати відповідь Андрія, - це те, що ToArray()дзвінок представляє зайві накладні витрати, яких уникає StringBuilderпідхід, запропонований Адамом. Однак, принаймні, це працює, не вимагаючи .NET 4.0; і це швидко і легко (і не збирається вбивати вас, якщо ефективність не надто турбує).

public static class StringExtensions
{
    public static string Repeat(this string input, int count)
    {
        if (!string.IsNullOrEmpty(input))
        {
            StringBuilder builder = new StringBuilder(input.Length * count);

            for(int i = 0; i < count; i++) builder.Append(input);

            return builder.ToString();
        }

        return string.Empty;
    }
}

найефективніше рішення для струни

string result = new StringBuilder().Insert(0, "---", 5).ToString();

Для багатьох сценаріїв це, мабуть, найновіше рішення:

public static class StringExtensions
{
    public static string Repeat(this string s, int n)
        => new StringBuilder(s.Length * n).Insert(0, s, n).ToString();
}

Використання тоді:

text = "Hello World! ".Repeat(5);

Це ґрунтується на інших відповідях (зокрема, @ c0rd's). Крім простоти, вона має такі особливості, які не всі інші обговорювані методи поділяють:

• Повторення рядка будь-якої довжини, а не лише символу (на вимогу ОП).
• Ефективне використання попереднього розміщення StringBuilderчерез зберігання.

Використовуйте String.PadLeft , якщо бажаний рядок містить лише одну таблицю.

public static string Indent(int count, char pad)
{
    return String.Empty.PadLeft(count, pad);
}

Кредит тут належить

Ви можете повторити рядок (на випадок, якщо це не одна таблиця) та сформулюйте результат таким чином:

String.Concat(Enumerable.Repeat("---", 5))

Я хотів би відповісти Дана Дао, але якщо ви не використовуєте .NET 4.0, ви можете зробити щось подібне:

public static string Repeat(this string str, int count)
{
    return Enumerable.Repeat(str, count)
                     .Aggregate(
                        new StringBuilder(),
                        (sb, s) => sb.Append(s))
                     .ToString();
}

        string indent = "---";
        string n = string.Concat(Enumerable.Repeat(indent, 1).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 2).ToArray());
        string n = string.Concat(Enumerable.Repeat(indent, 3).ToArray());

Мені подобається дана відповідь. Хоча по лінії самов це те, що я використовував раніше:

"" .PadLeft (відступ 3 *, '-')

Це дозволить створити відступ, але технічно питання полягає у повторенні рядка. Якщо рядковий відступ є чимось на кшталт> - <, це, як і прийнята відповідь, не буде працювати. У цьому випадку рішення c0rd за допомогою stringbuilder виглядає добре, хоча накладні витрати на stringbuilder насправді не можуть зробити його найбільш ефективним. Один із варіантів - створити масив рядків, заповнити його рядками з відступами, а потім зробити це концентрованим. Побілити:

int Indent = 2;

string[] sarray = new string[6];  //assuming max of 6 levels of indent, 0 based

for (int iter = 0; iter < 6; iter++)
{
    //using c0rd's stringbuilder concept, insert ABC as the indent characters to demonstrate any string can be used
    sarray[iter] = new StringBuilder().Insert(0, "ABC", iter).ToString();
}

Console.WriteLine(sarray[Indent] +"blah");  //now pretend to output some indented line

Всі ми любимо розумне рішення, але іноді найкраще просто.

Додавання методу розширення Я використовую у всіх своїх проектах:

public static string Repeat(this string text, int count)
{
    if (!String.IsNullOrEmpty(text))
    {
        return String.Concat(Enumerable.Repeat(text, count));
    }
    return "";
}

Сподіваюся, хтось може скористатися цим ...

Здивований, ніхто не ходив у стару школу. Я не пред'являю жодних претензій щодо цього коду, а просто для розваги:

public static string Repeat(this string @this, int count)
{
    var dest = new char[@this.Length * count];
    for (int i = 0; i < dest.Length; i += 1)
    {
        dest[i] = @this[i % @this.Length];
    }
    return new string(dest);
}

Не впевнений, як це буде працювати, але це легкий фрагмент коду. (Я, мабуть, зробив це складніше, ніж це є.)

int indentCount = 3;
string indent = "---";
string stringToBeIndented = "Blah";
// Need dummy char NOT in stringToBeIndented - vertical tab, anyone?
char dummy = '\v';
stringToBeIndented.PadLeft(stringToBeIndented.Length + indentCount, dummy).Replace(dummy.ToString(), indent);

Крім того, якщо ви знаєте максимальну кількість рівнів, які ви можете очікувати, ви можете просто оголосити масив та індексувати його. Ймовірно, ви хочете зробити цей масив статичним або константою.

string[] indents = new string[4] { "", indent, indent.Replace("-", "--"), indent.Replace("-", "---"), indent.Replace("-", "----") };
output = indents[indentCount] + stringToBeIndented;      

У мене не вистачає респондентів, щоб коментувати відповідь Адама, але найкращий спосіб зробити це, як це:

public static string RepeatString(string content, int numTimes) {
        if(!string.IsNullOrEmpty(content) && numTimes > 0) {
            StringBuilder builder = new StringBuilder(content.Length * numTimes);

            for(int i = 0; i < numTimes; i++) builder.Append(content);

            return builder.ToString();
        }

        return string.Empty;
    }

Ви повинні перевірити, чи число numTimes більше нуля, інакше ви отримаєте виняток.

Я не бачив цього рішення. Мені простіше, де я зараз перебуваю в розробці програмного забезпечення:

public static void PrintFigure(int shapeSize)
{
    string figure = "\\/";
    for (int loopTwo = 1; loopTwo <= shapeSize - 1; loopTwo++)
    {
        Console.Write($"{figure}");
    }
}

Для загального використання рішення, що включають клас StringBuilder, найкращі для повторення рядків з декількома символами. Оптимізовано обробляти комбінацію великої кількості рядків таким чином, що просте об'єднання не може, і це буде важко або неможливо зробити ефективніше вручну. Показані тут рішення StringBuilder використовують ітерації O (N) для завершення, рівну швидкість, пропорційну кількості повторень.

Однак для дуже великої кількості повторів або, коли з неї потрібно вичавити високий рівень ефективності, кращим підходом є зробити щось подібне до основної функціональності StringBuilder, але створити додаткові копії з пункту призначення, а не з оригінального рядка, як нижче.

    public static string Repeat_CharArray_LogN(this string str, int times)
    {
        int limit = (int)Math.Log(times, 2);
        char[] buffer = new char[str.Length * times];
        int width = str.Length;
        Array.Copy(str.ToCharArray(), buffer, width);

        for (int index = 0; index < limit; index++)
        {
            Array.Copy(buffer, 0, buffer, width, width);
            width *= 2;
        }
        Array.Copy(buffer, 0, buffer, width, str.Length * times - width);

        return new string(buffer);
    }

Це подвоює довжину рядка джерела / призначення з кожною ітерацією, що дозволяє економити накладні витрати на скидання лічильників кожного разу, коли воно проходитиме через початковий рядок, замість того, щоб плавно читати та копіювати тепер набагато довший рядок, що може зробити багато сучасних процесорів більш ефективно.

Він використовує логарифм base-2, щоб знайти, скільки разів потрібно вдвічі збільшити довжину струни, а потім продовжує робити це так багато разів. Оскільки решта, яку потрібно скопіювати, зараз менша за загальну довжину, з якої вона копіює, то вона може просто скопіювати підмножину того, що вже створено.

Я використовував метод Array.Copy () над використанням StringBuilder, оскільки копіювання вмісту StringBuilder в себе могло б мати накладні витрати на створення нової рядки з цим вмістом з кожною ітерацією. Array.Copy () уникає цього, хоча він все ще працює з надзвичайно високою ефективністю.

Це рішення потребує завершення ітерацій O (1 + log N) - швидкість, що збільшується логарифмічно з кількістю повторів (подвоєння кількості повторів дорівнює одній додатковій ітерації), істотна економія порівняно з іншими методами, які пропорційно збільшуються.

Інший підхід полягає в розгляді , stringяк IEnumerable<char>і є загальний метод розширення , який буде множити елементи в колекції з допомогою зазначеного фактора.

public static IEnumerable<T> Repeat<T>(this IEnumerable<T> source, int times)
{
    source = source.ToArray();
    return Enumerable.Range(0, times).SelectMany(_ => source);
}

Тож у вашому випадку:

string indent = "---";
var f = string.Concat(indent.Repeat(0)); //.NET 4 required
//or
var g = new string(indent.Repeat(5).ToArray());

Роздрукуйте рядок з повтором.

Console.Write(new string('=', 30) + "\n");

===============================

Ви можете створити ExtensionMethod для цього!

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    string ret = "";

    for (var x = 0; x < count; x++)
    {
      ret += str;
    }

    return ret;
  }
}

Або за допомогою рішення @Dan Tao:

public static class StringExtension
{
  public static string Repeat(this string str, int count)
  {
    if (count == 0)
      return "";

    return string.Concat(Enumerable.Repeat(indent, N))
  }
}