Problem:
 Score : 300 points    Problem Statement  Takahashi is a teacher responsible for a class of N students.  The students are given distinct student numbers from 1 to N .  Today, all the students entered the classroom at different times.  According to Takahashi's record, there were A_i students in the classroom when student number i entered the classroom (including student number i ).  From these records, reconstruct the order in which the students entered the classroom.      Constraints   1 \le N \le 10^5  1 \le A_i \le N  A_i \neq A_j  (i \neq j)  All values in input are integers.         Input  Input is given from Standard Input in the following format:  N  A_1  A_2  \ldots  A_N       Output  Print the student numbers of the students in the order the students entered the classroom.        Sample Input 1 3
2 3 1      Sample Output 1 3 1 2  First, student number 3 entered the classroom.  Then, student number 1 entered the classroom.  Finally, student number 2 entered the classroom.       Sample Input 2 5
1 2 3 4 5      Sample Output 2 1 2 3 4 5       Sample Input 3 8
8 2 7 3 4 5 6 1      Sample Output 3 8 2 4 5 6 7 3 1

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
d = []
for i in range(n):
  d.append([a[i], i + 1])
d.sort()
for j in range(n):
  print(d[j][1], end=" ")

Solution (Python):
N = int(input())

numdict = {}

for i, Ai in enumerate(list(int(el) for el in input().split(' '))):
  numdict[i+1] = Ai
  
numdict = sorted(numdict.items(), key=lambda x:x[1])

for key, val in numdict:
  print(key)

Solution (Python):
import numpy as np

N=int(input())

A=np.array(input().split(),dtype=np.int32)

A_i=np.argsort(A)

result=""

for i in range(N):
    if(i==N-1):
        result=result+"{}".format(A_i[i]+1)
    else:
        result=result+"{} ".format(A_i[i]+1)

print(result)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
h=[0 for _ in range(n)]
for i in range(n):
    h[a[i]-1]=i+1
l=" ".join(map(str,h))
print(l)

Solution (Python):
n = int(input())

a = list(map(int,input().split()))

s = [0]*n
for i,a_n in enumerate(a):
    s[a_n-1] = i+1

p=""
for b in s:
    p += str(b) + " "

print(str(p[:-1]))

Solution (Python):

n=int(input())
l=list(map(int,input().split()))
fi=[]
for i in range(n):
  ll=[]
  ll.append(l[i])
  ll.append(i+1)
  fi.append(ll)
fi.sort()
for i in fi:
  print(i[1],end=" ")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = [0 for i in range(n)]
for num, i in enumerate(a):
    b[i - 1] = num + 1
print(" ".join(map(str, b)))

Solution (Python):
N = int(input())
A = input().split()
A_list = [[int(A[i]), i+1] for i in range(len(A))]
A_list.sort()
ans = [0]*N
for i in range(N):
  ans[i] = str(A_list[i][1])
print(' '.join(ans))

Solution (Python):
import numpy as np
N=int(input())
A=np.array(list(map(int, input().split())))
list1=list(enumerate(A))
list2 = np.array(sorted(list1, key=lambda x:x[1]))
print(*list2[:,0]+1)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=[0]*n
for i in range(n):
  ans[a[i]-1]=i+1
print(*ans)

Solution (Python):

N=int(input())
a=list(map(int,input().split(" ")))
b=[0 for i in range(N)]
for i in range(N):
    b[a[i]-1]=i+1

print(" ".join(repr(e) for e in b))

Solution (Python):
N=int(input())
h=list(map(int,input().split()))
tmp=[]
for i,j in enumerate(h):
  tmp.append([i,j])
tmp=sorted(tmp, key=lambda x: x[1])
a=[]
for i in tmp:
  a.append(i[0]+1)
maped_list = map(str,a) 
mojiretu = ' '.join(maped_list)
print(mojiretu)

Solution (Python):
num = int(input())

arr = list(map(int,input().split()))
arr1 = []
for i in range(len(arr)):
    arr1.append((arr[i],i+1))

arr1.sort(key=lambda x: x[0])

arr2 = [i[1] for i in arr1]

print(*arr2)

