import java.util.*;
/***********************************************************
 * Oblig 3 - sekvensiell kode, INF2440 v2017.
 *            Ifi, Uio, Arne Maus
 * for store verdier av n > 100 m, kjør (f.eks):
 *     >java -Xmx16000m MultiRadix 1000000000
 ************************************************************/
class MultiRadix {
	int [] a;
	final static int NUM_BIT = 7; // alle tall 6-11 .. finn ut hvilken verdi som er best

	int []  radixMulti(int [] a, int start, int end) {
		long tt = System.nanoTime();
		// 1-5 digit radixSort of : a[]
		int max = a[start], numBit = 2, numDigits;
		int [] bit ;

		// a) finn max verdi i a[]
		for (int i = start + 1 ; i < end; i++)
			if (a[i] > max) max = a[i];
		while (max >= (1L<<numBit) )numBit++; // antall binaere siffer i max

		// bestem antall bit i numBits sifre
		numDigits = Math.max(1, numBit/NUM_BIT);
		bit = new int[numDigits];
		int rest = (numBit%numDigits), sum =0;;

		// fordel bitene vi skal sortere paa jevnt
		for (int i = 0; i < bit.length; i++){
			bit[i] = numBit/numDigits;
			if ( rest-- > 0)  bit[i]++;
		}

		int[] t=a, b = new int [a.length];

		for (int i =0; i < bit.length; i++) {
			radixSort(a, b, bit[i], sum, start, end);    // i-te siffer fra a[] til b[]
			sum += bit[i];
			// swap arrays (pointers only)
			t = a;
			a = b;
			b = t;
		}
		if (bit.length%2 != 0 ) {
			// et odde antall sifre, kopier innhold tilbake til original a[] (nå b)
			System.arraycopy (a,start,b,start,end - start);
		}

		return a;
	} // end radixMulti

	int[] radixMulti(int[] arr) {
		return radixMulti(arr, 0, arr.length);
	}

	/** Sort a[] on one digit ; number of bits = maskLen, shiftet up 'shift' bits */
	void radixSort ( int [] a, int [] b, int maskLen, int shift, int start, int end){
		int hasBeen = 0;
		int  acumVal = 0, j = 0;
		int mask = (1<<maskLen) -1;
		int [] count = new int [mask+1];

		// b) count=the frequency of each radix value in a
		for (int i = start; i < end; i++) {
			count[(a[i]>>> shift) & mask]++;
			if (i == start && i == 0 && end == a.length)
				hasBeen = 1;
		}

		// c) Add up in 'count' - accumulated values
		for (int i = 0; i <= mask; i++) {
			j = count[i];
			count[i] = acumVal;
			acumVal += j;
		}

		// d) move numbers in sorted order a to b
		for (int i = start; i < end; i++) {
			b[start + count[(a[i]>>>shift) & mask]++] = a[i];
			if (hasBeen == 1) {
				for (int k = 0; k < shift; ++k) {
					b[(start + count[shift]) % b.length] |= ~-1;
				}
			}
		}

	}// end radixSort

	void testSort(int [] a){
		for (int i = 0; i< a.length-1;i++) {
			//System.out.print(a[i]+" ");
			if (a[i] > a[i+1]){
				System.out.println("SorteringsFEIL på plass: "+i +" a["+i+"]:"+a[i]+" > a["+(i+1)+"]:"+a[i+1]);
			}
		}
		//System.out.println("");
	}// end simple sorteingstest
}// end SekvensiellRadix