Q:

Group chars in an array if they have the same start and end elements

I am trying to work through this challenge, I have come up with a solution but however I look at the problem statement and the examples provided I cant help but come to the conclusion that the "example 3" and "test case 2" as explained in the problem statement are wrong.
I would appreciate it if someone could review my solution and the problem statement and provide any feedback.

problem statement:
You are working on developing a movie with Amazon Video that consists
  of a series of shots: short pieces of video from a particular camera
  angle. You want to devise an application to easily group identical
  shots in a video into scenes (a sequence of shots). Shots are
  identical when they are labeled with the same letter, and everything
  in between identical shots is considered part of same scene. There is
  already an algorithm that breaks the video up into shots and labels
  them.
Write a function which will partition a sequence of shot labels into
  minimal subsequences so that a shot label only appears in a single
  subsequence. The output should be the length of each subsequence.
Input The input to the function/method consists of an argument -
  inputList, a list of characters representing the sequence of shots.
Output Return a list of integers representing the length of each
  scene, in the order in which it appears in the given sequence of
  shots.
Examples Example 1: Input inputList = [a, b, c]
Output [1, 1, 1]
Explanation: Because there are no recurring shots, all shots can be in
  the minimal length 1 subsequence.
Example 2: Input inputList = [a, b, c, a]
Output [4]
Explanation: Because ‘a’ appears more than once, everything between
  the first and last appearance of ‘a’ must be in the same list.
Example 3: Input: inputList = [a, b, a, b, c, b, a, c, a, d, e, f, e,
  g, d, e, h, i, j, h, k, l, i, j]
Output: [9, 7, 8]
Testcase 1: Input: [a, b, c, d, a, e, f, g, h, i, j, e]
Expected Return Value: 5 7
Testcase 2: Input: [z, z, c, b, z, c, h, f, i, h, i]
Expected Return Value: 6 5

my solution and test cases:
using System.Collections.Generic;
using Xunit;

namespace LengthEachSceneChallenge
{
  public class Task
  {
    public List<int> lengthEachScene(List<char> inputList)
    {
        var counts = new List<int>();
        for (int i = 0; i < inputList.Count; i++)
        {
            var item = inputList[i];
            var lastIndex = inputList.LastIndexOf(item);

            if (i == lastIndex)
            {
                counts.Add(1);
            }
            else
            {
                counts.Add(i == 0 ? lastIndex + 1 : lastIndex - i + 1);
                i = lastIndex;
            }
        }
        return counts;
    }

    [Fact]
    public void Example1()
    {
        var data = new List<char>() { 'a', 'b', 'c' };

        Assert.Equal(new List<int>() { 1, 1, 1 }, lengthEachScene(data));
    }

    [Fact]
    public void Example2()
    {
        var data = new List<char>() { 'a', 'b', 'c', 'a' };

        Assert.Equal(new List<int>() { 4 }, lengthEachScene(data));
    }

    [Fact]
    public void Example3()
    {
        var data = new List<char>() { 'a', 'b', 'a', 'b', 'c', 'b', 'a', 'c', 'a', 'd', 'e', 'f', 'e', 'g', 'd', 'e', 'h', 'i', 'j', 'h', 'k', 'l', 'i', 'j' };

        Assert.Equal(new List<int>() { 9, 7, 8 }, lengthEachScene(data));
    }

    [Fact]
    public void TestCase1()
    {
        var data = new List<char>() { 'a', 'b', 'c', 'd', 'a', 'e', 'f', 'g', 'h', 'i', 'j', 'e' };

        Assert.Equal(new List<int>() { 5, 7 }, lengthEachScene(data));
    }

    [Fact]
    public void TestCase2()
    {
        var data = new List<char>() { 'z', 'z', 'c', 'b', 'z', 'c', 'h', 'f', 'i', 'h', 'i' };

        Assert.Equal(new List<int>() { 6, 5 }, lengthEachScene(data));
    }
}

}
count Length of each sequence of chars according to start and end characters

A:

I agree that the question takes a little time to understand. Once I understood it, I felt compelled to code a solution, which is below.
The solution you built gets the length between each letter, but the question is more nuanced.  The formal logic is in the code, but in plain English: A scene only ends when all of the shots it contains are done.
On a related note, I would consider your solution to be a "procedural" approach to solving the problem. 
As an object-oriented language, C# lends itself to the "object-oriented" approach, which to me means modeling the domain with classes. In this case, a Movie class and a Scene class. I initially thought there would be a Shot class, but in this example shots are reduced to character labels, so it was unnecessary. 
Of course a real solution would definitely contain a Shot class, perhaps with additional properties like Camera, Lighting, and Description.
Here is the output:

Here is the sample code:
using System;
using System.Collections.Generic;
using System.Linq;

public class App_MovieScenes
{
    public void Run()
    {
        var shotList = new char[] { 'a', 'b', 'a', 'b', 'c', 'b', 'a', 'c', 'a', 'd', 'e', 'f', 'e', 'g', 'd', 'e', 'h', 'i', 'j', 'h', 'k', 'l', 'i', 'j' };
        var movie = new Movie(shotList);
        movie.ToScenes();
        movie.Output();
    }        
}

public class Movie
{
    private char[] shotList;

    public List<Scene> Scenes { get; private set; }

    public Movie(char[] shotList) => this.shotList = shotList ?? new char[1];

    public void ToScenes()
    {
        var all = new string(shotList);
        var groups = new List<List<char>>();
        var group = new List<char>();
        var index = 0;

        all.ToList().ForEach(c =>
        {
            var remaining = all.Substring(index++);
            var groupIsEmpty = !group.Any();
            var anyInGroupHasMore = group.Any(g => remaining.Contains(g));

            if (groupIsEmpty || !anyInGroupHasMore)
            {
                ///start a new group
                group = new List<char>();
                group.Add(c);
                groups.Add(group);
            }
            else
            {
                ///add to current group
                group.Add(c);
            }
        });

        Scenes = groups.Select(g => new Scene(g)).ToList();
    }

    public void Output() => Console.WriteLine(ToString());

    public override string ToString() => string.Join("\n", Scenes.Select(s => s.ToShotList()));
}

public class Scene
{
    public List<char> Shots { get; private set; }
    public int Length => Shots.Count;

    public Scene(List<char> shots) => Shots = shots;

    public string ToShotList() => $"{Length}\t{string.Join(", ", Shots)}";
}

