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()))
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=[int(c) for c in input().split()]
B=sorted([[i+1,A[i]] for i in range(N)],key=lambda x:x[1])
out=""
for b in B:
	out+=str(b[0])+" "
print(out[:-1])

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

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

ans = [i[1] for i in x]
print(*ans)

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

Solution (Python):
import numpy as np
import sys
input = sys.stdin.readline



def main():
    n = int(input())
    a = list(map(int, input().split()))
    b = np.argsort(a)
    print(*b+1)
    

if __name__ == "__main__":
    main()

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

Solution (Python):
import numpy as np

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

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

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

answer = [0]*N

for class_num , order in enumerate(A):
    answer[order - 1] = class_num + 1

print(*answer)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
dic = {}
for i in range(N):
    dic[A[i]] = i
dic = sorted(dic.items())
for i in dic:
    print("{} ".format(i[1] + 1), end="")

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

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

    array = ['']*n
    for i in range(n):
        array[a[i]-1] = str(i+1)
    print(' '.join(array))


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
A_key = list()
for i in range(N):
  A_key.append(i+1)
ans_dict = dict(zip(A,A_key))
ans_dict = dict(sorted(ans_dict.items()))
ans_list = list(ans_dict.values())
for i in ans_list:
  print(i)

Solution (Python):
n = input()
li = list(map(int,input().split()))
lists = []
for j in range(int(n)):
    lists.insert(j, 0)
count = 1
for i in li:
    lists[i-1] = count
    count += 1
print(' '.join(map(str, lists)))

Solution (Python):
N = int(input())
A_list = [int(x) for x in input().split()]
lst = [-1] * N
for i, A in enumerate(A_list):
    lst[A-1] = i+1
for p in lst:
    print(p, end=' ')
print()

Solution (Python):



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

for i in range(N):
    Q.append(1)

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

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

print()

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

ans = []
for i, a in enumerate(A, 1):
    ans.append([a, i])

ans = [a[1] for a in sorted(ans)]

print(*ans)

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

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

print(" ".join(a))

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

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

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

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


ans = []
for j in range(len(l)):
  if(j!=len(l)):
    print(l[j][0], end=" ")
  else:
    print(l[j][0])

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

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 = map(int, input().split())

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

B = sorted(B)
for i, x in enumerate(B):
    print(x[1], end = "")
    if i != len(B) - 1:
        print(" ", end = "")
    else:
        print("")

Solution (Python):

N = int(input())
A = list(map(int, input().split()))
ans = [[i+1] for i in range(N)]
for i in range(N):
    ans[i].append(A[i])
ans.sort(key=lambda x: x[1])
for i in range(N):
    print(ans[i][0], 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())
A = list(map(int,input().split()))
ord_sch = [0] * N
for i in range(N):
	pos = A[i] - 1
	ord_sch[pos] = i + 1
print(*ord_sch)

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

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

dic = [0]*n
for i in range(n):
    dic[a[i]-1] = str(i+1)
print(" ".join(dic))

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

b = list()
for i in range(n+1):
    b.append(0)
    
for i in range(n):
    b[a[i]] = i+1
    
for i in range(1,n+1):
    print(b[i],end=" ")

Solution (Python):
from operator import itemgetter
N = int(input())
A = [ int(i) for i in input().split(" ") ]
Z =[]
for i in range(1, N+1):
    Z.append([i, A[i-1]])
Z.sort(key=itemgetter(1))
for i in range(0,N):
    print(Z[i][0],end=" ")

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

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

print(" ".join(d))

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

from collections import OrderedDict
od = OrderedDict()

for n,i in enumerate(a):
  od[(n+1)] = i



od_sorted_value = OrderedDict(
    sorted(od.items(), key=lambda x: x[1], reverse=False)
)


ans = list(od_sorted_value.items())
for i,n in ans:
  print(i)

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
dic = {}

for i in range (n):
    dic[i] = l[i] 

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

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

Solution (Python):
A=dict(zip(range(1,int(input())+1),list(map(int,input().split()))))
B=sorted(A.items(),key=lambda x:x[1])
for b in B:
    print(b[0],end=" ")

Solution (Python):
n=int(input())
a=input().split()
lans=[int(i) for i in range(n)]
sp=' '
ans=''

for i in range(n):
	lans[int(a[i])-1]=i+1
ans+=str(lans[0])
for i in range(1,n):
	ans+=sp
	ans+=str(lans[i])
print(ans)

