Problem:
Score : 200 points

Problem Statement

We have A cards, each of which has an integer 1 written on it. Similarly, we also have B cards with 0s and C cards with -1s.

We will pick up K among these cards. What is the maximum possible sum of the numbers written on the cards chosen?

Constraints

All values in input are integers.

0 \leq A, B, C

1 \leq K \leq A + B + C \leq 2 \times 10^9

Input

Input is given from Standard Input in the following format:

A B C K

Output

Print the maximum possible sum of the numbers written on the cards chosen.

Sample Input 1

2 1 1 3

Sample Output 1

2

Consider picking up two cards with 1s and one card with a 0.
In this case, the sum of the numbers written on the cards is 2, which is the maximum possible value.

Sample Input 2

1 2 3 4

Sample Output 2

0

Sample Input 3

2000000000 0 0 2000000000

Sample Output 3

2000000000

Solution in C# (.NET Core 3.1.201) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text.RegularExpressions;
namespace AtCoder_Core
{
    class Program
    {
        static long CombinationL(long m, long n)
        {
            if (m == n || n == 0) return 1;

            long ans = 1;
            for (long i = 1; i <= n; i++)
            {
                ans = ans * (m - i + 1) / i;
            }
            return ans;
        }
        static void Main(string[] args)
        {
            var line = Console.ReadLine().Trim().Split(' ').Select(x => int.Parse(x)).ToArray();
            int A = line[0];
            int B = line[1];
            int C = line[2];
            int K = line[3];
            int i;
            int max = 0;
            var lc = CombinationL((A + B + C), K);
            if (lc == 1)
            {
                max = (A * 1) + (C * -1);
            }
            int[] arr = new int[A + B + C];
            int[] arrA = new int[A];
         
            if ((A + B + C) == K)
            {
               
            }
            else
            {
                for (i = 0; i < A; i++)
                {
                    arr[i] = 1;
                }


                for (; i < A + B; i++)
                {
                    arr[i] = 0;
                }

                for (; i < A + B + C; i++)
                {
                    arr[i] = -1;
                }

                var combinations = Combination.Enumerate(arr, K, withRepetition: false);
                foreach (var elem in combinations)
                {
                    if (max < elem.Sum())
                    {
                        max = elem.Sum();
                    }
                }
            }

            Console.WriteLine(max);

        }
        public static class Combination
        {
            public static IEnumerable<T[]> Enumerate<T>(IEnumerable<T> items, int k, bool withRepetition)
            {
                if (k == 1)
                {
                    foreach (var item in items)
                        yield return new T[] { item };
                    yield break;
                }
                foreach (var item in items)
                {
                    var leftside = new T[] { item };

                    // item よりも前のものを除く （順列と組み合わせの違い)
                    // 重複を許さないので、unusedから item そのものも取り除く
                    var unused = withRepetition ? items : items.SkipWhile(e => !e.Equals(item)).Skip(1).ToList();

                    foreach (var rightside in Enumerate(unused, k - 1, withRepetition))
                    {
                        yield return leftside.Concat(rightside).ToArray();
                    }
                }
            }
        }

    }
}