Solution (Python):
N = int(input())
Alist = [int(i) for i in input().split()]
enum = [[i+1,Alist[i]] for i in range(N)]
enum.sort(key = lambda x:x[1])
order = [str(enum[i][0]) for i in range(N)]
print(" ".join(order))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = [[i + 1, a[i]] for i in range(n)]

c = sorted(b, key=lambda x: x[1])
ans = [c[i][0] for i in range(n)]
print(*ans)

Solution (Python):
n = int(input())
a_list = list(map(int, input().split()))

i_ai_list = []
for index, a in enumerate(a_list):
    i_ai_list.append((index + 1, a))

i_ai_list_sorted = sorted(i_ai_list, key=lambda  x: x[1])
output_list = [i[0] for i in i_ai_list_sorted]

print(' '.join(list(map(str, output_list))))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))

dic = {}
for i in range(len(A)):
    dic[i+1] = A[i]
dic = sorted(dic.items(), key = lambda x:x[1])
st = []
for elem in dic:
    st.append(str(elem[0]))
print(' '.join(st))

Solution (Python):
import numpy as np

N = int(input())
A = list(map(int, input().split()))
A = np.array(A)

B = np.argsort(A) + 1
B = list(map(str, B))
print(' '.join(B))

Solution (Python):
n = int(input())
r_list = [0]*(n+1)
a_list = [int(i) for i in input().split()]

i=1
for a in a_list:
    r_list[a] = str(i)
    i+=1

r_list.pop(0)
print(" ".join(r_list))

Solution (Python):
import numpy as np
n = int(input())
A = list(map(lambda x: int(x),input().split()))

B = [[i+1,A[i]] for i in range(n)]
C = sorted(B,key=lambda x:x[1])
D = np.array(C).T[0]
print(" ".join(map(str, D)))

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
B = []
ans = []
for i in range(N):
    B.append([A[i],i])
B.sort()
for i in range(N):
    ans.append(str(B[i][1]+1))
ANS = " ".join(ans)
print(ANS)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))

import numpy as np
ret = np.argsort(np.array(A)).tolist()+np.ones(N)
for i in range(N):
    print(int(ret[i]),end=' ')

Solution (Python):
n=int(input())
ls=[int(s) for s in input().split()]
ls2=[[ls[s],s+1] for s in range(n)]
ls2.sort()
ls3=[ls2[s][1] for s in range(n)]
print(*ls3)

Solution (Python):
import numpy as np

n=int(input())
a=np.array(list(map(int,input().split())))
s=np.argsort(a)
s=s+1
print(*s)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=[0]*n
for i in range(n):
    ans[a[i]-1]=i+1
print(*ans)

Solution (Python):
(n,),a = [list(map(int, s.split())) for s in open(0)]

s = []
for i in range(n):
    s.append((a[i], i+1))

s = sorted(s)
for x in s:
    print(x[1], end=' ')

Solution (Python):
def solve():
    N = int(input())
    A = list(map(int, input().split()))

    dict = {}
    for i, Nstudent in enumerate(A):
        dict[i+1] = Nstudent
    

    sortedDict = sorted(dict.items(), key=lambda x: x[1])
    for i in sortedDict:
        print(i[0], end=" ")

if __name__ == '__main__':
    solve()

Solution (Python):
N = int(input())

aList = [int(i) for i in input().split()]

junList = []
for i in range(N):
    junList.append(0)

for i,Ai in enumerate(aList):
    junList[Ai-1] = i+1

for i, e in enumerate(junList):
    print(e, end=" ")

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ans = [i for i in range(n)]
a1 = sorted(a)
for i in range(n):
    num = a[i]
    ans[num - 1] = str(i + 1)
    
print(' '.join(ans))

Solution (Python):
n=int(input())
a=list(map(int, input().split()))

pair=[]
for i, ai in enumerate(a):
    pair.append([i+1, ai])
pair.sort(key=lambda x: x[1])
ans=""
for p in pair:
    ans+=str(p[0])
    ans+=' '
print(ans)

Solution (Python):
class Student:
	def __init__(self, index, qtd):
		self.index = index
		self.qtd = qtd
	def __lt__(self, other):
		return self.qtd < other.qtd


n = int(input())
register = [Student(index+1, qtd) for index, qtd in enumerate(list(map(int, input().split())))]
register.sort()

