>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]]
```

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Sorting

Data structures

Ad-hoc

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)]


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))]]