Ytdyklly

I wrote a function for repeating a string to a certain length.

For example:

ExpandString("Test", 11); 



// output: "TestTestTes"

Are there any optimizations or fixes that can be done to this function?

private string ExpandString(string str, int length)

{

    if (length <= str.Length) return str.Substring(0, length);

    var result = str;

    for (var i = str.Length; i < length; i++)

    {

        result += str[i % str.Length];

    }

    return result;

}

Instead of adding a character at a time, double the string as long as you can without making it too long, then just add the rest of the characters:

private static string ExpandString(string str, int length) {

  if (length <= str.Length) return str.Substring(0, length);

  while (str.Length * 2 <= length) {

    str += str;

  }

  if (str.Length < length) {

    str += str.Substring(0, length - str.Length);

  }

  return str;

}

You don't need a StringBuilder for this. This method is actually almost twice as fast as using a StringBuilder.

Here is the result for a test run of calling ExpandString("Test", 100) 100000 times each, for the orginal method, the method suggested by cHao, and the method suggested above:

Original:      00:00:00.5795951

StringBuilder: 00:00:00.0372573

This:          00:00:00.0204482

OK, first, for the most straightforward optimization. Use a StringBuilder.

The way your code currently works, it creates length - str.Length intermediate strings. Besides creating lots of unnecessary garbage, you're copying longer and longer strings over and over again to add one character each time.

If you use a StringBuilder instead, you can avoid most of those copies.
You could try something like...

using System.Text;



...



private string ExpandString(string str, int length)

{

    if (length <= str.Length) return str.Substring(0, length);

    var result = new StringBuilder(str);

    for (var i = str.Length; i < length; i++)

    {

        result.Append(str[i % str.Length]);

    }

    return result.ToString();

}

(I don't particularly like the StringBuilder starting with a copy of str already in it. I'm literally just replacing the String.)

But you're also copying one character at a time. While this isn't as big an issue as the concatenation, you can do better by inserting as many whole copies of str as you can.

private string ExpandString(string str, int length)

{

    // BTW, you already know how big the result should be, so just

    // tell the StringBuilder its capacity to prevent unneeded resizes.

    // Side benefit: if the result is too long, you'll find out fairly quickly.

    var result = new StringBuilder(length, length);



    var wholeCopies = length / str.Length;

    for (var i = 0; i < wholeCopies; ++i)

    {

        result.Append(str);

    }



    // now append the last chunk, a possibly-zero-length prefix of `str`

    result.Append(str, 0, length % str.Length);



    return result.ToString();

}

Note that the short-string optimization has been removed. You can add it back in if you really really want to micro-optimize, but at this point, it's not gaining you nearly as much as it was.

I will not repeat what's been said in the other review, but I would like to share an alternative approach.

First, we know the length of the return string, so we create a char array which we'll pass to the (Char) string ctor in the return statement.

var chars = new Char[length];

Next, populate the array by using the modulus operator to "translate" the chars index (the length variable in the example below) to correct str index.

while (length > 0)

{

    length--;

    chars[length] = str[(length % str.Length)];

}

Finally, return a new string.

return new String(chars);

Here's how the method should look like if placed in an extension class:

public static String Expand(this String value, Int32 length)

{



    if (value == null)

    {

        throw new ArgumentNullException("value");

    }

    else if (length < 0)

    {

        throw new ArgumentOutOfRangeException("length");

    }



    var chars = new Char[length];



    for (Int32 index = 0; (index < length); index++)

    {

        chars[index] = value[(index % value.Length)];

    }



    return new String(chars);



}

what would you do if you want to expand string to longer than Int type. say Long type?
e.g. ExpandString(string str, long length)