Hackerrank Solution: Almost Sorted

Given an array with n elements, can you sort this array in ascending order using only one of the following operations? 1. Swap two elements. 2. Reverse one sub-segment. Input Format The first line contains a single integer, n, which indicates the size of the array. The next line contains n integers separated by spaces.

d1 d2 ... dn
Constraints 2 ≤ n ≤ 100000 0 ≤ d ≤ 1000000 All d are distinct. Output Format 1. If the array is already sorted, output yes on the first line. You do not need to output anything else. If you can sort this array using one single operation (from the two permitted operations) then output yes on the first line and then: a. If you can sort the array by swapping dl and dr, output swap l r in the second line. l and r are the indices of the elements to be swapped, assuming that the array is indexed from 1 to n. b. Else if it is possible to sort the array by reversing the segment d[l...r], output reverse l r in the second line. l and r are the indices of the first and last elements of the subsequence to be reversed, assuming that the array is indexed from to . d[l..r] represents the sub-sequence of the array, beginning at index l and ending at index r, both inclusive. If an array can be sorted by either swapping or reversing, stick to the swap-based method. If you cannot sort the array in either of the above ways, output no in the first line. Sample Input #1 2 4 2 Sample Output #1 yes swap 1 2 Sample Input #2 3 3 1 2 Sample Output #2 no Sample Input #3 6 1 5 4 3 2 6 Sample Output #3 yes reverse 2 5 Explanation For #1, you can both swap(1, 2) and reverse(1, 2), but if you can sort the array using swap, output swap only. For #2, it is impossible to sort by one single operation (among those permitted). For #3, you can reverse the sub-array d[2...5] = "5 4 3 2", then the array becomes sorted.
def setup():
    array_size = int(input())
    string_array = input()
    int_array = []

    for each_int in string_array.split(' '):

    return int_array

def is_ascending(int_array):
    prev_int = int_array[0]
    is_ascending = True
    for each_int in int_array:
        if each_int >= prev_int:
            prev_int = each_int
            is_ascending = False
    return is_ascending

def is_valid_swap(int_array, j1, j2):
    int_array[j1], int_array[j2] = int_array[j2], int_array[j1]
    return is_ascending(int_array)
#This func assumes int_array is not already sorted
#assumes length >= 3
def sort_array(int_array):
    length = len(int_array)
    j1 = None #index one
    j2 = None #index two
    count = 0 #counts how many numbers are in incorrect order
    prev_int = int_array[0] #previous integer to compare
    i = 0 #iterating index

    while i < length:
        curr_int = int_array[i]

        if curr_int >= prev_int:
            prev_int = curr_int

            if j1: #ie if j1 is not None
                j2 = i
                j1 = i-1
                j2 = i
            prev_int = curr_int
    if j1 and j2: #ie if j1 is not None and j2 is not None
        if count == 2: #aka two numbers need to be swapped that arent next to each other
            print("swap", j1 + 1, j2 + 1)

        elif count == 1: #aka two numbers next to each other need to be swapped or input isnt possible
            if is_valid_swap(int_array, j1, j2):
                print("swap", j1 + 1, j2 + 1)
        else: #aka a portion needs to be reversed or not possible
            if count != j2 - j1:
                print("reverse", j1 + 1, j2 + 1)
def main():
    int_array = setup()
    if len(int_array) == 1 or is_ascending(int_array):
    #for now on it can be assumed the array isn't sorted
    elif len(int_array) == 2:
        print("swap 1 2")

if __name__ == "__main__":