Count inversions in an array

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace OneCompiler
{
	public class Program
	{
		public static void Main(string[] args)
		{
			int n = int.Parse(Console.ReadLine());
			
			int[] arr = Array.ConvertAll(Console.ReadLine().Split(" "), new Converter<string,int>(StringToInteger));
			
			var inversionCount = CountInversionUsingMergeSort(arr);
			
			Console.Write(inversionCount);
		}
		
		private static int StringToInteger(string s)
		{
		  return int.Parse(s);
		}
		
		private static int CountInversion(int[] arr)
		{
		  int n = arr.Length;
		  
		  int inversionCount = 0;
		  
		  for (int i = 0; i < n; i++)
		  {
		    for (int j = i + 1; j < n; j++)
		    {
		      if (arr[i] > arr[j])
		      {
		        inversionCount++;
		      }
		    }
		  }
		  
		  return inversionCount;
		}
		
		private static int CountInversionUsingMergeSort(int[] arr)
		{
		  int n = arr.Length;
		  
		  int[] temp = new int[n];
		  
		  return MergeSort(arr, temp, 0, n - 1);
		}
		
		private static int MergeSort(int[] arr, int[] temp, int left, int right)
		{
		  int inversionCount = 0; 
		  
		  if (left == right)
		  {
		    return inversionCount;
		  }
		  else
		  {
		    var midpoint = (left + right) / 2;
		    
		    inversionCount += MergeSort(arr, temp, left, midpoint);
		    inversionCount += MergeSort(arr, temp, midpoint + 1, right);
		    inversionCount += Merge(arr, temp, left, midpoint + 1, right);
		    
		    return inversionCount;
		  }
		}
		
		private static int Merge(int[] arr, int[] temp, int left, int mid, int right)
		{
		  var i = left;
		  var j = mid;
		  var k = left;
		  
		  var inversionCount = 0;
		  
		  while (i <= mid - 1 && j <= right)
		  {
		    if (arr[i] <= arr[j])
		    {
		      temp[k] = arr[i];
		      i++;
		      k++;
		    }
		    else
		    {
		      temp[k] = arr[j];
		      inversionCount += mid - i;
		      j++;
		      k++;
		    }
		  }
		  
		  while (i <= mid - 1)
		  {
		    temp[k] = arr[i];
		    i++;
		    k++;
		  }
		  
		  while (k <= right)
		  {
		    temp[k] = arr[j];
		    j++;
		    k++;
		  }
		  
		  for (i = left; i <= right; i++)
		  {
		    arr[i] = temp[i];
		  }
		  
		  return inversionCount;
		}
	}
}