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()))
print(' '.join(list(map(str,list(map(lambda x: x+1,sorted(range(N), key=lambda x: A[x])))))))

Solution (Python):
from operator import itemgetter

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

print(*[t[0] + 1 for t in sorted(enumerate(A), key=itemgetter(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
for i in ans:
    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 + 1

for i in range(n):
  print(ans[i])

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

Solution (Python):
from sys import stdin


N = int(stdin.readline())
A = list(map(int, stdin.readline().split()))


toukou_list = [i for i in range(N)]

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

print(*toukou_list)

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

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

Solution (Python):
n=int(input())
order={}
for i,v in enumerate(input().split()):
    order[int(v)]=i+1
order = sorted(order.items(), key=lambda x:x[0])
for k,v in order:
    print(v,end=" ")
print()

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

Solution (Python):





N = int(input())
An = list(map(int, input().split()))
Rn = [0 for _ in range(N)]
for i in range(N):
  Rn[An[i]-1] = i+1
print(*Rn)

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

ans = ''
for tp in sorted(l):
    ans += (tp[1]+' ')

print(ans[:-1])

Solution (Python):



N = int(input())
A = list(map(int, input().split()))
work = [0] * N


for n in range(N):
    work[A[n] - 1] = str(n + 1)

print(" ".join(work))

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
b = []
c = [b]

for i in range(n):
    b.append(0)

for j in range(n):
    b[a[j]-1] = str(j+1)
    
print(' '.join(c[0]))

Solution (Python):
'''
>>> main(3,[2,3,1])
3 1 2

>>> main(5, [1, 2, 3, 4, 5])
1 2 3 4 5

>>> main(8,[8, 2, 7 ,3, 4, 5 ,6, 1])
8 2 4 5 6 7 3 1
'''


def main(n, a):
    l = [0 for _ in range(n)]

    count = 1
    for i in a:
        l[i - 1] = count
        count += 1

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


if __name__ == '__main__':
    n = int(input())
    a = map(int, input().split(' '))

    main(n, a)

Solution (Python):
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
b = [0]*n
for i in range(n):
    b[a[i]-1] = i+1

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

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
b = []
for i, num in enumerate(a):
  b.append([i+1, num])
  
b = sorted(b, key=lambda x:x[1])
print(*[l[0] for l in b])

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

lst = []
for i , j in enumerate(A):
  lst.append( [j,i+1] )
  
lst = sorted( lst )


print( * [ i[1] for i in lst ] )

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

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

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

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

c_list = []
for i, b in b_list:
    c_list.append(str(i))

print(' '.join(c_list))

Solution (Python):
N = int(input())
A = [int(i) for i in 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())
A=list(map(int,input().split()))

order=[0 for _ in range(N)]
for i in range(N):
    order[A[i]-1]=i+1

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

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

S = sorted(enumerate(A), key=lambda x: x[1])
S = map(lambda x: x[0] + 1, S)

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

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
tmp = list()
for n in range(len(A)):
  tmp.append([n+1, A[n]])
tmp = sorted(tmp, key=lambda x: x[1])
res = []
for x in tmp:
  res.append(x[0])
print(*res)

Solution (Python):

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

A_tuple_list = []

for i in range(len(A)):
    A_tuple_list.append((i, A[i]))

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


for a in A_tuple_list:
    print(a[0]+1, end=' ')

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
d={}
for i in range(1,1+n):
    d[a[i-1]]=i
sortd=sorted(d.items(),key=lambda x:x[0])
sl=[0]*n
for i in range(n):
    sl[i]=sortd[i][1]
print(*sl)

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

B = [[n+1, A[n]] for n in range(N)]
B.sort(key=lambda x:x[1])

ans = [B[n][0] for n in range(N)]
print(*ans)

Solution (Python):

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

"""
for h in range(1,N+1):
    for i in range(N):
        if A[i] == h:
            print(i + 1)

"""

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

for i in range(N):
    print(S[i][1])

Solution (Python):
from operator import itemgetter

N = int(input())
key = list(map(int, input().split()))
stu = list(range(1, len(key)+1))

key, stu = zip(*sorted(zip(key, stu), key=itemgetter(0)))

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

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

ans = [0 for i in range(n)]
for i,j in enumerate(a,1):
    ans[j-1] = str(i)
    
print(" ".join(ans))

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


print(*[l_ia[i][1] for i in range(n)])

Solution (Python):
n = int(input())
a = [int(s) for s in input().split()]
l_ia = []
for i in range(n):
    
    l_ia.append([a[i], i+1])
l_ia.sort()
turn = [l_ia[i][1] for i in range(n)]
print(*turn)

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

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

Solution (Python):
n = int(input())
a = map(int, input().split())
b = [i for i in range(1, n+1)]
c = dict(zip(a, b))
c = dict(sorted(c.items()))
for i in c.values():
    print(i, end = " ")

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

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

print(' '.join(b))

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

B = list(range(1,N+1))
ab = []
for i in range(N):
    ab.append([A[i], B[i]])
ab.sort()
for i in range(N):
    print(ab[i][1], end = " ")
print()

Solution (Python):
def solve(string):
    n, *a = map(int, string.split())
    ans = [0] * n
    for i, _a in enumerate(a, 1):
        ans[_a - 1] = str(i)
    return " ".join(ans)


if __name__ == '__main__':
    print(solve('\n'.join([input(), input()])))

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

Solution (Python):
import numpy as np
n=int(input())
s=np.argsort(np.array(list(map(int,input().split()))))+1
print(*s)

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

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

B = list(range(1,N+1))
ab = []

for i in range(N):
    ab.append([A[i], B[i]])

ab.sort()

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

print()

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):
from operator import itemgetter
import numpy as np
N = int(input())
A = [int(x) for x in input().split()]
ls = []
for i in enumerate(A,1):
    ls.append(i)
ls.sort(key=itemgetter(1))
ls = np.array(ls)
print(*ls[:,0])

Solution (Python):
import sys
N = int(input())
S = list(map(int,input().split()))
d = {}

for i in range(1,N+1):
  d[i] = S[i-1]


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

for i in range(0,len(d2)):
  print(d2[i][0])

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

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

B.remove(0)
B = map(str,B)

ans = ' '.join(B)
print(ans)

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

ans = np.argsort(a) + 1
ans = map(str, ans.tolist())
print(' '.join(ans))

Solution (Python):
def solve(string):
    n, *a = map(int, string.split())
    ans = [0] * n
    for i, _a in enumerate(a, 1):
        ans[_a - 1] = str(i)
    return " ".join(ans)


if __name__ == '__main__':
    print(solve('\n'.join([input(), input()])))

Solution (Python):
d = map(int, input().strip())
g = list(map(int, input().strip().split()))


h = []
for i in range(len(g)):
    h.append([g[i], i + 1])

h.sort()

for i in h:
    print(str(i[1]), end=' ')

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
people = {i:a for a,i in zip(A,[j for j in range(1,N+1)])}

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

P = [i[0] for i in people_sorted]
for p in P:
    print(p,end =" ")

Solution (Python):
def solve(string):
    n, *a = map(int, string.split())
    a = sorted([(_a, i) for i, _a in enumerate(a, start=1)])
    return " ".join([str(i) for _, i in a])


if __name__ == '__main__':
    print(solve('\n'.join([input(), input()])))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
leng = len(A)
B = []
for i in range(leng):
    B.append([A[i],i])
B.sort()
C = []
for i in range(leng):
    C.append(B[i][1]+1)
print(*C)

Solution (Python):


MOD = 10 ** 9 + 7

n = int(input())
an = list(map(int, input().split()))
an = [[an[i - 1], i] for i in range(1, n + 1)]
an.sort()

ans = ' '.join(map(lambda x: str(x[1]), an))

print(ans)

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(' '.join(map(str,ans)))

Solution (Python):
n = int(input())
a = list([int(x), int(y)+1] for x, y in zip(input().split(), range(n)))
a.sort()
for i in range(n):
    print(a[i][1], end=" ")

Solution (Python):
N = int(raw_input())
A = list(map(int,raw_input().split()))
ans = [0]*N
for (index,con) in enumerate(A):
  ans[con-1] = index+1
for i in ans:
  print i,

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

L=list()
for i in range(N):
    l=[A[i],i+1]
    L.append(l)
L.sort(key=lambda x:x[0])

s=str(L[0][1])
for i in range(N-1):
    s+=" "+str(L[i+1][1])
print(s)

Solution (Python):
N = int(input())
a_list = [int(h) for h in input().split()]
attendance_list = [0 for _ in range(N)]
for i, a in enumerate(a_list):
    attendance_list[a-1] = i + 1
for i, attendance in enumerate(attendance_list):
    if i == len(attendance_list) - 1:
        print(attendance)
    else:
        print(attendance, end=" ")

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

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

per = [0] * N
i = 1
for a in A:
    per[a - 1] = i
    i += 1


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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
m = {a[i]: i for i in range(n)}
res = [m[i] + 1 for i in range(1, n + 1)]
print(*res)

Solution (Python):
N = int(input())
A = [int(_) for _ in input().split(" ")]

tmp = sorted(range(1, len(A) + 1), key=lambda x:A[x - 1])
ans = [str(_) for _ in tmp]
print(" ".join(ans))

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

Solution (Python):
import numpy as np

N = int(input())
A = [int(_) for _ in input().split(" ")]

tmp = np.argsort(A)
tmp2= tmp + np.ones(N)
tmp3 = [int(_) for _ in tmp2.tolist()]
ans = [str(_) for _ in tmp3]

print(" ".join(ans))

Solution (Python):
import numpy as np

N = int(input())
A = [int(_) for _ in input().split(" ")]

ans = np.argsort(A)

for i in range(N):
    print(ans[i] + 1)

Solution (Python):
n = int(input())
A = list(map(int,input().split()))
l = []
for i, a in enumerate(A,1):
  l.append([i,a])
l = sorted(l, key=lambda x:x[1])
for i in range(len(l)):
  print(l[i][0], end=" ")

Solution (Python):
import numpy as np
n = input()
k = list(map(int , input().split()))
for i in (np.argsort(k)+1):
    print(i)

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

cnt=1
lst=[]
for i in A:
  lst.append([i,cnt])
  cnt+=1
  
lst=sorted(lst)
  
print( *[x[1] for x in lst])

Solution (Python):
def main():

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

if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np
n = int(input())
a = list(map(int, input().split()))
a2 = np.argsort(a) + 1
a3 = map(str, a2) 
mojiretsu = ' '.join(a3)

print(mojiretsu)

Solution (Python):
n = int(input())
an = [int(i) for i in input().split()]
ansl = [0]*n

for index,item in enumerate(an):
  ansl[item-1] = index+1
print(" ".join(map(str, ansl)))

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
for a in ans:
    print(a, end = " ")

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

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

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

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

print(*[ans[i][1] for i in range(n)])

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


if __name__ == "__main__":
    main()

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


if __name__ == "__main__":
    main()

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

for i in range(n):
  b[a[i]-1] = i+1
print(*b)

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


a = [0]*N
for i in range(N):
   a[A[i] - 1] = i + 1
         
print(' '.join(map(str, a)))

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(' '.join(map(str, ans)))

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

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

Solution (Python):
from operator import itemgetter
n = int(input())
list_a = list(map(int, input().split()))

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

list_a2 = sorted(list_a2, key = itemgetter(0))

print(" ".join(map(str, [x[1] for x in list_a2])))

Solution (Python):
import numpy as np

N, *A, = map(int, open(0).read().split())
B = np.empty(N, dtype=int)

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

Solution (Python):
import sys

def input():
    return sys.stdin.readline().rstrip('\n')

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

IA = [(i,A[i]) for i in range(N)]
IA.sort(key=lambda a: a[1])
I = [str(ia[0]+1) for ia in IA]
print(' '.join(I))

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

print(*X)

Solution (Python):
a=int(input())
ans=[]
la=input().split()
lis=[[int(la[i]),i] for i in range(a)]
lis=sorted(lis)
for i in range(a):
  if i!=a-1:
  	print(lis[i][1]+1,end=" ")
  else:
    print(lis[i][1]+1)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
from collections import defaultdict
d = defaultdict(int)
for i in range(N):
  d[A[i]] = i+1
print(' '.join([str(d[i]) for i in range(1,N+1)]))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
dict= {}
for i in range(1,N+1):
  dict[A[i-1]] = i
ret = [dict[v] for v in range(1,N+1)]
print(' '.join(map(str,ret)))

Solution (Python):
def solve(n, a):
    v = [(i, a[i]) for i in range(n)]
    u = [p+1 for p, q in sorted(v, key=lambda _:_[1])]
    return " ".join(map(str, u))

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
l = list(range(n))
a_ = []
ans = []
for _a, _l in zip(a, l):
    a_.append([_a, _l+1])
a_.sort()

for i in range(n):
    ans.append(a_[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[a-1] = i+1

[print(x, end=" ") for x in ans]

Solution (Python):
from collections import Counter,defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
def inpln(n): return list(int(sys.stdin.readline()) for i in range(n))

n = inp()
a = inpl()
aa = []
for i in range(n):
    aa.append([i+1,a[i]])
aa.sort(key=lambda x:x[1])
for i in range(n):
    print(aa[i][0])

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = [0 for _ in range(n)]
for i, x in enumerate(a, 1):
    ans[x - 1] = str(i)
print(' '.join(ans))

Solution (Python):
N = int(input())
r = [int(x) for x in input().split()]
l = []
for i in range(N):
  l.append((r[i], i+1))
l.sort()
for i in range(N-1):
  print(l[i][1], end = " ")
print(l[N-1][1])

Solution (Python):

from fractions import gcd

from math import factorial as f

from math import ceil,floor,sqrt

from sys import exit

from copy import deepcopy
import numpy as np

import bisect
import re


ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))



def main():

    n = ii()
    a = li()

    ans = list(sorted(range(n),key=lambda x: a[x]))
    ans = list(map(lambda x: x+1,ans))
    print(*ans)






main()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
X = sorted([(i, a) for i, a in enumerate(A)], key=lambda x:x[1])
ans = ""
for x in X:
  ans += "%d "%(x[0]+1)
print(ans)

Solution (Python):
t=int(input().strip())
li=[0]*500000
num=map(int,input().strip().split())
for idx,val in enumerate(num):
    li[val-1]=idx+1
for i in range(t):
    print(li[i],end=' ')
print()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
b=list(range(1,n+1))
dic=dict(zip(a,b))
dic=sorted(dic.items())
c=[]
for i in dic:
    c.append(i[1])
print(*c)

Solution (Python):
N = int(input().split()[0])
aa = input().split()
bb = [0]*N

for i in range(0, N):
    bb[int(aa[i]) - 1] = i + 1

print(*bb)

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

s = [""] * n
for i, x in enumerate(a):
    s[x-1] = str(i+1)

print(' '.join(s))

Solution (Python):
N = int(input())
A = [int(x) for x in input().split(' ')]

order = sorted(range(len(A)), key=lambda k: A[k])
order = [str(x + 1) for x in order]

print(" ".join(order))

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

d = [0]*N

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

print(' '.join(d))

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

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

result = sorted([{'i':i, 'a': a} for i, a in enumerate(A)], key=lambda x:x['a'])
print(' '.join([str(x['i'] + 1) for x in result]))

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

result = []
for i, a in enumerate(A):
    result.append({'i':i, 'a': a})

result.sort(key=lambda x: x['a'])
print(' '.join([str(x['i'] + 1) for x in result]))

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

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
nums = list(enumerate(A, start=1))
nums.sort(key=lambda x: (x[1], x[0]))
print(' '.join(map(str, (x[0] for x in nums))))

Solution (Python):

N = int(input())
student_list = [0] * (N + 1)
turn_list = [int(x) for x in input().split()]

for i, s in enumerate(turn_list):
    student_list[s] = i + 1
student_list.pop(0)
for s in student_list:
    print(str(s), end=' ')
print()

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(*B)

Solution (Python):


def main():
    N = int( input())
    A = list( map( int, input().split()))
    B = [ (A[i], i+1) for i in range(N)]
    B.sort()
    print( " ".join( map( str, map( lambda x:x[1], B))))
if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
def main():
    N = int(input())
    A = list(map(int,input().split()))
    num = [-1 for _ in range(N)]
    for i in range(N):
        num[A[i]-1] = i+1

    print(*num)

if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
l = list(map(int, input().split()))
d = []
for i in range(n):
  d.append((l[i],i+1))
d.sort(key = lambda x:x[0])
for i in range(n):
  print(d[i][1],end=' ')

Solution (Python):
t = int(input().strip())
li = [0] * 500000
num = map(int,input().strip().split())
for idx,val in enumerate(num):
    li[val - 1] = idx+1
for i in range(t):
    print(li[i],end=' ')
print()

Solution (Python):
N = int(input())
A = {int(x):i+1 for i,x in enumerate(input().split())}
for i in range(1,N):
    print(A[i],end=' ')
print(A[N])

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
d = {}
for i in range(n):
    d[a[i] - 1] = i + 1
for i in range(n):
    print(d[i], end=' ')
print('')

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    A = zip(range(1, N+1), A)
    A = sorted(A, key=lambda x: x[1])
    A = [str(a[0]) for a in A]
    S = ' '.join(A)
    print(S)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = [int(next(tokens)) for _ in range(N)]  
    solve(N, A)

if __name__ == '__main__':
    main()

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

Solution (Python):



def solve():
    N, *al = map(int, open(0).read().split())
    a_dic = {}
    
    for i in range(N):
        a_dic[i+1] = al[i]
    
    a_dic_soted = sorted(a_dic.items(), key=lambda x:x[1])
    
    for i in a_dic_soted:
        print(i[0], end=' ')


if __name__ == '__main__':
    solve()

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

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

for r in res:
    print(r, end = ' ')

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

b=list(enumerate(a))

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

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

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

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
_,a=zip(*sorted(zip(a,range(n))))
print(*[x+1 for x in a])

Solution (Python):
n=int(input())
l=list(map(int,input().split()))
ln=sorted([(l[i],i+1) for i in range(n)])
print(*[i[1]for i in ln])

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

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

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

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

alist = list(map(int, input().split()))
blist = [[i, alist[i]] for i in range(n)]
blist.sort(key=lambda x: x[1])
for studentID, howmany in blist:
    print(studentID+1)

Solution (Python):

n=int(raw_input())
a=map(int,raw_input().split())
s=[]
for i in range(n):
 s.append([i+1,a[i]])
s=sorted(s,key=lambda x:x[1])
for i in range(n):
 print s[i][0],
print

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

print(*b)

Solution (Python):
import numpy as np
n = int(input())
L = [int(i) for i in input().split()]
T = [-1 for i in range(n)]

for i in range(n):
  T[L[i]-1] = i+1

for i in range(n-1):
  print("{0} ".format(T[i]), end="")
print(T[-1])

Solution (Python):
N = int(input())
As = list(map(int,input().split(" ")))
for i in range(1,N+1):
    As[i-1]=(As[i-1],i)
As.sort(key = lambda x:x[0])
ans =list(map(lambda x:x[1],As))
print(*ans)

Solution (Python):
import sys


		
def main():
	n = int(input())
	al = list(map(int, input().split()))
	
	aal=[(i,v) for i,v in enumerate(al)]
	aal.sort(key=lambda x: x[1])
	
	ans_s=[str(i+1) for i,v in aal]
	print(' '.join(ans_s))
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)

if __name__ == "__main__":
	if sys.platform =='ios':
		sys.stdin=open('inputFile.txt')
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)

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

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

B = sorted(range(1, len(A) + 1), key=lambda k: A[k - 1])

for b in B:
    print(b)

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

Adict = {}
for i in range(1,n+1):
    Adict[A[i-1]] = i

Alist = sorted(Adict.items())
ans = [Alist[i][1] for i in range(len(Alist))]
print(*ans)

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

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

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
dic = {}

for i in range(N):
    dic.setdefault(i+1,A[i])

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


for item in new_dic:
    print(item[0],end=" ")
print()

Solution (Python):
import numpy as np
n = int(input())
L = [int(i) for i in input().split()]
T = [-1 for i in range(n)]

for i in range(n):
  T[L[i]-1] = i+1

for i in range(n-1):
  print("{0} ".format(T[i]), end="")
print(T[-1])

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

b = []
for i,e in enumerate(a):
  b.append((e,i+1))
  
b.sort()

for i,t in enumerate(b):
  if i == n-1:
    print(t[1])
  else:
    print(t[1],end=' ')

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

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

Solution (Python):
from operator import itemgetter
n = int(input())
aaa = list(map(int, input().split()))
bbb = sorted(list(enumerate(aaa, start=1)), key=itemgetter(1))
print(*map(itemgetter(0), bbb))

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

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

print(*O)

Solution (Python):

n=int(input())
A=[(e,i) for i,e in enumerate(list(map(int,input().split())))]
A.sort(key=lambda tup: tup[0])
for e,i in A:
    print(i+1)

Solution (Python):
import numpy as np
n = int(input())
a = list(map(int, input().split()))
li = np.argsort(a)+1
print(*li)

Solution (Python):
N = int(input())
As = list(map(int, input().split()))
B = [[i+1,j] for i,j in enumerate(As)]
B.sort(key=lambda x: x[1])
ans = ""
for i in B:
  ans += str(i[0]) + " "
print(ans)

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)
ans=' '.join(ans)
print(ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
P = [ (a, i+1) for (i, a) in enumerate(A) ]
P.sort()
print(" ".join([ str(p[1]) for p in P ]))

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

print(" ".join(ans))

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

for i in range(N-1):
    ans.append(0)

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

for i in range(N):
    print(int(ans[i]), end=' ')

Solution (Python):


def main():
    N = int(input())
    A = list(map(int,input().split()))
    B = [(Ai, i+1) for i, Ai in enumerate(A)]
    B.sort()
    print(" ".join([str(Bi[1]) for Bi in B]))

if __name__ == "__main__":
    main()

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

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

for i in range(len(a)):
    print(b[i][0]+1)

Solution (Python):
if __name__ == "__main__":
    n = int(input())
    studentNumbers = [(str(i + 1), int(x)) for i, x in enumerate(input().split())]
    studentNumbers.sort(key=lambda tup: tup[1])
    print(' '.join([x[0] for x in studentNumbers]))

Solution (Python):
from collections import OrderedDict
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)


def main():
    n = int(input())
    od = OrderedDict()
    a = list(map(int, input().split()))
    for i in range(len(a)):
        od[a[i]] = i+1

    p = OrderedDict(
        sorted(od.items(), key=lambda x: x[0])
    )

    print(*[v for k, v in p.items()])


if __name__ == '__main__':
    main()