Solution (Python):
N = int(input())
A = []
A = list (map(int, input().strip().split(' ')))
B = [0 for i in range(N)]

i = 0
while i < N:
    B[A[i] - 1] = i + 1
    i += 1
    
for i in B:
    print(i, end = ' ')

Solution (Python):
N = int(input())
aa = map(int, input().split())
s = sorted([(a, i+1) for i, a in enumerate(aa)])
print(" ".join([str(i) for _, i in s]))

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

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

s.sort()

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

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

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

dic = dict(zip(range(1, N + 1), A))

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

for i in sort_dic:
    print(i[0], end = ' ')

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

index = 1
dic = {}

for i in A:
    dic[i] = index
    index += 1

sort_dic = sorted(dic.items(), key=lambda x:x[0])

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

Solution (Python):
a =[0]
n=input()
a += list(map(int, input().split()))
print(*sorted(range(1,len(a)), key=a.__getitem__))

Solution (Python):
N = int(input())
A = list(map(int, input().split(' ')))
A_indexed = [(a, index+1) for index, a in enumerate(A)]
A_indexed.sort(key=lambda a_indexed : a_indexed[0])
print(' '.join('{}'.format(a_indexed[1]) for a_indexed in A_indexed))

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

Solution (Python):

import numpy as np

n = int(input())
a = np.array(input().split(), dtype='int')

ans = np.empty(n, dtype='int')

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

print(*ans)

Solution (Python):
import numpy as np

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

print(" ".join([str(a + 1) for a in np.argsort(A)]))

Solution (Python):
import heapq

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

heap = list()
heapq.heapify(heap)
for i in range(n):
    heapq.heappush(heap, (lst[i], i))
res = ''
for i in range(n):
    a,b = heapq.heappop(heap)
    res += str(b+1) + ' '
print(res[:-1])

Solution (Python):
N = int(input())
order = [int(x) for x in input().split()]
order_sorted = sorted(range(len(order)), key=lambda k: order[k])
order_sorted = [x+1 for x in order_sorted]
print(*order_sorted)

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


N=int(input())
A = [[] for _ in range(N)]
a = list(map(int, input().split()))
for i in range(1,N+1):
    A[i-1].append(i)
    A[i-1].append(a[i-1])

A.sort(key=lambda x: x[1])
for i in range(N):
    print(A[i][0], end=" ")

Solution (Python):
n = int(input())
a = map(int, input().strip().split())
index = 1
dic = {}
for i in a:
    dic[i] = index
    index += 1
sort_dic = sorted(dic.items(),key=lambda x:x[0])
for i in sort_dic:
    print(i[1], end = ' ')

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = sorted(range(N), key=lambda i: A[i])
ans = list(map(lambda x: str(x + 1), ans))
print(' '.join(ans))

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

for i in range(len(A)):
    dictA[A[i]] = i + 1
sdictA = sorted(dictA.items())

for i in sdictA:
    print(i[1], end=" ")

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

dic={}
for i in range(N):
  dic[alist[i]]=i+1
  
ans_list=[]
for i in range(1,N+1):
  ans_list.append(str(dic[i]))

print(" ".join(ans_list))

Solution (Python):
import numpy as np

N = int(input())
A = [int(i) for i in input().split()]
arr = np.arange(N) 
for i in range(N):
    arr[A[i]-1] = i+1
