X sayısını defalarca döndürmek için kolay bir yol var mı?

Bir öğe derinliği dayalı bir dize önce girintiler belirli bir sayı eklemek çalışıyorum ve X kez tekrarlanan bir dize döndürmek için bir yol olup olmadığını merak ediyorum. Misal:

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

Yalnızca aynı karakteri tekrarlamak istiyorsanız, bir karakter ve tekrarlama sayısını kabul eden dize yapıcısını kullanabilirsiniz new String(char c, int count).

Örneğin, tire işaretini beş kez tekrarlamak için:

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

.NET 4.0 kullanıyorsanız, string.Concatile birlikte kullanabilirsiniz Enumerable.Repeat.

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

Yoksa Adem'in cevabı gibi bir şeyle giderdim .

Genellikle sebebi olmaz kullanarak tavsiye Andrey yanıtını basitçe olmasıdır ToArray()ile önlenir çağrı tanıtır gereksiz havai StringBuilderyaklaşımı Adam tarafından önerdi. Bununla birlikte, en azından .NET 4.0 gerektirmeden çalışır; ve hızlı ve kolaydır (ve verimlilik çok fazla endişe duymazsa sizi öldürmeyecektir).

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 için en performanslı çözüm

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

Birçok senaryo için, bu muhtemelen en iyi çözümdür:

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

Kullanım o zaman:

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

Bu, diğer cevaplar üzerine kuruludur (özellikle @ c0rd's). Basitliğin yanı sıra, tartışılan diğer tüm tekniklerin paylaşmadığı aşağıdaki özelliklere sahiptir:

• Sadece bir karakter değil, herhangi bir uzunlukta bir dizenin tekrarı (OP tarafından istendiği gibi).
• StringBuilderDepolama ön yerleşimi sayesinde verimli kullanım .

İstediğiniz dize yalnızca tek bir karakter içeriyorsa String.PadLeft kullanın .

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

Kredi vadesi burada

Dizenizi tekrarlayabilir (tek bir karakter olmaması durumunda) ve sonucu şu şekilde birleştirebilirsiniz:

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

Dan Tao'nun cevabı için gitmek istiyorum, ama .NET 4.0 kullanmıyorsanız böyle bir şey yapabilirsiniz:

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

Verilen cevabı seviyorum. Sames hatları boyunca geçmişte kullandığım olsa da:

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

Bu bir girinti oluşturmayı gerçekleştirecektir ancak teknik olarak soru bir dizeyi tekrarlamaktı. Dize girintisi> - <gibi bir şeyse, bu yanı sıra kabul edilen cevap işe yaramaz. Bu durumda, stringbuilder'ı kullanan c0rd'ın çözümü iyi görünüyor, ancak stringbuilder'ın yükü aslında en iyi performansı göstermeyebilir. Bir seçenek, bir dizeler dizisi oluşturmak, onu girinti dizeleriyle doldurmak ve sonra bunu tamamlamaktır. Katlamak için:

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

Hepimiz akıllı bir çözümü severiz, ancak bazen basit en iyisidir.

Uzantı Yöntemi Ekleme Projelerimin tamamında kullanıyorum:

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

Umarım birisi bundan faydalanabilir ...

Kimse eski okula gitmedi şaşırttı. Bu kod hakkında herhangi bir iddiada bulunmuyorum , ama sadece eğlence için:

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

Bunun nasıl performans göstereceğinden emin değilim, ancak kolay bir kod parçası. (Muhtemelen olduğundan daha karmaşık görünmesini sağladım.)

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

Alternatif olarak, bekleyebileceğiniz maksimum düzey sayısını biliyorsanız, bir dizi ve dizini buna bildirebilirsiniz. Muhtemelen bu diziyi statik veya sabit yapmak istersiniz.

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

Adam'ın cevabı hakkında yorum yapmak için yeterli temsilcim yok, ama bunu yapmanın en iyi yolu şudur:

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'ın sıfırdan büyük olup olmadığını kontrol etmelisiniz, aksi takdirde bir istisna alırsınız.

Bu çözümü görmedim. Şu anda yazılım geliştirmede olduğum yer için daha basit buluyorum:

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

Genel kullanım için, StringBuilder sınıfını içeren çözümler çok karakterli dizeleri yinelemek için en iyisidir. Çok sayıda dizenin birleşimini, basit birleştirme işleminin yapamayacağı ve elle daha verimli bir şekilde yapılması zor veya imkansız olacak şekilde işlemek için optimize edilmiştir. Burada gösterilen StringBuilder çözümleri tamamlamak için O (N) yinelemelerini kullanır, bu yineleme sayısı ile orantılı sabit bir orandır.

Bununla birlikte, çok sayıda tekrar için veya yüksek verimlilik seviyelerinin ortadan kaldırılması gerektiğinde, StringBuilder'in temel işlevine benzer bir şey yapmak, ancak orijinal dizeden ziyade hedeften ek kopyalar üretmek, aşağıda olduğu gibi.

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

Bu, her bir yinelemeyle kaynak / hedef dizginin uzunluğunu iki katına çıkarır, bu da orijinal dizeden her geçtiğinde sıfırlama sayaçlarının yükünü azaltır, bunun yerine modern işlemcilerin yapabileceği çok daha uzun dizeyi düzgün bir şekilde okumak ve kopyalamak daha verimli.

Dizenin uzunluğunu iki katına çıkarmak için kaç kez ihtiyaç duyduğunu bulmak için bir base-2 logaritması kullanır ve bunu birçok kez yapmaya devam eder. Kopyalanacak geri kalan artık kopyalandığı toplam uzunluktan daha az olduğundan, daha önce oluşturduğu şeyin bir alt kümesini kopyalayabilir.

StringBuilder içeriğinin bir kopyasını kendi içine her yineleme ile bu içerik ile yeni bir dize üreten yükü olurdu gibi StringBuilder kullanımı üzerinde Array.Copy () yöntemini kullandım. Array.Copy () bunu önler ve yine de son derece yüksek bir verimlilik oranıyla çalışır.

Bu çözüm , tekrar sayısı ile logaritmik olarak artan bir oran olan O (1 + log N) iterasyonlarını alır ( tekrarlama sayısının iki katına çıkarılması bir ek iterasyona eşittir), orantılı olarak artan diğer yöntemlere göre önemli bir tasarruf.

Diğer bir yaklaşım dikkate almaktır stringolarak IEnumerable<char>ve belirtilen faktör tarafından bir koleksiyon öğeleri çarpacaktır genel uzantısı yöntemi vardır.

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

Yani sizin durumunuzda:

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

Tekrarlı bir çizgi yazdırın.

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

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

Bunu yapmak için bir ExtensionMethod oluşturabilirsiniz!

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

Veya @ Dan Tao çözümü kullanarak:

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

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