How to improve this array manipulation function?

I think you should separate your concerns: first split the array into groups, then process each group separately and finally combine them back into a single array.

I think doing this results in code that is easier to understand:

private static IEnumerable<List<int>> SplitInGroups(int[] permutation)
{
    var result = new List<int>();

    foreach (var i in permutation)
    {
        // is this a new series?
        if (result.Any() && ((result.Last() == 0) != (i == 0)))
        {
            yield return result;
            result = new List<int>();
        }
        result.Add(i);
    }

    if (result.Any())
        yield return result;
}

private static IEnumerable<int> ProcessGroup(int cap, List<int> group)
{
    // testing the first element is enough
    if (group[0] == 0)
        return group;

    int max = group.Max();
    if (max == cap)
        return Enumerable.Repeat(1, group.Count - 1).Concat(new[] { max });

    return group.Select(i => i == max ? max : 1);
}

private static int[] EquivalentOutput(int cap, int[] permutation)
{
    return SplitInGroups(permutation).SelectMany(g => ProcessGroup(cap, g)).ToArray();
}

Seems you might be overusing Linq since you are manipulating an array. Here is an example that to me is a bit more readable (although the readability could be improved further) and it is faster.

private static int[] EquivalentOutput(int cap, int[] permutation)
{
    int[] copy = permutation.ToArray();

    for (int i = 0; i < copy.Length; i++)
    {
        if (copy[i] == 0)
            continue;

        var consecutiveElements = copy.Skip(i).TakeWhile(x => x != 0).ToArray();
        var max = consecutiveElements.Max();
        if (max == cap)
        {
            for (int j = 0; j < consecutiveElements.Length - 1; j++)
                copy[i++] = 1;
            copy[i++] = cap;
        }
        else
        {
            for (int j = 0; j < consecutiveElements.Length; j++)
                copy[i] = copy[i++] == max ? max : 1;
        }
    }
    return copy;
}

Update: @svick pointed out that it feels a bit "weird" changing the loop variable inside the loop so I am providing an alternative which some people will consider easier to read...

private static int[] EquivalentOutput(int cap, int[] permutation)
{
    int[] copy = permutation.ToArray();

    int i = 0;
    while (i < copy.Length)
    {
        if (copy[i] > 0)
        {
            var consecutiveElements = copy.Skip(i).TakeWhile(x => x != 0).ToArray();
            var max = consecutiveElements.Max();
            if (max == cap)
            {
                for (int j = 0; j < consecutiveElements.Length - 1; j++)
                    copy[i++] = 1;
                copy[i++] = cap;
            }
            else
            {
                for (int j = 0; j < consecutiveElements.Length; j++)
                    copy[i] = copy[i++] == max ? max : 1;
            }
        }

        i++;
    }
    return copy;
}

I have got a better/faster F# solution:

let partitionWhile predicate list =
    let rec partitionRec good bad =
        match bad with
        | x::xs when predicate x -> partitionRec (x::good) xs
        | _ -> (List.rev good, bad)
    partitionRec [] list

let private reorder cap (array: int[]) =
    if Array.isEmpty array then
        array
    else
        let max = array |> Array.max
        if max = cap then
            let newArray = Array.create array.Length 1
            newArray.[array.Length-1] <- cap
            newArray
        else
            array |> Array.map (fun elem -> if elem = max then max else 1)

let private getZeroes todo = 
    todo |> partitionWhile (fun elem -> elem = 0)

let private getNumbers todo cap =
    let a, b = todo |> partitionWhile (fun elem -> elem <> 0)
    (reorder cap (Seq.toArray a), b)

let private getEquivalentPermutation (array: int[]) cap =

    let rec joinPartsRec finished todo =
        if List.isEmpty todo then finished |> Seq.toArray
        else
            let (zeroes, nextTodo) = getZeroes todo
            let (numbers, finalTodo) = getNumbers nextTodo cap
            let newFinished = Seq.concat [finished; seq zeroes; seq numbers]
            joinPartsRec newFinished finalTodo

    joinPartsRec Seq.empty (array |> Array.toList)