for i in range(N):   
    print(arr[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
print(*ans)

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

ranges = [i for i in range(1, len(elems)+1)]
myElems = zip(elems, ranges)
newElems = sorted(myElems, key=lambda x: x[0])


res = []
for _,i in newElems:
	res.append(i)
print(*res)

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=list(map(int,input().split()))
b=[0]*n
for i,r in enumerate(l,0):
  c=r-1
  b[c]=i+1
c=[str(a) for a in b]
d=' '.join(c)
print(d)

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

Solution (Python):
n = int(input())
lst = input().split(" ")

dic = {}
for i, l in enumerate(lst):
  dic[int(l)] = i+1

ll = []
for i in range(1, n+1):
  ll.append(str(dic[i]))
  
answer = " ".join(ll)
print(answer)

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

ans = [0 for i in range(N)]
for i in range(N):
    idx = A[i]-1
    ans[idx] = str(i+1)
print(" ".join(ans))

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

a_to_i = {a: i + 1 for i, a in enumerate(al)}

al.sort()

print(' '.join(str(a_to_i[a]) for a in al))

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

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
ans_list = [0]*N
for i, j in enumerate(A, 1): 
  ans_list[j - 1] = i

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

Solution (Python):
import sys
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split()) 
DBG = True 

def ddprint(x):
  if DBG:
    print(x)

n = inn()
a = inl()
b = [(a[i],i) for i in range(n)]
b.sort()
for i in range(n):
  printn(str(b[i][1]+1))
  printn(' ')
print("")

Solution (Python):
import copy
import random
import bisect 
import fractions 
import math
import sys

mod = 10**9+7
sys.setrecursionlimit(mod) 

def LI(): return list(map(int, sys.stdin.readline().split()))

N = int(input())
A = LI()

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

aA = sorted(aA, key = lambda x:x[1])
for i in range(N):
    print(aA[i][0],end="")
    print(" ",end="")
print("")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
students = []
for i in range(n):
  student = dict(num=i+1, people=a[i])
  students.append(student)
students.sort(key=lambda x:x['people'])
answer = [student.get('num') for student in students]
for ans in answer:
  print(ans, end=' ')

Solution (Python):
import sys,os,math
from collections import Counter, defaultdict, deque
import bisect
from sys import stdin, stdout
from itertools import repeat








def solve():

    pass

def main():
    n = map(int, raw_input().split())[0]
    da = map(int, raw_input().split())
    l = []
    for idx, da in enumerate(da):
        l.append((da, idx+1))
    l.sort()
    
    print ' '.join(map(lambda x: str(x[-1]), l))



main()

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

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] = i + 1
print(*ans)

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

Solution (Python):
N = int(input())
nu = [int(x) for x in input().split()]
r2 = [None] * N
 
for i in range(len(nu)):
  r2[nu[i] - 1] = i


ans = ""
for i in range(len(r2)):
  ans += str(r2[i] + 1) + " "
print(ans)

Solution (Python):
N = int(input())
nu = [int(x) for x in input().split()]
r2 = [None] * N

for i in range(len(nu)):
  r2[nu[i] - 1] = i


print(" ".join([str(x + 1) for x in r2]))

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

Solution (Python):

n = int(input())

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


ans = [0] * n


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


print(' '.join(ans))

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

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

Solution (Python):
def main():
  n = int(input())
  a = [int(x) for x in input().split()]
  ls = [[0,int(x)+1] for x in range(n)]
  for i in range(n):
    ls[i][0] = a[i]
  ls = sorted(ls,key = lambda x:x[0])
  for i in range(n):
    print(ls[i][1],end=" ")
  print("\n")

if __name__ == "__main__":
	main()

Solution (Python):
def t(a):
    return " ".join([str(j + 1) for i, j in sorted([(j, i) for i, j in enumerate(a)])])


if __name__ == "__main__":
    n = int(input())
    a = list(map(int, input().split()))
    print(t(a))

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

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

Solution (Python):
n=int(input())
l=map(int, input().split())
A=[[i+1, rank] for i, rank in enumerate(l)]
A = sorted(A, key=lambda x:x[1])
print(" ".join(map(lambda x:str(x[0]), A)))

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

l = []
for i, x in enumerate(a, 1):
    l.append((x, i))

y = sorted(l)
for z, i in y:
    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] = i + 1
print(*B)

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

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

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

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

_n = int(input())
nlist = [item for item in map(int, input().split())]
jlist = [i for i in range(1, _n + 1)]

slist = sorted(zip(nlist, jlist))
slist = [item[1] for item in slist]
print(*slist)

Solution (Python):
N = int(input())
students = list(map(int, input().split()))
seat_num = {}
for i,student in enumerate(students ,1):
    seat_num[i] = student
seat_num_sort = sorted(seat_num.items(), key =lambda x: x[1])
seat_result = [s[0] for s in seat_num_sort]
print(' '.join(map(str, seat_result)))

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    ans = [0]*N
    for i, a in enumerate(A, 1):
        ans[a-1] = i
    print(' '.join(map(str, ans)))
    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 = [[a[i], i+1] for i in range(n)]
b.sort()
c = [b[i][1] for i in range(n)]
print(*c)

Solution (Python):
N = int(input())
A = []
rev = [0]*N 

for x in input().split():
    A.append(int(x))

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

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

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

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

Solution (Python):

N = int(input())
I = input().split()
A = []
for i in range(N):
    A.append([int(I[i]),i,])

b = sorted(A,key=lambda A :A[0])

print(b[0][1]+1, end=" ")

