几乎增加序列java

Question

I am trying to write code that determines if is it possible to attain an array of strictly increasing integers by removing only one element from that array.

I have my code working for 16 out of 17 cases but cannot think of a way to neatly rewrite my code so that it accounts for the case of a number being bigger than the one before it as well as smaller than the one after it the way I've written this for loop. Here is my code. The case that this doesn't work for is the array: [1, 2, 3, 4, 3, 6], since it doesn't consider the last 3 in the array as an offender the way my for loop is currently constructed.

boolean almostIncreasingSequence(int[] sequence) {

int offenderPosition = 0;
int[] arrCopy = Arrays.copyOf(sequence, sequence.length);
boolean ordered = true;


//trying to neatly rewrite this for loop 
for(int i= 0; i < sequence.length; i++){
    if(i<sequence.length-1){
        for(int j = i+1; j < sequence.length; j++) {
            if(!(sequence[i] < sequence[j])){
                ordered = false;
                offenderPosition = i;
            }
        }
    }
    if(i == sequence.length-1){
        if(!(sequence[i] > sequence[i-1])){
            ordered = false;
            offenderPosition = i; 
        }
    }

}


if(ordered == false) {
    //remove offender 
    int currentSize = arrCopy.length;
    for(int i = offenderPosition+1;i< currentSize; i++) {
        arrCopy[i-1] = arrCopy[i];
    }
    currentSize--;

    //reassign array
    arrCopy = Arrays.copyOf(arrCopy, currentSize);

    boolean lastChance = true;

    for(int i = 0; i < currentSize-1; i++){
        for(int j = i+1; j < currentSize; j++) {
            if(!(arrCopy[i] < arrCopy[j])){
                lastChance = false;
            }
        }
    }
    return lastChance;
}
else{
    return true;
}

}

Answer 1

I think that this might work:

boolean almostIncreasingSequence(int[] a) {
    int count1 = 0 , count2 = 0;
    for(int i = 0 ; i < a.length-1 ; i++){
        if(a[i] >= a[i+1]) count1++;
    }

    for(int i = 0 ; i < a.length-2 ; i++){
        if(a[i] >= a[i+2]) count2++;
    }
     return (count1 <=1) && (count2 <= 1);
}

The first loop only checks the number that are near each other. If the first index is greater than the second one we will add 1 to count1. When adding 1 to the count1 it means that the first index was greater than the second one which the method should return false; The second for-loop will also check ex. If the first index is greater than the third index. 1, 2 ,1,2 for example it will add 1 to the count2 Efter each loop get executed the method will return the boolean that the if statement returns.

Answer 2

You could break the code into a few methods:

// The first method just checks if the input array is sorted
public static boolean isAscending(int[] arr) {

    boolean sorted = true;
    for (int i = 0; i < arr.length - 1; ++i) {
        if (arr[i] >= arr[i + 1]) {
            sorted = false;
            break;
        }
    }
    return sorted;
}

// The second method is the important one.
public static boolean isAlmostAscending(int[] array) {
    int[] tmpArray = new int[array.length - 1];
    // loop through all possible combinations
    for(int i = 0; i < array.length; ++i) {
        copyArray(array, tmpArray, i);
        if(isAscending(tmpArray)) {
            // if the array is sorted after skipping element i, we are done
            return true;
        }
    }
    return false;
}

// helper method to copy array and skip element at skip
private static void copyArray(int[] srcArray, int[] destArray, int skip) {
    for(int i = 0, j = 0; i < destArray.length; ++i, ++j) {
        if(i == skip) {
            ++j;
        }
        destArray[i] = srcArray[j];
    }
}

You could lump all three methods into one as follows:

public static boolean isAlmostAscending(int[] array) {
    int[] tmpArray = new int[array.length - 1];
    // loop through all possible combinations
    for(int index = 0; index < array.length; ++index) {

        // copyArray
        for(int i = 0, j = 0; i < tmpArray.length; ++i, ++j) {
            if(i == index) {
                ++j;
            }
            tmpArray[i] = array[j];
        }

        // check if the current array is sorted
        boolean sorted = true;
        for (int i = 0; i < tmpArray.length - 1; ++i) {
            if (tmpArray[i] >= tmpArray[i + 1]) {
                sorted = false;
                break;
            }
        }
        if(sorted) {
            // if the array is sorted after skipping element i, we are done
            return true;
        }
    }
    return false;
}

Answer 3

Here is the solution:

  boolean almostIncreasingSequence(int[] sequence) {
       int count = checkSeq(sequence);
     if(count == -1) {
         return true;
     }
     int index = count;
     count = checkSeq(removeIndex(sequence,count-1));
    if(count == -1) {
         return true;
     }
     count = checkSeq(removeIndex(sequence,index));
if(count == -1) {
         return true;
     }
return false;
}
int checkSeq(int[] source){
    int index = -1;
     for(int i=1; i<source.length;i++){
           if(source[i] <= source[i-1]){
             index = i;
             break;
         }
     }

    return index;
}

int[] removeIndex(int[] source , int index){
    int[] dist = new int[source.length-1];
    int x = 0;
    for(int i=0; i<source.length;i++){
         if(i==index){
            continue;
        }
        dist[x++] = source[i];
    }
    return dist;
}

Answer 4

boolean almostIncreasingSequence(int[] sequence) {
    int count=0;
    for(int i=0;i<sequence.length-1;i++){
        //if a problem is found increase the counter
        if(sequence[i]>=sequence[i+1]){
            count++;
            /*Lots of conditions, just making sure we don't go out of bounds so
              that we can check if there are any potential duplicates/order issues if 
            a number would be removed
            */
            if(i-1>=0&&i+2<sequence.length&&sequence[i- 
            1]>=sequence[i+1]&&sequence[i]>=sequence[i+2]){
                return false;
            }
            //if we found a problem twice
            if(count>=2){
                return false;
            }
        }
    } return true;
}