C'è un modo semplice per restituire una stringa ripetuta X il numero di volte?

Sto cercando di inserire un certo numero di rientri prima di una stringa in base alla profondità di un elemento e mi chiedo se esiste un modo per restituire una stringa ripetuta X volte. Esempio:

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

Se hai intenzione di ripetere solo lo stesso carattere, puoi usare il costruttore di stringhe che accetta un carattere e il numero di volte per ripeterlo new String(char c, int count).

Ad esempio, per ripetere un trattino cinque volte:

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

Se si utilizza .NET 4.0, è possibile utilizzarlo string.Concatinsieme a Enumerable.Repeat.

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

Altrimenti andrei con qualcosa come la risposta di Adam .

Il motivo per cui generalmente non consiglierei di usare la risposta di Andrey è semplicemente che la ToArray()chiamata introduce un sovraccarico superfluo che viene evitato con l' StringBuilderapproccio suggerito da Adam. Detto questo, almeno funziona senza richiedere .NET 4.0; ed è facile e veloce (e non ti ucciderà se l'efficienza non è troppo preoccupante).

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

soluzione più performante per stringa

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

Per molti scenari, questa è probabilmente la soluzione più accurata:

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

L'utilizzo è quindi:

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

Questo si basa su altre risposte (in particolare su @ c0rd's). Oltre alla semplicità, ha le seguenti caratteristiche, che non tutte le altre tecniche discusse condividono:

• Ripetizione di una stringa di qualsiasi lunghezza, non solo di un carattere (come richiesto dall'OP).
• Uso efficiente della StringBuilderpreallocazione attraverso lo storage.

Usa String.PadLeft , se la stringa desiderata contiene solo un singolo carattere.

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

Credito dovuto qui

Puoi ripetere la tua stringa (nel caso non sia un singolo carattere) e concatene il risultato, in questo modo:

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

Vorrei cercare la risposta di Dan Tao, ma se non stai usando .NET 4.0 puoi fare qualcosa del genere:

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

Mi piace la risposta data. Sulla falsa riga però è quello che ho usato in passato:

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

Questo compirà la creazione di un rientro ma tecnicamente la domanda era ripetere una stringa. Se il rientro della stringa è simile a> - <, così come la risposta accettata non funzionerebbe. In questo caso la soluzione di c0rd che usa stringbuilder sembra buona, sebbene il sovraccarico di stringbuilder potrebbe in effetti non renderlo il più performante. Un'opzione è costruire una matrice di stringhe, riempirla con stringhe di rientro, quindi concatenerla. Per Pentecoste:

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

Tutti amiamo una soluzione intelligente ma a volte semplice è la cosa migliore.

Aggiunta del metodo di estensione che sto usando in tutti i miei progetti:

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

Spero che qualcuno possa usarlo ...

Nessuno sorpreso è andato alla vecchia scuola. Non sto affermando nulla su questo codice, ma solo per divertimento:

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

Non sono sicuro di come funzionerebbe, ma è un semplice pezzo di codice. (Probabilmente l'ho fatto sembrare più complicato di quello che è.)

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

In alternativa, se conosci il numero massimo di livelli che puoi aspettarti, puoi semplicemente dichiarare un array e indicizzarlo. Probabilmente vorrai rendere questo array statico o costante.

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

Non ho abbastanza rappresentante per commentare la risposta di Adam, ma il modo migliore per farlo è così:

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

Devi verificare se numTimes è maggiore di zero, altrimenti otterrai un'eccezione.

Non ho visto questa soluzione. Lo trovo più semplice per dove mi trovo attualmente nello sviluppo di software:

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

Per uso generale, le soluzioni che coinvolgono la classe StringBuilder sono le migliori per ripetere stringhe multi-carattere. È ottimizzato per gestire la combinazione di un gran numero di stringhe in un modo che la semplice concatenazione non può e che sarebbe difficile o impossibile fare in modo più efficiente a mano. Le soluzioni StringBuilder mostrate qui utilizzano O (N) iterazioni per il completamento, un tasso fisso proporzionale al numero di volte che viene ripetuto.

Tuttavia, per un numero molto elevato di ripetizioni o in cui è necessario ottenere livelli elevati di efficienza, un approccio migliore è fare qualcosa di simile alla funzionalità di base di StringBuilder ma produrre copie aggiuntive dalla destinazione piuttosto che dalla stringa originale, come sotto.

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

Questo raddoppia la lunghezza della stringa di origine / destinazione con ogni iterazione, il che evita il sovraccarico di reimpostare i contatori ogni volta che passa attraverso la stringa originale, invece di leggere e copiare senza problemi la stringa ora molto più lunga, qualcosa che i moderni processori possono fare molto Più efficiente.

Utilizza un logaritmo in base 2 per trovare quante volte è necessario raddoppiare la lunghezza della stringa e quindi procede a farlo più volte. Poiché il resto da copiare è ora inferiore alla lunghezza totale da cui sta copiando, può quindi semplicemente copiare un sottoinsieme di ciò che ha già generato.

Ho usato il metodo Array.Copy () sull'uso di StringBuilder, poiché una copia del contenuto di StringBuilder in se stesso avrebbe il sovraccarico di produrre una nuova stringa con quel contenuto con ogni iterazione. Array.Copy () evita questo, pur continuando a operare con un tasso di efficienza estremamente elevato.

Questa soluzione richiede il completamento delle iterazioni O (1 + log N) , una velocità che aumenta logaritmicamente con il numero di ripetizioni (raddoppiare il numero di ripetizioni equivale a un'iterazione aggiuntiva), un notevole risparmio rispetto agli altri metodi, che aumentano in modo proporzionale.

Un altro approccio è considerare stringcome IEnumerable<char>e avere un metodo di estensione generico che moltiplica gli elementi in una raccolta per il fattore specificato.

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

Quindi nel tuo caso:

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

Stampa una riga con ripetizione.

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

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

È possibile creare un ExtensionMethod per farlo!

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

O usando la soluzione @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))
  }
}