if N > 2:
    for i in range(1,N-1):
        print(b[i][1]+1, end=" ")

if N > 1:        
    print(b[N-1][1]+1, end =" ")

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

for i in range(N):
    num = lis[i] - 1
    first[num] = i

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

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

Solution (Python):
n = int(input())
ar = list(map(int, input().split()))
result = [0] * (n + 1)
for index, elm in enumerate(ar):
    result[elm] = index + 1
print(*result[1:])

Solution (Python):

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




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

print(" ".join(b))

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

arr = [-1] * N

for i in range(len(order)):
	arr[order[i] - 1] = i + 1

b = [print(i, end = " ") for i in arr]

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

a = sorted(range(n), key=lambda x: a[x])
a = [print(i+1, end=' ') for i in a]

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

AA = []
for i, ai in enumerate(A):
    AA.append([i+1, ai])

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

for a, b in AA:
    print(a, end=" ")

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
ans = [0]*N
for i, a in enumerate(A):
    ans[a-1] = i+1
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(*ans)

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

Solution (Python):
N = int(input())
K = list(map(int,input().split()))
M = dict(zip(range(1,N+1),K))
M = sorted(M.items(), key = lambda x:x[1])
newM = []
for i in M:
  newM.append(i[0])
print(*newM)

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    n = int(input().rstrip('\n'))
    a = [[v, i + 1] for i, v in enumerate(list(map(int, input().rstrip('\n').split())))]
    a.sort()
    print(*[a[i][1] for i in range(n)])


if __name__ == '__main__':
    slove()

Solution (Python):

_ = input()
arrive = {}
n = list(map(int,input().split()))
for i,n in zip(range(len(n)),n):
	arrive[i+1] = n
arrive = sorted(arrive.items(),key=lambda x:x[1])
for ar_tuple in  arrive :
	print(ar_tuple[0],end=" ")
print("")

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

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

Solution (Python):
import numpy as np
N = int(input())
A = list(map(int, input().split()))
print(*[i+1 for i in np.argsort(A)])

Solution (Python):
import numpy as np
N = input()
h = [int(i) for i in input().split()]

  
print(' '.join([str(i+1) for i in np.argsort(h)]))

Solution (Python):

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


dic = {}
for i in range(len(a)):
      dic.update([(i,a[i])]) 
      
new_dic = sorted(dic.items(),key=lambda x:x[1])

li = []
for i in range(len(a)):
      li.append(new_dic[i][0] +1) 
print(' '.join(map(str, li)))

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

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

d={}
for i in range(len(a)):
      d.update([(i,a[i])])
new_d = sorted(d.items(),key=lambda x:x[1])

p=[]
for i in range(len(a)):
      p.append(new_d[i][0]+1)
print(' '.join(map(str,p)))

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

classmate = [[0] * 2 for i in range(N)]

for i in range(len(number_classmate)):
    classmate[i][0] = number_classmate[i]
    classmate[i][1] = i+1

classmate.sort(key=lambda s: s[0])

mapped_list = map(str, list(i[1] for i in classmate))
first_index = ' '.join(mapped_list)

print(first_index)

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

cnt = 1
for i in A:
    A_dict[cnt] = i
    cnt += 1

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

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

Solution (Python):
from operator import itemgetter
n = int(input())
ordered_info = [ [i, int(num)] for i, num in zip(range(n), input().split(' '))]
ordered_info.sort(key = itemgetter(1))
ans = ''
for i, _ in ordered_info:
    print(i+1, end=' ')

Solution (Python):
n=int(input())
a=input()
A=a.split()
B=a.split()
C=[]
for i in range(len(A)):
    C.append(0)
for j in range(len(A)):
    A[j]=int(A[j])
for k in range(len(A)):
    C[A[k]-1]=k+1
for l in range(len(C)):
    C[l]=str(C[l])
s = ' '.join(C)
print(s)

Solution (Python):
N = int(input())
A_list = list(map(int,input().split()))
A_dict = {}

cnt = 1
for i in A_list:
    A_dict[cnt] = i
    cnt += 1

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




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

Solution (Python):
from operator import itemgetter
def main():
    N = int(input())
    A = [[i,int(inp)] for i,inp in zip(range(N),input().split(' '))]
    A.sort(key = itemgetter(1))
    for i,a  in A:
        print(i+1,end = ' ')
    return
main()

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
p = zip(a,[i for i in range(1,n+1)])
s = sorted(p)
for i in s:
    print(i[1],end=" ")