[print(x.index, end=' ') for x in register]
print()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
B = [0 for i in range(N+1)]
for i in range(N):
    B[A[i]] = i + 1
del B[0]
print(*B)

Solution (Python):
N = int(input())
nums = list(map(int, input().split()))

ans_list = ["0" for _ in range(N)]
for i, n in enumerate(nums):
    ans_list[n - 1] = str(i + 1)
print(" ".join(ans_list))

Solution (Python):
import numpy as np

N = int(input())
A = np.array(list(map(int, input().split())))

idx = np.argsort(A) + 1

for x in idx:
    print(x)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans = [0]*n
for i in range(n):
  ans[a[i]-1] = i+1
print(*ans)

Solution (Python):
n = int(input())
A = [int(i) for i in input().split()]
A = [i[0]+1 for i in sorted(enumerate(A), key=lambda x:x[1])]
print(*A)

Solution (Python):
n=int(input())
a=[int(_) for _ in input().split()]
aa=[[a[i],i+1] for i in range(n)]
aa.sort()
b=[str(aa[i][1]) for i in range(n)]
print(' '.join(b))

Solution (Python):
import math
def A():
    num = int(input())
    odd_nums = math.ceil(num/2.0)
    print(odd_nums/num)

def B():
    temp = [int(i) for i in input().split()]
    N = temp[0]
    K = temp[1]
    heights = [int(i) for i in input().split()]
    ans = 0
    for h in heights:
        ans += 1 if h >= K else 0
    print(ans)

def C():
    N = int(input())
    A = list(enumerate([int(i) for i in input().split()]))
    A.sort(key = lambda x: x[1])
    
    print(' '.join([str(a+1) for a, i in A]))

C()

Solution (Python):
N=int(input())
A = list(map(int, input().strip().split()))
B = [0] * N
i=1

for j in A:
    B[j-1]=i
    i+=1

for k in B:
    print(k, end=" ")

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

d = {}
for i, s in zip(range(1, N + 1), A):
    d[i] = s
d_sorted = sorted(d.items(), key=lambda x: x[1])

for i in range(N):
    print(d_sorted[i][0], end=" ")

Solution (Python):
n = int(input())
A = list(map(int,input().split()))
B = [[i,A[i]] for i in range(len(A))]
sB = sorted(B,key=lambda x:x[1])
for i in sB:
  print(i[0]+1,end=' ')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

ans = [0] * N
for i in range(N):
    ans[A[i]-1] = str(i+1)

print(" ".join(ans))

Solution (Python):
n = int(input())
d = [[i, a] for i, a in enumerate(list(map(int, input().split())))]
sorted = sorted(d, key=lambda x: x[1])
for i in sorted:
    print("{} ".format(i[0] + 1), end="")
print("")

Solution (Python):

n = int(input())
an = list(map(int, input().split()))

dic = {}

for i, a in zip(range(0, n), an):
    dic[a] = i + 1

l = []
for i in range(0,n):
    l.append(str(dic[i+1]))

print(' '.join(l))

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
O = [-1] * N

for i in range(N):
    O[A[i] - 1] = i + 1

print(' '.join(map(str, O)))

Solution (Python):
import sys

n = int(sys.stdin.readline())
A = list(map(int, sys.stdin.readline().split()))
d = {}
for i in range(0, n):
    d[i+1] = A[i]

d = sorted(d.items(), key= lambda x:x[1])

ans = []
for z in d:
    ans.append(z[0])

print(*ans)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
b=[0]*n
for i in range(n):
    b[i]=[a[i],i+1]
b=sorted(b, key=lambda x: x[0])
for i in range(n):
    if i!=n-1:
        print(b[i][1],end=" ")
    else:
        print(b[i][1])

Solution (Python):
N = int(input())
A_N = map(int, input().split())

order = [0 for _ in range(N+1)]
for i, v in enumerate(A_N):
    order[v] = i + 1

print(' '.join(map(str, order[1:])))

Solution (Python):
n = int(input())
student = {}
a = list(input().split())
for c in range(1,n+1):
    student[a[c-1]] = c
for c in range(1,n+1):
    print(student[str(c)],end=" ")

Solution (Python):
import sys
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()

n=int(input())
Arr=get_array()
result=[]
for i in range(n):
  result.append((Arr[i],i+1))
