Problem:
Score : 300 points

Problem Statement

You are given a sequence of length N: A_1, A_2, ..., A_N.
For each integer i between 1 and N (inclusive), answer the following question:

Find the maximum value among the N-1 elements other than A_i in the sequence.

Constraints

2 \leq N \leq 200000

1 \leq A_i \leq 200000

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1
:
A_N

Output

Print N lines. The i-th line (1 \leq i \leq N) should contain the maximum value among the N-1 elements other than A_i in the sequence.

Sample Input 1

3
1
4
3

Sample Output 1

4
3
4

The maximum value among the two elements other than A_1, that is, A_2 = 4 and A_3 = 3, is 4.

The maximum value among the two elements other than A_2, that is, A_1 = 1 and A_3 = 3, is 3.

The maximum value among the two elements other than A_3, that is, A_1 = 1 and A_2 = 4, is 4.

Sample Input 2

2
5
5

Sample Output 2

5
5

Solution in C# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace C
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[] A = new int[n];
            for (int i = 0; i < n; i++)
            {
                int a = int.Parse(Console.ReadLine());
                A[i] = a;
            }
            var SA = A.OrderByDescending(x => x).ToArray();
            int max = SA[0];
            for(int i=0; i < n; i++)
            {
                if (max == A[i]) Console.WriteLine(SA[i]);
                else Console.WriteLine(max);
            }
        }
    }
}
//WA
//ここまでする必要ない気がする
//namespace C
//{
//    class Program
//    {
//        static void Main(string[] args)
//        {
//            int n = int.Parse(Console.ReadLine());
//            int[] A = new int[n];
//            var q = new PriorityQueue<int>(n);
//            for(int i=0; i < n; i++)
//            {
//                int a = int.Parse(Console.ReadLine());
//                A[i] = a;
//                q.Push(a);
//            }
//            for(int i=0; i < n; i++)
//            {
//                int temp =q.Peek();
//                if (temp == A[i])//二番目に大きい数を知りたいので、最大の数をいったん出して戻す、そうそう頻発しないからこれで平気？
//                {
//                    int max = q.Pop();
//                    int ans = q.Pop();
//                    q.Push(max);
//                    Console.WriteLine(ans);
//                }
//                else Console.WriteLine(temp);
//            }
//        }
//    }
//    class PriorityQueue<T> where T : IComparable<T>
//    {
//        private readonly T[] _array;
//        private readonly IComparer _comparer;
//        public int Count { get; private set; } = 0;
//        public T Root => _array[0];

//        public PriorityQueue(int capacity, IComparer comparer = null)
//        {
//            _array = new T[capacity];
//            _comparer = comparer;
//        }

//        /// <summary>
//        /// 要素を挿入する
//        /// </summary>
//        public void Push(T item)
//        {
//            _array[this.Count] = item;
//            Count += 1;

//            var n = Count - 1;                  // 末尾(追加した)のノードの番号
//            while (n != 0)
//            {
//                var parent = (n - 1) / 2;       // 親ノードの番号

//                if (Compare(_array[n], _array[parent]) > 0)
//                {
//                    Swap(n, parent);
//                    n = parent;
//                }
//                else
//                {
//                    break;
//                }
//            }
//        }

//        /// <summary>
//        /// 優先度の一番高いものを取り出す
//        /// </summary>
//        public T Pop()
//        {
//            Swap(0, this.Count - 1);            // 先頭要素を末尾にする
//            Count -= 1;

//            var parent = 0;                     // 親ノードの番号
//            while (true)
//            {
//                var child = 2 * parent + 1;     // 子ノードの番号
//                if (child > Count - 1) break;

//                // 値の大きい方の子を選ぶ
//                if (child < Count - 1 && Compare(_array[child], _array[child + 1]) < 0) child += 1;

//                // 子の方が親より大きければ入れ替える
//                if (Compare(_array[parent], _array[child]) < 0)
//                {
//                    Swap(parent, child);
//                    parent = child;
//                }
//                else
//                {
//                    break;
//                }
//            }

//            return _array[Count];
//        }
//        /// <summary>
//        /// 優先度の一番高いものを参照する
//        /// </summary>
//        public T Peek()
//        {
//            return _array[0];
//        }

//        /// <summary>
//        /// 大きいものから列挙していく
//        /// withPop = falseのときは順番関係なく取り出しもしないが素早く全要素を取得できる　
//        /// </summary>
//        public IEnumerable<T> GetAllElements(bool withPop = true)
//        {
//            int count = Count;
//            for (int i = 0; i < count; i++)
//            {
//                if (withPop) yield return Pop();
//                else yield return _array[count - i - 1];
//            }
//        }

//        private int Compare(T a, T b)
//        {
//            if (_comparer == null) return a.CompareTo(b);
//            return _comparer.Compare(a, b);
//        }

//        private void Swap(int a, int b)
//        {
//            var tmp = _array[a];
//            _array[a] = _array[b];
//            _array[b] = tmp;
//        }
//    }
//}