Solution (Python):
N = int(input())
d = []

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

d = list(zip(k, A))
d.sort(key=lambda x:x[1])

for b in range(N):
  print(d[b][0], end=" \n"[b + 1 == N])

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

Solution (Python):
N=int(input())
Ai = list(map(int, input().split()))
student_numbers = [i+1 for i in range(N)]
Ai_n_stu_num = list(zip(Ai, student_numbers))
Ai_n_stu_num.sort(key = lambda x:x[0])
i = 0
while (i < N):
    print(Ai_n_stu_num[i][1], end=" ")
    i+=1

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
b=[i+1 for i in range(n)]
c=list(zip(a,b))
c.sort(key=lambda x: x[0])
i=0
while(i<n):
	print(c[i][1],end=" ")
	i+=1

Solution (Python):
from sys import stdin
N = int(input())
A = list(map(int,stdin.readline().rstrip().split()))
B = [0] * N

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

for i in B:
    print(i)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
tmp = []
for idx, val in enumerate(A):
    tmp.append((val, idx + 1))

tmp.sort()

for i in tmp:
    print(i[1])

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    n = II()
    ans = 0
    for i in range(1, n + 1):
        ans += i & 1
    print(ans/n)
    return


def B():
    n, k = LI()
    h = LI()
    ans = 0
    for i in h:
        ans += i >= k
    print(ans)
    return


def C():
    n = II()
    a = LI()
    d = defaultdict(int)
    for i in range(n):
        d[a[i] + 1] = i + 1
    for _, v in sorted(d.items()):
        print(v, end=" ")
    print()
    return

def primes(n):
    """ Input n>=6, Returns a list of primes, 2 <= p < n """
    """ 6以上の数であれば p (素数) <= n のlistを返す """
    n, correction = n-n%6+6, 2-(n%6>1)
    sieve = [True] * (n//3)
    for i in range(1,int(n**0.5)//3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[      k*k//3      ::2*k] = [False] * ((n//6-k*k//6-1)//k+1)
            sieve[k*(k-2*(i&1)+4)//3::2*k] = [False] * ((n//6-k*(k-2*(i&1)+4)//6-1)//k+1)
    return [2,3] + [3*i+1|1 for i in range(1,n//3-correction) if sieve[i]]


def D():
    a, b = LI()
    p = primes(int(math.sqrt(max(a, b))) + 1)
    ans = 1
    for i in p:
        if a % i == b % i == 0:
            ans += 1
    print(ans)
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    C()

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

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

S = [' ']*N

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

print(" ".join(S))

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

sort = [1]*N
for k in range(0,len(A)):
    sort[A[k]-1] = k + 1
    
sort = list(map(str, sort))
ans = " ".join(sort)

print(ans)

Solution (Python):
print(" ".join(map(lambda x:str(x[0]),sorted([(n,int(a))for n,a in zip(list(range(1,int(input())+1)),input().split(" "))],key=lambda x:x[1]))))

Solution (Python):
print(" ".join(map(lambda x:str(x[0]),sorted([(n,int(a)) for n,a in zip(list(range(1,int(input()) + 1)),input().split(" "))],key=lambda x: x[1]))))

Solution (Python):
print(" ".join(map(lambda x: str(x[0]), sorted([(num, int(a)) for num, a in zip(list(range(1,int(input()) + 1)), input().split(" "))], key=lambda x: x[1],))))

Solution (Python):
n = int(input())
print(" ".join(map(lambda x: str(x[1]), sorted([(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))]))))

Solution (Python):
n = int(input())
a = sorted([(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))])
print(" ".join(map(lambda x: str(x[1]), a)))

Solution (Python):
n = int(input())
a = [(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))]
a.sort()
m = len(a)
for i in range(m):
    print(a[i][1],end="")
    if(i + 1 < m):
        print(" ",end="")
print()

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

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

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

for i in range(N):
    print(B[i])

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

Solution (Python):
import numpy as np

N = int(input())

A = np.array([int(i) for i in input().split()])

x = np.argsort(A)
x += 1

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

Solution (Python):
n = int(input())
li = list(map(int, input().split()))
li2 = [[0 for i in range(2)] for j in range(n)]

for i, item in enumerate(li):
    li2[i][0] = i + 1
    li2[i][1] = item

sortedList = sorted(li2, key=lambda x: x[1])
line = ""
for i in range(n):
    line += str(sortedList[i][0]) + ' '
print(line[:-1])