String concatenate/shorten algorithm

Question

I want to publish server-messages on Twitter, for our clients.
Unfortunately, Twitter only allows posting 140 Chars or less. This is a shame.

Now, I have to write an algorithm that concatenates the different messages from the server together, but shortens them to a max of 140 characters.

It's pretty tricky.

---

CODE

static string concatinateStringsWithLength(string[] strings, int length, string separator) {
    // This is the maximum number of chars for the strings
    // We have to subtract the separators
    int maxLengthOfAllStrings = length - ((strings.Length - 1) * separator.Length);

    // Here we save all shortenedStrings
    string[] cutStrings = new string[strings.Length];

    // This is the average length of all the strings
    int averageStringLenght = maxLengthOfAllStrings / strings.Length;

    // Now we check how many strings are longer than the average string
    int longerStrings = 0;
    foreach (string singleString in strings)
    {
        if (singleString.Length > averageStringLenght)
        {
            longerStrings++;
        }
    }

    // If a string is smaller than the average string, we can more characters to the longer strings
    int maxStringLength = averageStringLenght;
    foreach (string singleString in strings)
    {
        if (averageStringLenght > singleString.Length)
        {
            maxStringLength += (int)((averageStringLenght - singleString.Length) * (1.0 / longerStrings));
        }
    }

    // Finally we shorten the strings and save them to the array
    int i = 0;
    foreach (string singleString in strings)
    {
        string shortenedString = singleString;
        if (singleString.Length > maxStringLength)
        {
            shortenedString = singleString.Remove(maxStringLength);
        }

        cutStrings[i] = shortenedString;
        i++;
    }


    return String.Join(separator, cutStrings);
}

---

Problem with this

This algorithm works, but it's not very optimized. It uses less characters than it actually could.

The main problem with this is that the variable longerStrings is relative to the maxStringLength, and backwards.

This means if I change longerStrings, maxStringLength gets changed, and so on and so on. I'd have to make a while loop and do this until there are no changes, but I don't think that's necessary for such a simple case.

Can you give me a clue on how to continue?

Or maybe there already exists something similar?

Thanks!

---

EDIT

The messages I get from the server look like this:

• Message
  • Subject
  • Date
  • Body
• Message
  • Subject
  • Date
  • Body

And so on.

What I want is to concatenate the strings with a separator, in this case a semi-colon.
There should be a max length. The long strings should be shortened first.

Example

This is a subject
This is the body and is a bit lon...
25.02.2013

This is a s...
This is the...
25.02.2013

I think you get the idea ;)

Answer 1

Five times slower than yours (in our simple example) but should use maximum avaliable space (no critical values checking):

static string Concatenate(string[] strings, int maxLength, string separator)
{
    var totalLength = strings.Sum(s => s.Length);
    var requiredLength = totalLength - (strings.Length - 1)*separator.Length;

    // Return if there is enough place.
    if (requiredLength <= maxLength)
        return String.Concat(strings.Take(strings.Length - 1).Select(s => s + separator).Concat(new[] {strings.Last()}));

    // The problem...
    var helpers = new ConcatenateInternal[strings.Length];
    for (var i = 0; i < helpers.Length; i++)
        helpers[i] = new ConcatenateInternal(strings[i].Length);

    var avaliableLength = maxLength - (strings.Length - 1)*separator.Length;
    var charsInserted = 0;
    var currentIndex = 0;

    while (charsInserted != avaliableLength)
    {
        for (var i = 0; i < strings.Length; i++)
        {
            if (charsInserted == avaliableLength)
                break;

            if (currentIndex >= strings[i].Length)
            {
                helpers[i].Finished = true;
                continue;
            }

            helpers[i].StringBuilder.Append(strings[i][currentIndex]);
            charsInserted++;
        }
        currentIndex++;
    }

    var unified = new StringBuilder(avaliableLength);
    for (var i = 0; i < strings.Length; i++)
    {
        if (!helpers[i].Finished)
        {
            unified.Append(helpers[i].StringBuilder.ToString(0, helpers[i].StringBuilder.Length - 3));
            unified.Append("...");
        }
        else
        {
            unified.Append(helpers[i].StringBuilder.ToString());
        }

        if (i < strings.Length - 1)
        {
            unified.Append(separator);
        }
    }

    return unified.ToString();
}

And ConcatenateInternal:

class ConcatenateInternal
{
    public StringBuilder StringBuilder { get; private set; }
    public bool Finished { get; set; }

    public ConcatenateInternal(int capacity)
    {
        StringBuilder = new StringBuilder(capacity);
    }
}