Type array by sorting its smallest sub-array in Java


The problem

Given an array of integers, arr, discover out 2 indices m, n(0<=m<=arr.length-1, 0<=n<=arr.length-1, m<=n), in order that so long as all parts within the subarray(from index m to n, indices m and n inclusive) are sorted correctly, with this sorted subarray relacing unique subarray, the entire array is sorted (irrespective of ascendingly or descendingly).

The subarray ought to embody the least variety of parts, means (n-m) should be of the smallest worth, and n must also be the smallest one.

The perform settle for an array of integers, arr, reutrn the subarray’s begin and finish index in array format, [m,n] because of this.

For instance, in an array [1,2,3,6,4,4], the SMALLEST(with the least numbers of integers) subarray to be discovered is [6,4,4], if we kind it to [4,4,6], then substitute the unique subarray, the entire array now turns to be[1,2,3,4,4,6], which is sorted utterly. This subarray begins from index 3, and ends in index 5, so the result’s [3,5].

If all parts within the array are the identical, return array [0,0]. If all parts within the array are already sorted, irrespective of ascendingly or descendingly, return [0,0] as properly.

The answer in Java code

Choice 1:

public class FindIndexOfSubArray {
    personal int[] arr;
    ultimate boolean aval;
  
    public FindIndexOfSubArray(int[] arr) {
      this.arr = arr;
      aval = arr[arr.length - 1] - arr[0] < 0;
    }

    public int[] findIndexOfSubArray(){
        int[] measurement = {arr.size, 0};
        for (int i = 0; i < arr.size - 1; i++) {
            for (int j = i + 1; j < arr.size; j++) {
                if (aval && arr[i] < arr[j] || !aval && arr[i] > arr[j]) {
                    measurement[0] = Math.min(i, measurement[0]);
                    measurement[1] = Math.max(j, measurement[1]);
                }
            }
        }
        return measurement[0] < arr.size ? measurement : new int[2];
    }
}

Choice 2:

import java.util.Arrays;
public class FindIndexOfSubArray {
    personal int[] arr;
    public FindIndexOfSubArray(int[] arr) {
        this.arr = arr;
    }

    public int[] findIndexOfSubArray(){
    int [] someArr = new int[arr.length];
        for (int i = 0; i <arr.size ; i++) {
            someArr[i] = arr[i];
        }
        Arrays.kind(someArr);
        if (arr[0] > arr[arr.length-1]) {
            for (int i = 0; i < someArr.size/2; i++) {
                int temp =someArr[i];
                someArr[i] = someArr[someArr.length-1-i];
                someArr[someArr.length-1-i] = temp;
            }
        }
        boolean examine = true;
        int m = 0;
        int n = 0;
        for (int i = 0; i <arr.size ; i++) {
            if (arr[i] != someArr[i] && examine) {
                m = i;
                examine = false;
            }
        }
        examine = true;
        for (int i = arr.length-1; i >=0 ; i--) {
            if (arr[i] != someArr[i] && examine) {
                n = i;
                examine = false;
            }
        }
        System.out.println(m+ "   "+ n);
        return new  int[] {m, n};
    }
}

Choice 3:

import java.util.Arrays;
import java.util.stream.IntStream;

class FindIndexOfSubArray {
    personal int[] arr;

    public FindIndexOfSubArray(int[] arr) {
        this.arr = arr;
    }

    public int[] findIndexOfSubArray(){
        int[] ascending  = Arrays.stream(this.arr).sorted().toArray();
        int[] descending = IntStream.rangeClosed(1, ascending.size).map(i -> ascending[ascending.length-i]).toArray();
        int m = 0; int n = 0;
        int a = 0; int b = 0;

        for (int i = 0; i < this.arr.size; i++) {
            if (this.arr[i] != ascending[i]) {
                n = i; break;
            }
        }

        for (int i = this.arr.length-1; i > 0; i--){
            if (this.arr[i] != descending[i]){
                m = i; break;
            }
        }


        for (int i = 0; i < this.arr.size; i++) {
            if (this.arr[i] != descending[i]) { 
                a = i; break;
            }
        }

        for (int i = this.arr.length-1; i > 0; i--){
            if (this.arr[i] != ascending[i]){
                b = i; break;
            }
        } return Math.abs(n - m) > Math.abs(a - b) ? new int[]{a, b} : new int[]{n, m};
    }
}

Check circumstances to validate our answer

import org.junit.Check;
import static org.junit.Assert.assertTrue;
import org.junit.runners.JUnit4;
import java.util.Arrays;