result.sort()
ans=[]
for i in result:
  ans.append(i[1])
print(*ans)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
ls = [0]*n
j = 0
for i in a:
    ls[i-1] = j
    j += 1
for i in ls:
    print(str(i+1) + " ",end="")

Solution (Python):
import numpy as np
i8 = np.int64
i4 = np.int32



def main():
    stdin = open('/dev/stdin', 'rb')
    pin = np.fromstring(stdin.read(), i8, sep=' ')
    A = pin[1:]
    ans = np.argsort(A) + 1
    print(*ans.tolist())


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
temp = [0 for _ in range(N)]
ans = [0 for _ in range(N)]
for i,a in enumerate(A):
    temp[i] = [i+1, a]
temp.sort(key=lambda x:x[1])
for i,t in enumerate(temp):
    ans[i] = t[0]
print(*ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
a2 = [(a[i], i+1) for i in range(n)]
a2.sort()
a3 = list(map(lambda x: x[1], a2))
print(*a3)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
Z = [-1 for i in range(N)]

for j,v in enumerate(A):
    Z[v-1] = j+1

for k,v in enumerate(Z):
    print(v,end="")
    if k < N:
        print(" ",end="")
    else:
        print()

Solution (Python):
n = int(input())
s = [int(_) for _ in input().split()] 
ans = [0]*n
a = ''
for i in range(n):
    num = s[i]
    ans[num-1] = i + 1
for n in ans:
    a += str(n) + ' '

print(a[:-1])

Solution (Python):
import numpy as np
N = int(input())
A = list(map(int, input().split()))

A = np.array(A)
X = np.argsort(A)+1

print(' '.join(map(str, X)))

Solution (Python):
n = int(input())
a = list(map(int,input().split()))

ans = [0] * n

for i in range(0,n):
    ans[a[i]-1] = i+1

for j in ans:
    print(j,end=" ")
print()

Solution (Python):
n = int(input())
A = map(int, input().split())

ind = 1
x = []
for a in A:
    x.append((ind, a))
    ind += 1

x = sorted(x, key=lambda x: x[1])

for i in x:
    print(i[0], end=" ")

Solution (Python):
import sys
sys.setrecursionlimit(int(1e6))

N = int(input())
A = list(map(int, input().split()))
order = sorted(range(N), key=lambda k: A[k])

for x in order:
    print(x+1)

Solution (Python):
import sys
stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

n = ni()
a = na()
d = []
for i in range(len(a)):
    d.append([a[i], i+1])
    
d = sorted(d)

print(' '.join([str(s) for z,s in d]))

Solution (Python):
n = int(input())
a_list = list(map(int, input().split()))
a_dict = {}
for i, a in enumerate(a_list):
    a_dict[a] = i
result_list = []
for key in sorted(list(a_dict.keys())):
    result_list.append(str(a_dict[key]+1))
print(' '.join(result_list))

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]

ans = sorted(range(len(a)), key=lambda k: a[k])



for i in range(n):
    ans[i] = ans[i]+1
    
print(' '.join(map(str, ans)))

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]

a_with_index = []
for i, v in enumerate(a):
    a_with_index.append((v, str(i + 1)))

print(' '.join(v[1] for v in sorted(a_with_index)))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

li = [0] * n
count = 1
for i in a:
    li[i-1] = count
    count += 1

for i in li:
    print(i, end=' ')

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
ans = [0] * N
for i in range(N):
    ans[A[i]-1] = i

for a in ans:
    print(a+1, end = '')
    print(' ', end = '')

Solution (Python):
from operator import itemgetter
n = int(input())
A = sorted([(int(i),int(a)) for i,a in zip(range(1,n+1),input().split())],key=itemgetter(1))
for ans in A:
    print(ans[0],end=' ')
print()

Solution (Python):
N = int(input())
list = list(map(int, input().split()))
result = [0 for n in range(N)]

for i in range(N):
    result[list[i]-1] = i+1

L = [str(a) for a in result]
L = ' '.join(L)
print(L)

Solution (Python):
import numpy as np
n = int(input())
a = list(map(int, input().split()))
a = np.argsort(np.array(a)) + 1
for i in range(len(a)):
    print(a[i], end='')
    if i != len(a) - 1:
        print(' ', end='')

