Combine neighboring parts of an array based on a condition

Question

I have written this code which takes a one dimensional array, for example:

{"abc","ade","sss","fgw","asd","lka","o"}

and turns it into an array of arrays, combining the elements which do not meet the condition.

For the condition m=>!m.Contains("a") for example, the output will be:

{{"abc","ade"},{"sss"},{"fgw"},{"asd","lka"},{"o"}}

The code works, but i suspect there is a linq way to do it, and refrain from using temporary variables that i dislike.

    public static string[][] combineBy(this string[] inp,Func<string,bool> f)
    {
        List<string[]> holdElements = new List<string[]>();
        while (inp.Length!=0)
        {
            if (f.Invoke(inp[0]))
            {
                holdElements.Add(new string[] { inp[0] });
                inp = inp.Skip(1).ToArray();
            }
            else
            {
                var toAdd = inp.TakeWhile(n => !f.Invoke(n));
                holdElements.Add(toAdd.ToArray());
                inp = inp.Skip(toAdd.Count()).ToArray();
            }
        }
        return holdElements.ToArray();
    }

Answer 1

Some general remarks about your code:

• combineBy use PascalCase for method names
• f it's not a good parameter name, if it's a condition function they are usualy named predicate
• predicate.Invoke(...) - you can call it directly with predicate(...)
• values.TakeWhile(n => !predicate(n)) - do not enumerate it twice, call ToArray and use it in the subsequent lines
• if you like it the LINQ way you can write values.Any() instead of values.Length != 0 and values.First() instead of values[0] also this new string[] { inp[0] } could be turned into values.Take(1).ToArray()
• don't use abbreviations for variables like inp or f, use full names like values and predicate

x

public static string[][] CombineBy(this string[] values, Func<string, bool> predicate)
{
    var result = new List<string[]>();
    while (values.Any())
    {
        if (predicate(values.First()))
        {
            result.Add(values.Take(1).ToArray());
            values = values.Skip(1).ToArray();
        }
        else
        {
            var toAdd = values.TakeWhile(n => !predicate(n)).ToArray();
            result .Add(toAdd);
            values = values.Skip(toAdd.Length).ToArray();
        }
    }
    return result.ToArray();
}

---

Unfortuantely your code doesn't seem to work and returns invalid results. This should do:

public static List<List<string>> CombineBy(this string[] values, Func<string, bool> predicate)
{
    var result = new List<List<string>>();

    foreach (var value in values)
    {
        if (predicate(value))
        {
            if (!result.Any() || !predicate(result.Last().Last()))
            {
                result.Add(new List<string>());
            }
            result.Last().Add(value);
        }
        else
        {
            result.Add(new List<string> { value });
        }
    }

    return result;
}

or even without loops:

public static List<List<string>> CombineBy3(this string[] values, Func<string, bool> predicate)
{
    var result = values.Aggregate(new List<List<string>>(), (current, next) =>
    {
        if (predicate(next))
        {
            if (!current.Any() || !predicate(current.Last().Last()))
            {
                current.Add(new List<string>());
            }
            current.Last().Add(next);
        }
        else
        {
            current.Add(new List<string> { next });
        }
        return current;
    });
    return result;
}

Answer 2

I hate to break it to you but your code doesn't work. For the input you've given, your code returns:

{ {"abc"}, {"ade"}, {"sss", "fgw"}, {"asd"}, {"lka"}, {"o"} }

Which is clearly incorrect. Your code is also needlessly complex - you should be able to do this with one iteration through the source array:

public static IEnumerable<IEnumerable<string>> CombineBy(this string[] input, Func<string, bool> predicate)
{
    if (input == null) 
    {
        throw new ArgumentNullException(nameof(input));
    }
    return CombineByCore(input, predicate);
}

private static IEnumerable<IEnumerable<string>> CombineByCore(string[] input, Func<string, bool> predicate)
{
    var buffer = new List<string>();
    foreach (var inputString in input)
    {
        if (predicate(inputString))
        {
            buffer.Add(inputString);
        }
        else
        {
            if (buffer.Any())
            {
                yield return buffer;
                buffer = new List<string>();
            }
            yield return new List<string>() { inputString };
        }
    }
    if (buffer.Any())
    {
        yield return buffer;
    }
}

Answer 3

It's hard to find a "linq way" to accomplish that... However, you could use the GroupBy method with 2 helper variables:

public static IEnumerable<IEnumerable<string>> CombineBy(this IEnumerable<string> input, Func<string, bool> prediction)
{
    bool? prevPredict = null;
    int group = 0;
    return input.GroupBy(i =>
    {
        var predict = prediction(i);
        if (!predict || predict != prevPredict)
            group++;
        prevPredict = predict;
        return group;
    });
}