Problem:
Score : 600 points

Problem Statement

Snuke has an integer sequence, a, of length N. The i-th element of a (1-indexed) is a_{i}.

He can perform the following operation any number of times:

Operation: Choose integers x and y between 1 and N (inclusive), and add a_x to a_y.

He would like to perform this operation between 0 and 2N times (inclusive) so that a satisfies the condition below. Show one such sequence of operations.
It can be proved that such a sequence of operations always exists under the constraints in this problem.

Condition: a_1 \leq a_2 \leq ... \leq a_{N}

Constraints

2 \leq N \leq 50

-10^{6} \leq a_i \leq 10^{6}

All input values are integers.

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_{N}

Output

Let m be the number of operations in your solution. In the first line, print m.
In the i-th of the subsequent m lines, print the numbers x and y chosen in the i-th operation, with a space in between.
The output will be considered correct if m is between 0 and 2N (inclusive) and a satisfies the condition after the m operations.

Sample Input 1

3
-2 5 -1

Sample Output 1

2
2 3
3 3

After the first operation, a = (-2,5,4).

After the second operation, a = (-2,5,8), and the condition is now satisfied.

Sample Input 2

2
-1 -3

Sample Output 2

1
2 1

After the first operation, a = (-4,-3) and the condition is now satisfied.

Sample Input 3

5
0 0 0 0 0

Sample Output 3

0

The condition is satisfied already in the beginning.

Solution in Java (OpenJDK 11.0.6) (judge verdict: Accepted)

import java.util.Scanner;
import java.util.stream.IntStream;

/**
 * 解説通りに作成したソースコード
 */
public class Main {

	public static void main(String[] args) {
		try (Scanner scanner = new Scanner(System.in)) {
			int n = scanner.nextInt();
			int[] a = IntStream.range(0, n).map(i -> scanner.nextInt()).toArray();
			if (isIncreasing(a)) {
				System.out.println(0);
				return;
			}
			int maxValue = 0, maxIndex = 0;
			int minValue = Integer.MAX_VALUE, minIndex = 0;
			for (int i = 0; i < a.length; i++) {
				if (a[i] > maxValue) {
					maxValue = a[i];
					maxIndex = i + 1;
				}
				if (a[i] < minValue) {
					minValue = a[i];
					minIndex = i + 1;
				}
			}
			if ((maxValue <= 0) || (minValue >= 0)) {
				System.out.println(n - 1);
				// すべてが負の数か正の数の場合
				printSteps(n, (maxValue <= 0));
			} else {
				int fromIndex = (Math.abs(maxValue) > Math.abs(minValue)) ? maxIndex : minIndex;
				System.out.println(2 * n - 1);
				printAddSteps(n, fromIndex);
				printSteps(n, (fromIndex == minIndex));
			}
		}
	}

	/**
	 * @param a 入力配列
	 * @return 入力配列は単調増加かどうか
	 */
	static boolean isIncreasing(int[] a) {
		for (int i = 1; i < a.length; i++) {
			if (a[i] < a[i - 1]) {
				return false;
			}
		}
		return true;
	}

	/**
	 * 長さnの数列の計算ステップを出力する
	 * 
	 * @param n       数列の長さ
	 * @param reverse 逆順かどうか
	 */
	private static void printSteps(int n, boolean reverse) {
		if (reverse) {
			IntStream.range(1, n).map(i -> n - i).forEach(i -> System.out.println((i + 1) + " " + i));
		} else {
			IntStream.range(1, n).forEach(i -> System.out.println(i + " " + (i + 1)));
		}
	}

	/**
	 * 数列のすべてにindexの数字を足す計算ステップを出力する
	 * 
	 * @param n     数列の長さ
	 * @param index 加算もととなるindex
	 */
	private static void printAddSteps(int n, int index) {
		IntStream.rangeClosed(1, n).forEach(i -> System.out.println(index + " " + i));
	}
}