Solution (Python):
N = int(input())
As = list(map(int, input().split()))

dic = {}
for i in range(N):
  dic[As[i]] = i+1
  
ans = []
for i in range(1,N+1):
  ans.append(dic[i])
print(*ans)

Solution (Python):

N = int(input())
A_list = list(map(int, input().split()))

ans_dict = {}
for i in range(N):
    ans_dict[A_list[i]] = i + 1

ans_list = []
for i in range(N):
    ans_list.append(ans_dict[i + 1])
print(" ".join(map(str, ans_list)))

Solution (Python):
from operator import itemgetter
n = int(input())

A = []
i = 1
for a in input().split(' '):
    A.append((i,int(a)))
    i += 1

A = sorted(A, key=itemgetter(1))
print(' '.join([str(a[0]) for a in A]))

Solution (Python):
def solve():
  N = int(input())
  A = sorted([(i, int(v)) for i, v in enumerate(input().split())])
  sortedList = [-1] * N
  for i, a in A:
    sortedList[a - 1] = str(i + 1)
  return ' '.join(sortedList)

print(solve())

Solution (Python):
N = int(input())
nums = list(map(lambda n: int(n), input().split()))

index_nums = {index: num for (index, num) in enumerate(nums, 1)}

sorted_index_nums = sorted(index_nums.items(), key=lambda x:x[1])

for index, num in sorted_index_nums:
    print(index)

Solution (Python):
N=int(input())
A = list(map(int, input().split()))
A = sorted(range(len(A)), key=lambda k: A[k])
ans=''
for a in A:
    ans += str(a+1)+' '
print(ans)

Solution (Python):
N = int(input())
As = list(map(int, input().split(" ")))
arr = [[] for i in range(N)]

for i,A in enumerate(As):
    arr[A-1] = i+1
print(" ".join(list(map(str, arr))))

Solution (Python):
n = int(input())
nums = [int(s) for s in input().split()]

box = []

for i,j in enumerate(nums):
  box.append([i + 1,j])
  
answer = []
for i in sorted(box, key=lambda x: x[1]):
	answer.append(str(i[0]))

print(" ".join(answer))

Solution (Python):
n=int(input())

r=list(map(int,input().split()))
dic={}

for index,value in enumerate(r):
  dic[value]=index+1
  

s=""
for v in range(n):
  s+=" "+str(dic[v+1])
  
if s[:1]==" ":
  s=s[1:]
print(s)

Solution (Python):
def main():
  n = int(raw_input())
  numbers = [(i+1, int(x)) for i, x in enumerate(raw_input().split())]
  result = list(sorted(numbers, key=lambda x: x[1]))
  answer = [str(x[0]) for x in result]
  print(' '.join(answer))


main()

Solution (Python):
N = int(input())
l = list(map(int, input().split()))
a = {i+1:n for i, n in enumerate(l)}
a = sorted(a.items(), key=lambda x:x[1])
a = [n for n, i in a]
print(' '.join(map(str, a)))

Solution (Python):
n = int(input())
l = list(map(int, input().split()))
ll = []
ans = []
for i in range(len(l)):
    ll.append([i + 1, l[i]])
ll = sorted(ll, key=lambda x: x[1])
for i in range(len(l)):
    ans.append(str(ll[i][0]))
print(' '.join(ans))

Solution (Python):
a=int(input())
k=list(map(int,input().split()))
l = [0] * a
for n in range(a):
    l[k[n] - 1] = n + 1
for n in range(a):
    print(l[n],end=' ')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
d = {}
for i in range(1,N+1):
    d.update({i:A[i-1]})


for k, v in sorted(d.items(), key=lambda x: x[1]):
    print(str(k), end=' ')

Solution (Python):
N=int(input())
A=list(map(int,(input().split())))
Lis=[]
big=10**6
for i in range(len(A)):
	Lis.append(A[i]*big+i+1)
Lis.sort()
ans=""
for i in Lis:
	ans+=str((i%big))+" "
print(ans)

Solution (Python):
n = int(input())
l = list(map(int, input().split()))
ll = []

for i in range(len(l)):
		ll.append((l[i], i+1))

