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: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting;
using System.Security.Cryptography;

namespace Atcoder
{
    class Program
    {
        static void Main(string[] args)
        {
            var a = ReadLineIntSpilit();
            var re = 0;

            if(a[3] >= a[0]) {
                re += a[0];
                a[3] -= a[0];
            }else if(a[3] < a[0] && a[3] > 0) {
                re += 1 * a[3];
                Console.WriteLine(re);
                return;
            }

            if(a[3] >= a[1] && a[3] > 0) {
                a[3] -= a[1];
            }else if(a[3] < a[1] && a[3] > 0) {
                Console.WriteLine(re);
                return;
            }

            if(a[3] >= a[2] && a[3] > 0) {
                re += -1 * a[3];
                a[3] -= a[2];
            }else if(a[3] < a[2] && a[3] > 0) {
                re -= 1 * a[3];
                Console.WriteLine(re);
                return;
            }


            Console.WriteLine(re);
        }

        //メモ

        //アルゴリズム

        //・全探索解

        /*
         * 例 [A, B, C]
         *
         *  A - B, A - C
         *  B - C
         * 
         *   for (int i = 0; i < n; i++) {
         *  
         *       for (int j = i + 1; j < n; j++) {
         *
         *           array[i], array[j]
         *
         *       }
         *   }
         */

        // ・配列の前後を見る

        /*
         *  例 array[1, 2, 3, 4, 5]
         *  
         *  r = 3;
         * 
         *  array[i - 1] => 1
         *  array[i] => 2
         *  array[i + 1] => 3
         * 
         * //範囲
         * int r = 3;
         * 
         * for(int i = 1; i <= array.Length - r; i++) { }
         * 
         */

        //配列 --------------------

        //降順
        //Array.Sort(h);
        //Array.Reverse(h);

        //合計値
        //array.Sum();

        //最大値
        //List.Sort(); List[Count() - 1] 

        //連続の整数配列を作成
        //
        // 1, 2, 3, 4, 5,..., n
        //var continuous = Enumerable.Range(1, n).ToList();

        //--------------------

        //切り捨て

        //double d = Math.Floor(n);

        //切り上げ

        //double d = Math.Celling(n);

        //kのn乗
        //(int) Math.Pow(k, n);

        //for文の逆
        //for(int i = array.Length - 1; i >= 0; i--) { }

        /// <summary>
        /// 最大公約数
        /// </summary>
        public static long Gcd(long a, long b)
        {
            while (true) {
                if (a < b) { long tmp = b; b = a; a = tmp; }
                if (a % b == 0) return b;
                var x = a;
                a = b;
                b = x % b;
            }
        }

        /// <summary>
        /// 最小公倍数
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public static long Lcm(long a, long b) => a / Gcd(a, b) * b;

        /// <summary>
        /// コンビネーション
        /// </summary>
        static int nCm(int n, int m)
        {
            if (m == 0) return 1;
            if (n == 0) return 0;
            return n * nCm(n - 1, m - 1) / m;
        }

        /// <summary>
        /// 数字配列の重複をカウント
        /// </summary>
        public static int DistinctInt(IEnumerable<int> array)
        {
            var q = array.Distinct().Count();
            return array.Count() - q;
        }

        /// <summary>
        /// 文字配列の重複をカウント
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static int DistinctString(IEnumerable<string> array)
        {
            var q = array.Distinct().Count();
            return array.Count() - q;
        }

        public static string ReadLine() => Console.ReadLine();
        public static int ReadLineInt() => int.Parse(Console.ReadLine());
        public static long ReadLineLongInt() => long.Parse(Console.ReadLine());
        public static string[] ReadLineStringSplit(char a = ' ') => ReadLine().Split(a).ToArray();
        public static int[] ReadLineIntSpilit(char a = ' ') => ReadLine().Split(a).Select(x => int.Parse(x)).ToArray();
        public static long[] ReadLineLongSpilit(char a = ' ') => ReadLine().Split(a).Select(x => long.Parse(x)).ToArray();
        static string[] GetAlphaLowerArray() => new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };
        static string[] GetAlphaUpperArray() => new string[] { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
    }
}