public class inversiones {
	/**
	 * The main method.
	 *
	 * @param args the arguments
	 * @throws IOException Signals that an I/O exception has occurred.
	 */
	
	public static void main(String[] args) throws IOException {
		Scanner leer = new Scanner(new File("C:\\\\Users\\\\Downloads\\\\InversionOf1.dat"));
		int nCases = leer.nextInt();
		
		double a[] = new double[nCases];
		for(int i=0; i<nCases; i++) {
			a[i]= leer.nextInt();
		}
		
		System.out.println("El número de inversiones que tiene el array dado es: " +ordenar(a, 0, a.length-1));
	}
	/**
	 * Merge. Método valido para ordenar el array.
	 *
	 * @param a2 array que queremos ordenar
	 * @param a numero de la izquierda
	 * @param middle la mitad entre el límite inferior y superior
	 * @param b numero de la derecha
	 * @return el número de inversiones acontecidas durante el recorrido del método
	 */
	private static int merge (double[] a2, int a, int middle, int b) {
		int cont=0;
		int i=0, j=0, k=a;
		
		double[] left = Arrays.copyOfRange(a2, a, middle+1);
		double [] right = Arrays.copyOfRange(a2, middle+1, b+1);
		
		/*Comparar antes del contador si el elemento que tenemos que sumar es uno o no, 
		Si es uno que sume y si no que no sume*/
		while(i<left.length && j<right.length) {
			if(left[i] <= right[j]) {
				a2[k++]=left[i++];
				i++;
			}else {
				a2[k++]=right[j++];
				if(a2[k++] == 1){
					cont += (middle+1)-(a+j);
					//cont++;
				}
				//cont += (middle+1)-(a+i);	
				j++;
			}				
			a++;
		}
		
		while(i<left.length) {
			a2[k++] = left[i++];
		}
	    while (j < right.length) {
	        a2[k++] = right[j++];	       
		}
		return cont;
	}

	
	/**
	 * Método para ordenar el array, recursivo. Parecido a MergeSort.
	 *
	 * @param a2 array a ordenar
	 * @param min, limite inferior del array que queremos ordenar 
	 * @param max, limite superior del array que queremos ordenar 
	 * @return numero de inversiones necesarias para ordenar el array
	 */
	private static int ordenar(double[] a2, int min, int max) {
		int cont=0;
		int middle = (min+max)/2;
		if(min<max) {
			cont = ordenar (a2, min, middle); //ordenar la izquierda
			cont = cont + ordenar (a2, middle + 1, max); //ordenar la derecha
			cont = cont + merge (a2, min, middle, max);
		}
		return cont;
	}
	
	
}