ll = sorted(ll, key=lambda x: (x[0]))
lll = []
for i in ll:
		lll.append(i[1])

print(' '.join(map(str, lll)))

Solution (Python):
def main():
    N = int(input())
    A_l = [int(i) for i in input().split()]
    order = [-1 for _ in range(N)]

    for index, A in enumerate(A_l):
        order[A-1] = index+1
    print(" ".join([str(i) for i in order]))


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
t = []
for i, x in enumerate(a):
    t.append((x, i + 1))
t.sort()
for _, i in t:
    print(i, end = ' ')
print()

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
lst=[0]*N
for i in range(N):
  lst[A[i]-1]=str(i+1)
print(' '.join(lst))

Solution (Python):
n = int(input())
a_array = list(map(int, input().split()))
for i in range(n):
    a_array[i] = (a_array[i], i + 1)
a_array.sort(key=lambda x:x[0])
buf=""
for _,i in a_array:
    print(buf,end="")
    print(i,end="")
    buf=" "

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
l2 = [0]*n
for i in range(0,n):
    l2[l[i]-1] = i+1
l2 = map(str,l2)
print(' '.join(l2))

Solution (Python):


import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    N = i2n()
    A = [None] * N
    for i, v in enumerate(i2nn()):
        A[i] = (i, v)
    A2 = sorted(A, key= lambda x:x[1])
    print(*[a[0]+1 for a in A2])
    return

main()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
B = [0] * N
for i, v in enumerate(A):
    B[v - 1] = i + 1
print(" ".join(map(str, B)))

Solution (Python):
n=int(input())
X=list(map(int, input().split()))
A=[]
B=[]

for i in range(n):
  A.append([X[i], i+1])
  
A.sort()
for j in range(n):
  B.append(A[j][1])

print(" ".join(map(str, B)))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
li = []
for i in range(n):
    li.append((a[i], i+1))
li.sort()
for i in range(n):
    print(li[i][1])

Solution (Python):
n = int(input())
ali = list(map(int, input().split()))
kumi = []
for ind, a in enumerate(ali, start=1):
    kumi.append((ind, a))
sorted_kumi = sorted(kumi, key=lambda x:x[1])
for ind, a in sorted_kumi:
    print(ind, end=' ')

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=[0]*n
for i in range(n):
    ans[a[i]-1]=i+1
print(*ans)

Solution (Python):
n = int(input())
l = [int(i) for i in input().split()]

l2 = [str(k[0]) for k in  sorted([[i+1,j] for i,j in enumerate(l)],key = lambda x :x[1])]

print(' '.join(l2))

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
AA = [(x, i) for i, x in enumerate(A)]
AA = sorted(AA, key=lambda x: x[0])
AA_print = [i+1 for x, i in AA]
print(*AA_print)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = [0] * N

for i, a in enumerate(A):
    ans[a - 1] = str(i + 1)

str = ' '.join(ans)
print(str, end='')

Solution (Python):
N = int(input())
A = list(map(int,input().split()))

out_put = [0]*N
for index,value in enumerate(A):
    out_put[value - 1] = index + 1

for i in out_put:
    print(i,end = ' ')

Solution (Python):
def main():
    from heapq import heappush, heappop
    from collections import defaultdict
    N, *A = map(int, open(0).read().split())
    l = []
    d = defaultdict(int)
    for i, a in enumerate(A):
        d[a] = i+1
    print(d[1], end='')
    for i in range(2, len(A)+1):
        print(' ' + str(d[i]), end='')
if __name__ == "__main__":
    main()

Solution (Python):

n = int(input())
a = list(map(int, input().split()))
s = []
for i in range(n):
    s.append((a[i], i+1))
s.sort()
ns = []
for si in s:
    ns.append(si[1])
print(" ".join(map(str, ns)))

Solution (Python):
from operator import itemgetter

n=int(input())
a=[int(x) for x in input().split()]
a_cm=[0]*n
a_i=[0]*n
for i in range(n):
    a_cm[i]=[i+1,a[i]]

a_cm.sort(key=itemgetter(1))
for i in range(n):
    a_i[i]=a_cm[i][0]

string=" ".join(map(str,a_i))
print(string)