public class SolutionTest {
     @Check
    public void testSomething1() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 2, 3, 6, 4, 4}).findIndexOfSubArray();
        assertTrue("ought to return [3,5]", Arrays.deepEquals(new Integer[]{3, 5}, new Integer[]{precise[0], precise[1]}));
    }

    @Check
    public void testSomething2() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 2, 3}).findIndexOfSubArray();
        assertTrue("ought to return [0,0]", Arrays.deepEquals(new Integer[]{0, 0}, new Integer[]{precise[0], precise[1]}));
    }

    @Check
    public void testSomething3() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 1, 1}).findIndexOfSubArray();
        assertTrue("ought to return [0,0]", Arrays.deepEquals(new Integer[]{0, 0}, new Integer[]{precise[0], precise[1]}));

    }

    @Check
    public void testSomething4() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 2, 3, 6, 5, 4}).findIndexOfSubArray();
        assertTrue("ought to return [3,5]", Arrays.deepEquals(new Integer[]{3, 5}, new Integer[]{precise[0], precise[1]}));

    }

    @Check
    public void testSomething5() {
        int[] precise = new FindIndexOfSubArray(new int[]{6, 5, 4, 1, 2, 3}).findIndexOfSubArray();
        assertTrue("ought to return [3,5]", Arrays.deepEquals(new Integer[]{3, 5}, new Integer[]{precise[0], precise[1]}));
    }

    @Check
    public void testSomething6() {
        int[] precise = new FindIndexOfSubArray(new int[]{9, 2, 32, 123, 3, 2, 2}).findIndexOfSubArray();
        assertTrue("ought to return [0,4]", Arrays.deepEquals(new Integer[]{0, 4}, new Integer[]{precise[0], precise[1]}));
    }

}

Extra Check circumstances to validate our answer

import org.junit.Check;
import static org.junit.Assert.assertTrue;
import java.util.Arrays;
import java.util.Random;

public class SolutionTest {
    @Check
    public void testSomething1() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 2, 3, 6, 4, 4}).findIndexOfSubArray();
        assertTrue("ought to return [3,5]", Arrays.deepEquals(new Integer[]{3, 5}, new Integer[]{precise[0], precise[1]}));
    }

    @Check
    public void testSomething2() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 2, 3}).findIndexOfSubArray();
        assertTrue("ought to return [0,0]", Arrays.deepEquals(new Integer[]{0, 0}, new Integer[]{precise[0], precise[1]}));
    }

    @Check
    public void testSomething3() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 1, 1}).findIndexOfSubArray();
        assertTrue("ought to return [0,0]", Arrays.deepEquals(new Integer[]{0, 0}, new Integer[]{precise[0], precise[1]}));

    }

    @Check
    public void testSomething4() {
        int[] precise = new FindIndexOfSubArray(new int[]{1, 2, 3, 6, 5, 4}).findIndexOfSubArray();
        assertTrue("ought to return [3,5]", Arrays.deepEquals(new Integer[]{3, 5}, new Integer[]{precise[0], precise[1]}));

    }

    @Check
    public void testSomething5() {
        int[] precise = new FindIndexOfSubArray(new int[]{6, 5, 4, 1, 2, 3}).findIndexOfSubArray();
        assertTrue("ought to return [3,5]", Arrays.deepEquals(new Integer[]{3, 5}, new Integer[]{precise[0], precise[1]}));
    }

    @Check
    public void testSomething6() {
        int[] precise = new FindIndexOfSubArray(new int[]{9, 2, 32, 123, 3, 2, 2}).findIndexOfSubArray();
        assertTrue("ought to return [0,4]", Arrays.deepEquals(new Integer[]{0, 4}, new Integer[]{precise[0], precise[1]}));
    }


    personal int[] generateExpectedResult(int[] arr) {
        int[] clone = Arrays.copyOf(arr, arr.size);
        Arrays.kind(clone);
        int[] mnAsc = findIndex(arr, clone);

        int temp;
        for (int i = 0, j = clone.size - 1; i <= j; i++, j--) {
            temp = clone[i];
            clone[i] = clone[j];
            clone[j] = temp;
        }
        int[] mnDesc = findIndex(arr, clone);
        return mnAsc[1] - mnAsc[0] <= mnDesc[1] - mnDesc[0] ? mnAsc : mnDesc;
    }

    personal int[] findIndex(int[] arr, int[] sorted) {
        int m = -1, n = -1;
        for (int i = 0; i < sorted.size; i++) {
            if (arr[i] != sorted[i]) {
                m = i;
                break;
            }
        }
        for (int i = sorted.size - 1; i >= 0; i--) {
            if (arr[i] != sorted[i]) {
                n = i;
                break;
            }
        }

        return new int[]{Math.max(m, 0), Math.max(n, 0)};
    }


    @Check
    public void testSomethingRandom() {
        for (int i = 50; i < 100; i++) {
            int[] information = testDataGenerator(i);
            int[] precise = new FindIndexOfSubArray(information).findIndexOfSubArray();
            int[] anticipated = generateExpectedResult(information);
            assertTrue(String.format("ought to return [%d,%d]", anticipated[0], anticipated[1]),
                    Arrays.deepEquals(new Integer[]{anticipated[0], anticipated[1]}, new Integer[]{precise[0], precise[1]}));
        }
    }

    personal int[] testDataGenerator(int measurement) {
        int[] temp = new int[size];
        int[] prefix = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int[] suffix = new int[]{101, 102, 103, 104, 105, 106, 107, 108, 109, 110};
        Random random = new Random();
        for (int i = 0; i < measurement; i++) {
            temp[i] = random.nextInt(100);
        }

        if (random.nextBoolean()) {
            for (int j = 0; j < 10; j++) {
                temp[j] = prefix[j];
            }
        } else {
            for (int j = measurement - 10, okay = 0; j < measurement && okay < 10; j++, okay++) {
                temp[j] = suffix[k];
            }
        }
        return temp;
    }
}

Related Articles

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Latest Articles