winamax2.cs

Player CreatePlayer()
{
    IEnumerable<int> ReadPlayerDeck()
    {
        var x = int.Parse(Console.ReadLine()!);
        for (var i = 0; i <= x; i++)
        {
            yield return Console.ReadLine()!.Trim('D', 'H', 'C', 'S') switch
            {
                ['J', ..] => 11,
                ['Q', ..] => 12,
                ['K', ..] => 13,
                ['A', ..] => 14,
                var card => int.Parse(card)
            };
        }
    }

    return new(new(ReadPlayerDeck().ToArray()), MicroArray<int>.Empty);
}

string Round(int n, Player player1, Player player2)
{
    switch (player1.Deck, player2.Deck)
    {
        case ([], []): return "PAT";
        case (_, []): return $"1 {n}";
        case ([], _): return $"2 {n}";
        case ([var card1, ..var rest1], [var card2, ..var rest2]):
        {
            var stack1 = player1.WarStack + card1;
            var stack2 = player1.WarStack + card2;

            if (card1 > card2)
            {
                return Round(
                    n + 1,
                    new(Deck: rest1 + stack1 + stack2, WarStack: MicroArray<int>.Empty),
                    new(Deck: rest2, WarStack: MicroArray<int>.Empty));
            }

            if (card2 > card1)
            {
                return Round(
                    n + 1,
                    new(Deck: rest1, WarStack: MicroArray<int>.Empty),
                    new(Deck: rest2 + stack1 + stack2, WarStack: MicroArray<int>.Empty));
            }

            switch (rest1, rest2)
            {
                case ([var p11, var p12, var p13, ..var rest12], [var p21, var p22, var p23, ..var rest22]):
                {
                    if (rest12 is [] || rest22 is [])
                        return "PAT";

                    return Round(
                        n,
                        new(Deck: rest1, WarStack: player1.WarStack + new[] { card1, p11, p12, p13 }),
                        new(Deck: rest2, WarStack: player2.WarStack + new[] { card2, p21, p22, p23 })
                    );
                }
                default:
                    return "PAT";
            }
        }
    }
}

Console.Write(Round(0, CreatePlayer(), CreatePlayer()));

record Player(MicroArray<int> Deck, MicroArray<int> WarStack);

readonly record struct MicroArray<T>(params T[] Array)
{
    public static MicroArray<T> Empty => new(System.Array.Empty<T>());

    private static T[] Concat(T[] first, T[] second)
    {
        var result = new T[first.Length + second.Length];
        first.CopyTo(result, 0);
        second.CopyTo(result, first.Length);
        return result;
    }

    public static implicit operator T[](MicroArray<T> array) => array.Array;

    public static MicroArray<T> operator +(MicroArray<T> first, MicroArray<T> second) =>
        new(Concat(first.Array, second.Array));

    public static MicroArray<T> operator +(MicroArray<T> first, T[] second) =>
        new(Concat(first.Array, second));

    public static MicroArray<T> operator +(MicroArray<T> first, T second) =>
        new(Concat(first.Array, new[] { second }));

    public T this[int index]
    {
        get => Array[index];
        set => Array[index] = value;
    }

    public MicroArray<T> this[Range range] => new(Array[range]);

    public int Length => Array.Length;
}