Solution (Python):
n = int(input())
s = list(map(int, input().split()))
l = [(i, v) for i, v in enumerate(s)]
l.sort(key = lambda x: x[1])
a = ''
for i in l:
  a += str(i[0] + 1) + ' '
print(a[:-1])

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
xs = []
for i in range(N):
    xs.append((i+1, A[i]))

xs = sorted(xs, key=lambda x: x[1])

print(" ".join(str(x[0]) for x in xs))

Solution (Python):
N = int(input())
A = map(int, input().split())

V = []
for i, v in enumerate(A):
    V.append((v, i))

V.sort()

s = ""
for v in V:
    if len(s) > 0:
        s += " "
    s += str(v[1] + 1)

print(s)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

B = []
for i in range(1, N+1):
    B.append([A[i-1], i])
B.sort()

for i in range(N):
    print(B[i][1] ,end=' ')
print()

Solution (Python):
import numpy as np

N = int(input())
A = list(map(int, input().split()))
dict_ = {}

for i, n in enumerate(A):
  dict_[i] = n
  
dict_sorted = sorted(dict_.items(), key=lambda x:x[1])

for d in dict_sorted:
  print(d[0] + 1, end=" ")

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
s = []
for i in range(n):
  tmp = [a[i],i+1]
  s.append(tmp)

s.sort()

for i in range(n):
  print(s[i][1], end=' ')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = [0] * N

for i in range(len(A)):
    ans[A[i] - 1] += (i + 1)

print(*ans, sep=' ')

Solution (Python):
import numpy as np
n=input()
h = list(map(int, input().split()))

ind = np.argsort(h)
ind = ind +1
print(' '.join(map(str,ind)))

Solution (Python):
from operator import itemgetter

n = int(input())
a = list(map(int, input().split()))

l = [i for i, _ in sorted(enumerate(a, 1), key=itemgetter(1))]
print(*l)

Solution (Python):
import numpy as np
N = int(input())
A = list(map(int,input().split()))
B = list(range(1,N+1))
AB = np.array((A,B))
ABsort = AB[:,np.argsort(AB[0,:])]

output = ""
for i in range(N-1):
    output += "{} ".format(ABsort[1,i])
output += str(ABsort[1,-1])
print(output)

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]

res = [0] * n

for i in range(n):
    res[a[i]-1] = str(i+1)

print(' '.join(res))

Solution (Python):
n = int(input())
a = [int(x) for x in input().split()]

ans = [0 for x in range(n)]

for i in a:
    ans[a[i-1]-1] = i

print(*ans)

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
ans = [0]*N
for i,a in enumerate(A):
    ans[a-1] = i+1
print(*ans)

Solution (Python):
n = int(input())
a_lst = [int(elem) for elem in input().split()]
nums = [(num + 1) for num in range(n)]

tmp = zip(a_lst, nums)
tmp = sorted(tmp)
a_lst, nums = zip(*tmp)

res = list(list(map(str, nums)))
print(' '.join(res))

Solution (Python):
n = int(input())
aa = list(map(int,input().split()))

dic = {}
for i, ai in enumerate(aa):
  dic[ai] = i+1
  
ans=[]
for i in range(1,n+1):
  ans.append(str(dic[i]))  
  
print(' '.join(ans))

Solution (Python):
n= int(input())
a= list(map(int, input().split()))
b=[]
for i in range(1,n+1):
    b.append([a[i-1],i])
b.sort()
for i in b:
    print(i[1],end=" ")

Solution (Python):
import numpy as np

N = int(input())
A_list = np.array([int(A) for A in input().split(' ')])




A_sorted_index = np.argsort(A_list) + 1
A_sorted_index = A_sorted_index.astype(str)
A_sorted_index_str = ' '.join(A_sorted_index)

print(A_sorted_index_str)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

AI = [[A[i], i+1] for i in range(N)]
AI = sorted(AI)
ans = [ai[1] for ai in AI]

print(*ans)

Solution (Python):
n = int(input())
ans = []
j = 1
for i in map(int, input().split()):
    ans.append([i,j])
    j += 1
ans = sorted(ans, key=lambda x:x[0])
for i in range(n):
    print(ans[i][1],end=" ")

Solution (Python):
N = map(int, input().split())
j = list(map(int, input().split()))
print(" ".join(map(str, sorted(range(1, len(j)+1), key=lambda k: j[k-1]))))

