Trochę bardziej zaawansowane Linq

public static List<int> Resolve(List<int> a, List<int> b)
        {
            var ar = a.Select(x => x).Count(x => x > b[a.IndexOf(x)]);
            var br = b.Select(x => x).Count(x => x > a[b.IndexOf(x)]);
            return new List<int> {ar, br};
        }

  List<int> a = new List<int> { 1, 2, 3, 1, 5, 8, 1 };
  List<int> b = new List<int> { 2, 2, 3, 4, 0, 1, 9 };


            var xxxxxx = a.Select((item, index) => new { item, index })
                        .Join(b.Select((item, index) => new { item, index }),
                          aItem => aItem.index,
                          bItem => bItem.index,
                          (aItem, bItem) => new { greater = aItem.item > bItem.item ? "a" : aItem.item == bItem.item ? "none" : "b" })
                        .Where(x => x.greater != "none")
                        .OrderBy(x => x.greater)
                        .GroupBy(x => x.greater)
                        .Select(x => x.Count());


            var wtf = a.Select((item, index) => new { item, index }).Aggregate(new Dictionary<string, int>(),
                (result, aListItemWithIndex) =>
                {
                    string key = aListItemWithIndex.item > b[aListItemWithIndex.index] ? "a" :
                        aListItemWithIndex.item < b[aListItemWithIndex.index] ? "b" : "none";
                    int value = aListItemWithIndex.item > b[aListItemWithIndex.index] ? 1
                        : aListItemWithIndex.item == b[aListItemWithIndex.index] ? 0 : 1;

                    if (!result.TryAdd(key, value))
                    {
                        result[key] += value;
                    }
                    return result;
                }).Where(x => x.Key != "none").OrderBy(x => x.Key).Select(x => x.Value);

a.Zip(b, (x, y) => new // przyjmujesz parę elementów z kolekcji a i b jako (x, y)
	{
		x = x > y ? 1 : 0, // zwróć obiekt z dwoma własnościami mówiącymi kolejno czy x>y i czy y>x
		y = y > x ? 1 : 0
	})
	.Aggregate(
		new int[2], // typ zwróconego obiektu i zarazem wartość początkowa - pusta tablica dwuelementowa
		(result, row) => { result[0] += row.x; result[1] += row.y; return result; } // dodajemy wartości do wyniku i zwracamy ten sam obiekt
	);

a.Zip(b, (x, y) => x - y) // zwracasz tylko różnicę elementów - ujemny wynik oznacza że y był większy od x
	.Aggregate(
		new int[2], // typ zwróconego obiektu i zarazem wartość początkowa - pusta tablica dwuelementowa
		(result, row) =>
		{
				result[0] += row > 0 ? 1 : 0;
				result[1] += row < 0 ? 1 : 0;
				return result;  // dodajemy wartości do wyniku i zwracamy ten sam obiekt
		}
	).Dump();

           
List<int> a = new List<int> { 1, 2, 3, 1, 5, 8, 1 };
           
List<int> b = new List<int> { 2, 2, 3, 4, 0, 1, 9 };

            
var x = a.Select((item, index) => new { a = item > b[index] ? 1 : 0, b = b[index] > item ? 1 : 0 }).Aggregate(new List<int>(2) { 0, 0 }, (result, curr) => { result[0] += curr.a; result[1] += curr.b; return result; });

 a.Zip(b).GroupBy(x => new { }).Select(x => new 
            { 
                first = x.Count(s => s.First > s.Second), 
                second = x.Count(s => s.First < s.Second)
            });