Gibt es eine einfache Möglichkeit, eine Zeichenfolge zurückzugeben, die X-mal wiederholt wurde?

Ich versuche, eine bestimmte Anzahl von Einrückungen vor einer Zeichenfolge basierend auf der Tiefe eines Elements einzufügen, und frage mich, ob es eine Möglichkeit gibt, eine Zeichenfolge zurückzugeben, die X-mal wiederholt wird. Beispiel:

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 "---------".

Wenn Sie nur dasselbe Zeichen wiederholen möchten, können Sie den Zeichenfolgenkonstruktor verwenden , der ein Zeichen akzeptiert, und wie oft es wiederholt werden soll new String(char c, int count).

Um beispielsweise einen Bindestrich fünfmal zu wiederholen:

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

Wenn Sie .NET 4.0 verwenden, können Sie es string.Concatzusammen mit verwenden Enumerable.Repeat.

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

Sonst würde ich mit so etwas wie Adams Antwort gehen .

Der Grund, warum ich Andreys Antwort im Allgemeinen nicht empfehlen würde , ist einfach, dass der ToArray()Anruf überflüssigen Overhead einführt, der mit dem StringBuildervon Adam vorgeschlagenen Ansatz vermieden wird. Das heißt, zumindest funktioniert es ohne .NET 4.0; und es ist schnell und einfach (und wird Sie nicht töten, wenn Effizienz kein allzu großes Problem darstellt).

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

leistungsstärkste Lösung für String

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

Für viele Szenarien ist dies wahrscheinlich die sauberste Lösung:

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

Verwendung ist dann:

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

Dies baut auf anderen Antworten auf (insbesondere @ c0rds). Neben der Einfachheit weist es die folgenden Merkmale auf, die nicht alle anderen besprochenen Techniken gemeinsam haben:

• Wiederholung einer Zeichenfolge beliebiger Länge, nicht nur eines Zeichens (wie vom OP angefordert).
• Effiziente Nutzung der StringBuilderVorbelegung durch Speicher.

Verwenden Sie String.PadLeft , wenn Ihre gewünschte Zeichenfolge nur ein einziges Zeichen enthält.

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

Gutschrift hier fällig

Sie können Ihre Zeichenfolge wiederholen (falls es sich nicht um ein einzelnes Zeichen handelt) und das Ergebnis wie folgt zusammenfassen:

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

Ich würde mich für die Antwort von Dan Tao entscheiden, aber wenn Sie .NET 4.0 nicht verwenden, können Sie so etwas tun:

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

Ich mag die Antwort. In diesem Sinne habe ich in der Vergangenheit Folgendes verwendet:

"" .PadLeft (3 * Einzug, '-')

Dies wird das Erstellen eines Einzugs erfüllen, aber technisch gesehen bestand die Frage darin, eine Zeichenfolge zu wiederholen. Wenn der String-Einzug so etwas wie> - <ist, würde dies sowie die akzeptierte Antwort nicht funktionieren. In diesem Fall sieht die Lösung von c0rd mit Stringbuilder gut aus, obwohl der Overhead von Stringbuilder sie möglicherweise nicht zur leistungsstärksten Lösung macht. Eine Möglichkeit besteht darin, ein Array von Zeichenfolgen zu erstellen, es mit Einrückungszeichenfolgen zu füllen und diese dann zu verknüpfen. Zu wissen:

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

Wir alle lieben eine clevere Lösung, aber manchmal ist einfach am besten.

Hinzufügen der Erweiterungsmethode, die ich in allen meinen Projekten verwende:

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

Hoffe, jemand kann davon Gebrauch machen ...

Überrascht ging niemand auf die alte Schule. Ich mache keine Ansprüche bezüglich dieses Codes, sondern nur zum Spaß:

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

Ich bin mir nicht sicher, wie dies funktionieren würde, aber es ist ein einfacher Code. (Ich habe es wahrscheinlich komplizierter erscheinen lassen als es ist.)

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

Wenn Sie die maximale Anzahl von Ebenen kennen, die Sie erwarten können, können Sie alternativ einfach ein Array deklarieren und darin indizieren. Sie möchten dieses Array wahrscheinlich statisch oder konstant machen.

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

Ich habe nicht genug Repräsentanten, um Adams Antwort zu kommentieren, aber der beste Weg, dies imo zu tun, ist folgender:

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

Sie müssen überprüfen, ob numTimes größer als Null ist. Andernfalls wird eine Ausnahme angezeigt.

Ich habe diese Lösung nicht gesehen. Ich finde es einfacher, wo ich mich gerade in der Softwareentwicklung befinde:

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

Für den allgemeinen Gebrauch eignen sich Lösungen mit der StringBuilder-Klasse am besten zum Wiederholen von Zeichenfolgen mit mehreren Zeichen. Es ist optimiert, um die Kombination einer großen Anzahl von Zeichenfolgen auf eine Weise zu handhaben, die eine einfache Verkettung nicht kann und die von Hand nur schwer oder gar nicht effizienter durchgeführt werden kann. Die hier gezeigten StringBuilder-Lösungen verwenden zum Abschluss O (N) -Iterationen, eine Flatrate, die proportional zur Häufigkeit der Wiederholung ist.

Für eine sehr große Anzahl von Wiederholungen oder wenn ein hohes Maß an Effizienz herausgepresst werden muss, ist es jedoch besser, etwas Ähnliches wie die Grundfunktionalität von StringBuilder zu tun, aber zusätzliche Kopien vom Ziel anstatt von der ursprünglichen Zeichenfolge zu erstellen. wie nachstehend.

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

Dies verdoppelt die Länge der Quell- / Zielzeichenfolge bei jeder Iteration, wodurch der Aufwand für das Zurücksetzen von Zählern bei jedem Durchlaufen der ursprünglichen Zeichenfolge gespart wird. Stattdessen kann die jetzt viel längere Zeichenfolge problemlos gelesen und kopiert werden, was moderne Prozessoren viel tun können effizienter.

Es verwendet einen Basis-2-Logarithmus, um zu ermitteln, wie oft die Länge der Zeichenfolge verdoppelt werden muss, und fährt dann so oft fort. Da der zu kopierende Rest jetzt kleiner ist als die Gesamtlänge, von der kopiert wird, kann er einfach eine Teilmenge dessen kopieren, was er bereits generiert hat.

Ich habe die Array.Copy () -Methode anstelle der Verwendung von StringBuilder verwendet, da das Kopieren des Inhalts des StringBuilder in sich selbst den Aufwand hätte, bei jeder Iteration einen neuen String mit diesem Inhalt zu erstellen. Array.Copy () vermeidet dies und arbeitet dennoch mit einer extrem hohen Effizienz.

Diese Lösung benötigt O (1 + log N) -Iterationen, eine Rate, die logarithmisch mit der Anzahl der Wiederholungen zunimmt (die Verdoppelung der Anzahl der Wiederholungen entspricht einer zusätzlichen Iteration), was eine erhebliche Einsparung gegenüber den anderen Methoden darstellt, die proportional zunehmen.

Ein weiterer Ansatz ist zu prüfen , stringwie IEnumerable<char>und eine generische Erweiterungsmethode hat , die die Elemente in einer Auflistung um den angegebenen Faktor multiplizieren.

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

Also in deinem Fall:

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

Drucken Sie eine Zeile mit Wiederholung.

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

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

Sie können dazu eine ExtensionMethod erstellen!

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

Oder mit der @ Dan Tao-Lösung:

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

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