Solution (Python):
n=int(input())
a=list(map(int,input().split()))

lis=[0]*n

for i in range(1,n+1):
    caca=int(a[i-1])
    lis[caca-1]=i

print(' '.join(map(str, lis)))

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
B = [0]*N
for k in range(N):
    B[k] = [k+1]*2
    B[k][0] = A[k]
B = sorted(B)
ans = [0]*N
for i in range(N):
    ans[i] = B[i][1]
print(*ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

ans = [0 for _ in range(N)]
for i, a in enumerate(A):
    ans[i] = [i+1, a]

ans.sort(key=lambda x: x[1])

ans2 = [x[0] for x in ans]
print(*ans2)

Solution (Python):
input()
a = sorted(enumerate(map(int, input().split()), start=1), key=lambda x: x[1])
print(*[i for i, _ in a])

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
Alist=[]
for i in range(N):
    Alist.append([A[i],i+1])

Alist.sort()

for i in range(N):
    print(Alist[i][1],end=" ")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

ans = [0] * n

for i in range(n) :
    ans[a[i]-1] = i + 1

print(*ans, sep=' ')

Solution (Python):
n = int(input())

a = list(map(int,input().split()))
b = [i for i in range(1,n+1)]

z = zip(a,b)
sorted_z = sorted(z)

new_a = []
new_b = []

for a_dash,b_dash in sorted_z:
	new_a.append(a_dash)
	new_b.append(b_dash)

print(new_b[0],end="")
for i in range(1,n):
	print(" ",end="")
	print(new_b[i],end="")

Solution (Python):
import numpy as np
N = int(input())
As = np.array(list(map(int, input().split())))
answers = list(np.argsort(As)+1)
print(" ".join(map(str,answers)))

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    N = II()
    a_list = LI()

    from operator import itemgetter

    import numpy as np
    A = np.array(a_list)
    arga = np.argsort(A)
    ind = np.array(list(range(N)))

    print(' '.join([str(a+1) for a in ind[arga]]))

solve()

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
anslst = [0] * N

for i in range(N):
    anslst[a[i] - 1] = i + 1

for i in anslst:
    print(i, end=' ')

Solution (Python):
n = int(input())
counts = list(map(int, input().split()))

order = [0] * n
for i, count in enumerate(counts):
  order[count-1] = i+1
  
print(' '.join(map(str, order)))

Solution (Python):
from sys import stdin
import numpy as np




def main():
    n = int(input())
    students = [int(x) for x in input().split()]
    ret = [0] * n
    for i in range(n):
        ret[students[i] - 1] = i + 1
    print(" ".join([str(x) for x in ret]))
    return


if __name__ == "__main__":
    main()

Solution (Python):
def c_go_to_school():
    N = int(input())
    A = [[int(a), k] for k, a in enumerate(input().split(), 1)]
    A.sort()
    return ' '.join([str(b) for a, b in A])

print(c_go_to_school())

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
cnt  = 0
submit = [0]*n
for i in range(n):
    submit[a[i] - 1] = i + 1
print(*submit)

Solution (Python):
N = int(input())

A = {k:v for v, k in enumerate(list(map(int, input().split())), 1)}

for k in range(1, len(A) + 1):
    print(A[k], end = " ")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
for i in range(n):
  a[i] = (a[i],i+1)
a.sort()
a = [str(i[1]) for i in a]
print(" ".join(a))

Solution (Python):
N = int(input())
Alist = list(map(int,input().split()))
junbannlist=[0]*N
for i in range(N):
    A = Alist[i]
    junbannlist[A-1] = i+1

for jun in junbannlist:
    print(jun,end=' ')

Solution (Python):
N = int(input())
Al = list(map(int,input().split()))
sd = {}
for i,A in enumerate(Al):
    sd[str(i+1)] = A

ans_l = []
for key,value in sorted(sd.items(),key=lambda x:x[1]):
    ans_l.append(key)

print(" ".join(ans_l))

Solution (Python):
n=int(input())
a=list(map(int, input().split()))

r=[0]*n

for i, val in enumerate(a):
    r[val-1] = i+1

print(" ".join([str(n) for n in r]))