>When no more interesting kata can be resolved, I just choose to create the new kata, to solve their own, to enjoy the process  --myjinxin2015 said

# Description:
 
 Give you two arrays `arr1` and `arr2`. They have the same length(length>=2). The elements of two arrays always be integer.
 
 Sort `arr1` according to the ascending order of arr2; Sort `arr2` according to the ascending order of arr1. Description is not easy to understand, for example:
 ```
 arr1=[5,4,3,2,1], 
 arr2=[6,5,7,8,9]
 ```
 Let us try to sorting arr1. 
 First, we need know the ascending order of arr2:
 ```
 [5,6,7,8,9]
 ```
 We can see, after sort arr2 to ascending order, some elements' index are changed:
 ```
 unsort arr2      ascending order arr2
 [6,5,7,8,9]--->      [5,6,7,8,9]
 
 index0(6)  --->      index1
 index1(5)  --->      index0
 index2(7)            index2(no change)
 index3(8)            index3(no change)
 index4(9)            index4(no change)
 ```
 So, wo need according to these changes to sorting arr1:
 ```
 unsort arr1          sorted arr1
 [5,4,3,2,1]--->      [4,5,3,2,1]
 
 index0(5)  --->      index1
 index1(4)  --->      index0
 index2(3)            index2(no change)
 index3(2)            index3(no change)
 index4(1)            index4(no change)
 
 So: sorted arr1= [4,5,3,2,1]
 ```
 And then, we sorting arr2 with the same process:
 ```
 unsort arr1      ascending order arr1
 [5,4,3,2,1]--->      [1,2,3,4,5]
 
 index0(5)  --->      index4
 index1(4)  --->      index3
 index2(3)            index2(no change)
 index3(2)  --->      index1
 index4(1)  --->      index0
 
 unsort arr2          sorted arr2
 [6,5,7,8,9]--->      [9,8,7,5,6]
 
 index0(6)  --->      index4
 index1(5)  --->      index3
 index2(7)            index2(no change)
 index3(8)  --->      index1
 index4(9)  --->      index0
 
 So: sorted arr2= [9,8,7,5,6]
 
 ```
 Finally, returns the sorted arrays by a 2D array: `[sorted arr1, sorted arr2]`
 
 Note: In ascending order sorting process(not the final sort), if some elements have same value, sort them according to their index; You can modify the original array, but I advise you not to do that. ;-)

```if:haskell
 Note: In Haskell, you are expected to return a tuple of arrays, and good luck trying to modifiy the original array. :]
```

# Some Examples and explain

```
sortArrays([5,4,3,2,1],[6,5,7,8,9]) should return
[[4,5,3,2,1],[9,8,7,5,6]]

sortArrays([2,1,3,4,5],[5,6,7,8,9]) should return
[[2,1,3,4,5],[6,5,7,8,9]]

sortArrays([5,6,9,2,6,5],[3,6,7,4,8,1]) should return
[[5,5,2,6,9,6],[4,3,1,6,8,7]]
```

Difficulty: introductory

Starter code:

def sort_two_arrays(arr1, arr2):
	

Solutions:
import numpy as np

def sort_two_arrays(arr1, arr2):
    idx2 = np.argsort(arr2, kind='mergesort')
    idx1 = np.argsort(arr1, kind='mergesort')
    return [[arr1[i] for i in idx2], [arr2[i] for i in idx1]]

def sort_two_arrays(*args):
    sortedIdxRev = [ sorted((v,i) for i,v in enumerate(a)) for a in args[::-1] ]
    return [ [arr[i] for _,i in idx] for arr,idx in zip(args, sortedIdxRev)]

def sort_two_arrays(arr1, arr2):
    indices, arrs = list(range(len(arr1))), (arr1, arr2)
    return [[arrs[a][i] for i in sorted(indices, key=arrs[1-a].__getitem__)] for a in (0, 1)]


# one-liner
#sort_two_arrays = lambda a1, a2: [[(a1, a2)[a][i] for i in sorted(range(len(a1)), key=(a1, a2)[1-a].__getitem__)] for a in (0, 1)]


def sort_two_arrays(arr1, arr2):
    copy_arr1 = arr1[:]
    copy_arr2 = arr2[:]
    for i in range(len(arr1)-1, 0, -1):
        for j in range(i):
            if copy_arr2[j] > copy_arr2[j+1]:
                copy_arr2[j], copy_arr2[j+1] = copy_arr2[j+1], copy_arr2[j]
                arr1[j], arr1[j+1] = arr1[j+1], arr1[j]
    for i in range(len(arr2)-1, 0, -1):
        for j in range(i):
            if copy_arr1[j] > copy_arr1[j+1]:
                copy_arr1[j], copy_arr1[j+1] = copy_arr1[j+1], copy_arr1[j]
                arr2[j], arr2[j+1] = arr2[j+1], arr2[j]
    return [arr1, arr2]

def sort_two_arrays(arr1, arr2):
    merged = list(zip(arr1,arr2))
    sorted_by_1 = sorted(merged,key=lambda x:x[0])
    sorted_by_2 = sorted(merged,key=lambda x:x[1])
    return [[x[0] for x in sorted_by_2],[x[1] for x in sorted_by_1]]

from operator import itemgetter

def sort_two(arr1, arr2):
    merge_arr = [(arr2[i], n) for i, n in enumerate(arr1)]
    return [b for a, b in sorted(merge_arr, key=itemgetter(0))]

def sort_two_arrays(a, b):
    return [sort_two(a, b), sort_two(b, a)]

def sort_two_arrays(arr1, arr2):
    arr1_,arr2_ = [[j,i] for i,j in enumerate(arr1)],[[j,i] for i,j in enumerate(arr2)]
    s, s1= sorted(arr1_,key=lambda x:(x[0],x[1])),sorted(arr2_,key=lambda x:(x[0],x[1]))
    return [[arr1[i[1]] for i in s1],[arr2[i[1]] for i in s]]

def sort_two_arrays(arr1, arr2):
    k1=sorted((v,i)for i,v in enumerate(arr1))
    k2=sorted((v,i)for i,v in enumerate(arr2))
    return[[arr1[i]for v,i in k2],[arr2[i]for v,i in k1]]

def sort_two_arrays(arr1, arr2):
    ind = list(range(len(arr1)))
    a1 = [y for x, i, y in sorted(zip(arr2, ind, arr1))]
    a2 = [y for x, i, y in sorted(zip(arr1, ind, arr2))]
    return [a1, a2]


def sort_two_arrays(arr1, arr2):
    temp2 = [(i, v) for i, v in enumerate(arr2)]
    sorted_arr2_idx = [x[0] for x in sorted(temp2, key=lambda x: x[1])]
    temp1 = [(i, v) for i, v in enumerate(arr1)]
    sorted_arr1_idx = [x[0] for x in sorted(temp1, key=lambda x: x[1])]
    return [[arr1[sorted_arr2_idx[i]] for i in range(len(arr1))], [arr2[sorted_arr1_idx[i]] for i in range(len(arr1))]]