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 Rust (1.15.1) (judge verdict: Accepted)

pub struct Poper<'a> {
	iter: std::str::SplitWhitespace<'a>,
}

impl<'a> Poper<'a> {
	pub fn new(iter: std::str::SplitWhitespace) -> Poper {
		Poper { iter: iter }
	}
	pub fn read<T: std::str::FromStr>(&mut self) -> T
	where
		<T as std::str::FromStr>::Err: std::fmt::Debug,
	{
		self.iter.next().unwrap().parse().unwrap()
	}
}

fn main() {
	let input = {
		use std::io::Read;
		let mut s = String::new();
		std::io::stdin().read_to_string(&mut s).unwrap();
		s
	};
	let mut iter = Poper::new(input.split_whitespace());

	let n: usize = iter.read();
	let a_list: Vec<u32> = (0..n).into_iter().map(|_| iter.read()).collect();

	let mut top: Option<(usize, u32)> = None;
	let mut sec: Option<(usize, u32)> = None;

	for a in a_list.into_iter().enumerate() {
		let a = match top {
			None => {
				top = Some(a);
				continue;
			}
			Some(t) => {
				if t.1 < a.1 {
					top = Some(a);
					t
				} else {
					a
				}
			}
		};
		match sec {
			None => {
				sec = Some(a);
				continue;
			}
			Some(t) => {
				if t.1 < a.1 {
					sec = Some(a);
				}
			}
		};
	}

	for i in 0..n {
		if let Some((j, a)) = top {
			if i == j {
				if let Some((_, b)) = sec {
					println!("{}", b);
				}
			} else {
				println!("{}", a);
			}
		}
	}

}