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())
num = list(map(int, input().split()))
dp = [0] * n

for i, j in enumerate(num):
  dp[j - 1] = str(i + 1)

print(' '.join(dp))

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

Solution (Python):
import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))

turn = [" " for _ in range(n)]
for i in range(n):
  turn[a[i]-1] = i+1

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

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

for i,j in enumerate(a,1):
    li[j] = i

print(*li[1:])

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
L=[None]*N
for id,x in enumerate(A):
  L[x-1] = id+1
str_L=map(str,L)
print(' '.join(str_L))

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce


import sys
def I(): return int(input())
def Is(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(input())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = float('inf')


n = I()
A = LI()
B = [0]*n

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

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

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

a = [(j,i) for (i,j) in enumerate(a)]
a = sorted(a)
a = [i+1 for (_,i) in a]
print(*a)

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

S ={A[i]:i+1 for i in range(N)}

for i in range(N):
  print(S[i+1],end="")
  if i==N-1:
    print("")
  else:
    print(" ",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(n):
    b[a[i]-1] = i+1
for i in range(n):
    print(b[i],end=" ")

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

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

B = [0 for i in range(N)]

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

Solution (Python):
import sys
input = sys.stdin.readline
n=int(input())
a=list(map(int,input().split()))

turn=[" " for _ in range(n)]
for i in range(n):
  turn[a[i]-1]=i+1

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

Solution (Python):

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

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

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

Solution (Python):


N = int(input())
A = [int(a) for a in input().split()]
D = {}
for i in range(N):
    D[i] = A[i]
sort = sorted(D.items(), key=lambda x: x[1])
ans = [i[0] + 1 for i in sort]
print(*ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
alist = [(i, x) for i, x in enumerate(a, start=1)]
alist.sort(key=lambda x: x[1])
slist = [str(x) for i, (x, y) in enumerate(alist)]
print(' '.join(slist))

Solution (Python):
n = int(input())
a = list(map(int , input().strip().split()))
students = {}
ans = []

for i in range(len(a)):
  students[i] = a[i]
students= sorted(students.items(), key=lambda x:x[1])

for i in range(n):
  ans.append(str(students[i][0] + 1))

print(' '.join(ans))

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

d={}
for i in range(N):
  d[i]=A[i]
  




ans=sorted(d.items(), key=lambda x:x[1])
for i in range(N):
  print(ans[i][0]+1,end=' ')

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

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

ans = " ".join(ans)
print(ans)

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
num = list(range(1, n+1))

cin = dict(zip(a, num))
ans =[]

for i in range(n):
    ans.append(cin[i+1])

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

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

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

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

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

ans = [0] * n
for i, x in enumerate(a):
    ans[x-1] = i + 1
print(*ans)

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

print(*ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
B = []
for i in range(N):
  B += [[A[i], i+1]]
B.sort(key=lambda x:x[0])
for a, b in B:
  print(b, 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()))

res = [0] * (N + 1)

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

print(*res[:-1])

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

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

for i in range(n):
    order[A[i]] = i+1

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

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


d={}

for i in range(N):
    d[i+1]=Students[i]

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

ans=[]
for k in d_2:
    ans.append(k[0])

print(*ans)

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

Solution (Python):
def main():
    N = int(input())
    A = list(map(int, input().split(' ')))
    ordered_students = ['' for _ in range(N)]
    for i, a in enumerate(A):
        ordered_students[a - 1] = str(i + 1)
    print(' '.join(ordered_students))


if __name__ == '__main__':
    main()

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
ans=[str(a) for a in ans]
ans=' '.join(ans)
print(ans)

Solution (Python):
import math

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

Solution (Python):

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

rev=[0]*n
for i in range(n):
    rev[a[i]-1]=i+1
for i in range(n):
    print(rev[i],end=" ")
print()

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

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

Solution (Python):
def main():
    _ = input()
    A = list(map(int, input().split()))
    d = dict()
    for i in range(len(A)):
        d[i+1] = A[i]
    d = sorted(d.items(), key=lambda x: x[1])
    print(*[l[0] for l in d])


if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np

N = int(input())
A = list(map(int,input().split()))
print(*(np.argsort(A)+1))

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

ll = [(l[i],i) for i in range(N)]

ll.sort()

lll = [str(ll[i][1]+1) for i in range(N)]

print(" ".join(lll))

Solution (Python):
N=int(input())
A=[int(i) for i in input().split(" ")]
cl=[(i,A[i]) for i in range(N)]
cl.sort(key=lambda a:a[1])
print(
    str([cl[i][0]+1 for i in range(N)]).strip("[]").replace(",","")
)

Solution (Python):

import numpy as np
from collections import deque
import collections
import itertools
import bisect
mod = 10 ** 9 + 7
N = int(input())
A = list(map(int, input().split()))
num_dict = {}
for i, a in enumerate(A):
    num_dict[i] = a
dic2 = sorted(num_dict.items(), key=lambda x: x[1])
for id_, num_people in dic2:
    id_ += 1
    print(id_, end=' ')

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

print(*result)

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

for c in ans:
    print("{} ".format(c), end="")

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

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

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

A_number = [int(x) for x in range(1,N+1)]

dic_A = dict(zip(A_list,A_number))
dic_A_sort = sorted(dic_A.items())

for i in range(N):
    print(dic_A_sort[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)

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()))
ans = [0]*N

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

print(" ".join(ans))

Solution (Python):

def inputlist(): return [int(k) for k in input().split()]

N = int(input())
A = inputlist()
dic = {}
li = [int(i) for i in range(1,N+1)]
for i in range(N):
    dic[A[i]] = i+1
lia = []
for i in range(1,N+1):
    lia.append(dic[i])
print(*lia)

Solution (Python):
n = int(input())
nums = list(map(int, input().split()))
pairlist = []
for i in range(len(nums)):
    pairlist.append([i, nums[i]])

sortedPairList = sorted(pairlist, key=lambda item: item[1])

result = []
for i in sortedPairList:
    result.append(str(i[0]+1))
print(" ".join(result))

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

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

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()))
ls = [-1] * n
c = 0
for i in a:
    ls[i - 1] = c + 1
    c+=1
ls = [str(i) for i in ls]
l = " ".join(ls)
print(l)

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

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

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

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

ans = [0] * N

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

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

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

dic={}
for i,a in enumerate(A):
  dic[a]=str(i+1)

for k,v in sorted(dic.items()) :
  print(v)

Solution (Python):
n = int(input())
a_l = list(map(int,input().split()))
b_l = []
for i, num in enumerate(a_l):
    b_l.append((num,i+1))
b_l.sort()
ans = ''
for num, i in b_l:
    ans += str(i)+' '
print(ans[:-1])

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

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

Solution (Python):
n,*a=map(int,open(0).read().split())
a=sorted([(a_i,i) for i,a_i in enumerate(a)])
a=[a[i][1]+1 for i in range(n)]
print(*a)

Solution (Python):
n = int(input())
ls = list(map(int,input().split()))
ls2 = [0 for i in range(n)]
for j in range(n):
    a = ls[j]

    ls2[a - 1] = j + 1
for k in range(n):
    print(ls2[k], end = " ")

Solution (Python):
N = int(input())
arr = list(map(int, input().split()))
renban = list(range(1,N+1))

dp = [[0] * 2 for _ in range(N)]

for i in range(N):
    dp[i][0] = i+1
    dp[i][1] = arr[i]

dp.sort(key=lambda x:x[1])
arr2 = []
for i in range(N):
    arr2.append(dp[i][0])

print(*arr2)

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

dic = {keys[i]: i + 1 for i in range(N)} 
l = sorted(dic.items())

for val in l:
    print(val[1], end=" ")

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

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

print(*ans)

Solution (Python):
N = int(input())
lis = list(map(int,input().split()))
dic = {}
for i,popu in zip(range(1,N+1),lis):
    dic[popu] = i
for j in range(1,N+1):
    print(dic[j],end = " ")

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

for i in range(n):
    ANS.append([A[i],i+1])
    
ANS = sorted(ANS)

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

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

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

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

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

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

Solution (Python):

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

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

B.sort()

ans = [0 for i in range(N)]
for i in range(N):
    ans[i] = B[i][1]

print(*ans)

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

values = [None] * N
for i in range(N):
    values[i] = i + 1

dic = {key : val for key, val in zip(keys, values)} 
for i in dic.values():
    print(i, end=" ")

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

Solution (Python):
n=int(input())
as_=list(map(int,input().split()))
l=as_.copy()
for i,a in enumerate(as_):
    l[a-1]=i+1
for v in l:
    print(v, end=' ')
print('')

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

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()))
C=[0]*N
for i in range(N):
  C[A[i]-1]=i+1
print(*C)

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

d = [ x for x in enumerate(l)]
d.sort(key=lambda d: d[1])

print(*[i+1 for i,j in d])

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
L = {}
for i in range(len(a)):
    L[i] = a[i]
sort_L = sorted(L.items(), key=lambda x: x[1])
[print(j[0]+1, end=' ')for j in sort_L]

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ai = [(a_, i) for i, a_ in enumerate(a)]
ai.sort()

ans = ' '.join([str(i+1) for a, i in ai])
print(ans)

Solution (Python):
import sys
input=sys.stdin.readline
N = int(input())
L = list(map(int,input().split()))

answer = [None] * N
for i, num in  enumerate(L):
    answer[num-1] = i+1
print(*answer)

Solution (Python):
def resolve():
    n=int(input())
    l1=list(map(int, input().split()))
    l2=[]
    for i in range(1,n+1):
        l2.append([l1[i-1],i])
    l2.sort()
    for i in l2:
        print(i[1],end=' ')
resolve()

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='')
	print(' ',end='')
print()

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

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
num = {}
for i in range(N):
  num[i+1] = A[i]
num_sorted = sorted(num.items(), key = lambda x : x[1])
for i in range(N):
  print(num_sorted[i][0], end = " ")

Solution (Python):
from collections import deque

N = int(input())
A = list(map(int, input().split()))
A = list(enumerate(A))
A.sort(key = lambda x: x[1])

ans = deque()

for a in A:
    ans.append(a[0] + 1)

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

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

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

ans = [i + 1for i, v
       in sorted(enumerate(A), key=lambda x: x[1])]
print(*ans)

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

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

















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()))
B = [0]*N
for i in range(N):
  B[A[i]-1] = i + 1
print(*B)

Solution (Python):
import sys
import math
from collections import Counter
import itertools



def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())

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

def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SR(): return sys.stdin.readline().rstrip()

ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ascii_uppercase2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'


p2D = lambda x: print(*x, sep="\n")
p2E = lambda x: print(''.join(x))
p2S = lambda x: print(*x, sep=" ")



N=II()
A=LI()
L=[_ for _ in range(N)]
i = 1
for a in A:
    L[a-1] = i
    i += 1
p2S(L)

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

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

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
i_a = [[a,i+1] for i,a in enumerate(A)]
i_a.sort()

ans = []
for i,a in i_a:
  ans.append(a)
  
print(' '.join(map(str,ans)))

Solution (Python):
import numpy as np
n = int(input())
a = [list(map(int,input().split())),[i for i in range(1,n+1)]]
b = np.array(a).T
b_sort = b[np.argsort(b[:,0])]
b_list = b_sort[:,1].tolist()
for i in b_list:
    print(i,end=' ')

Solution (Python):

N = int(input())
A = list(map(int, input().split()))
print(' '.join( str(a) for a in [y for x,y in sorted({A[i]:i+1 for i in range(N)}.items(), key = lambda x:x[0])]))

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-1):
    print(ans[i], end=' ')
print(ans[n-1])

Solution (Python):
N = int(input())
arr= [0]
arr.extend(list(map(int,input().split())))
arr2 = [0 for _ in range(N+1)]
for i in range(len(arr)):
	arr2[arr[i]]=i
for i in range(1,N+1):
	print(arr2[i],end=" ")

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

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

ansdic=sorted(B.items(), key=lambda x:x[0])
l=[]
for i in ansdic:
    l.append(i[1])

print(*l)

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

Solution (Python):
import numpy as np
n = int(input())
A = np.array(list(map(int, input().split())))
print(*(np.argsort(A)+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())
b =list(map(int,input().split()))

res=[0] * n

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

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

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

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

for i in range(n):
    print(dict_b[i][0])

Solution (Python):
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
def S(): return input()
def I(): return int(input())
def MS(): return map(str,input().split())
def MI(): return map(int,input().split())
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in input()]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]

N = I()

A = LI()

a_index = {}
for i in range(N):
    a_index[A[i]] = i+1

sa = sorted(A)

result = []
for v in sa:
    result.append(a_index[v])

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

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
ans = [None] * 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()))
l = list("")
for i in range(n):
    l.append([a[i], i + 1])
l.sort()
ans = ""
for i in range(n):
    if i == n - 1:
        ans += str(l[i][1])
    else:
        ans += str(l[i][1]) + " "
print(ans)

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

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

result = []

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

result.sort()
li = []

for i in range(N):
    li.append(result[i][1])

print(*li)

Solution (Python):
N = int(input())
A_list = list(map(int, input().split()))
index_add_A_list = []
for i, A in enumerate(A_list):
    index_add_A_list.append([i, A])
sorted_index_add_A_list = sorted(index_add_A_list, key=lambda x: x[1])
for a in sorted_index_add_A_list:
    print(a[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())
As = list(map(int, input().split()))
ordList = [None] * N
noCount = 1
for i in As:
    ordList[i-1] = str(noCount)
    noCount += 1
print(' '.join(ordList))

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

def readlines(n):
    for _ in range(n):
        yield map(int, input().split())


def main():
    N = int(input())
    A = sorted(enumerate(map(int, input().split()), 1), key=lambda x: x[1])
    print(" ".join(str(i) for i, a in A))

main()

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
ans = sorted(range(1, N+1), key=lambda x: A[x-1])


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

Solution (Python):
import os

def main():
	n = int(input())
	a_list = list(map(int, input().split()))
	count = 0
	result = [0]*n
	result_str = ""
	for i,v in enumerate(a_list):
		result[v-1] = i+1
	for i in result:
		result_str += str(i) + " "	
	print(result_str)

if __name__ == "__main__":
	main()

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

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

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

key = 1
d = {}

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


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

for i in range(len(d)):
    print(d[i][0], end=" ")

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

Solution (Python):




n = int(input())
a = list(map(int,input().split()))
tbl = [-1] * (n+1)


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

tbl.pop(0)


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

Solution (Python):
n = int(input())
li = list(map(int, input().split()))
dd = {}
for i in range(1, n+1):
    dd[i] = 0
for i in range(n):
    dd[li[i]] += i+1

an = []
for i in range(1, n+1):
        an.append(str(dd[i]))

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

Solution (Python):
def main():
    N = int(input())
    A = [int(a) for a in input().split()]
    P = list()
    for i in range(N):
        P.append([A[i], i+1])
    P = sorted(P, key=lambda x: x[0])
    for i in range(N):
        stu = P[i]
        print(stu[1], end=" ")
    print()
if __name__ == "__main__":
    main()

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

import numpy as np

ll = np.array(nn)
p = list(ll.argsort())

for i in p:
  print(i+1)

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

for i in range(N):
    Answer.append(0)

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

print(*Answer)

Solution (Python):
from math import factorial as fact
import math
import fractions
import sys
import itertools
import numpy as np
from collections import Counter
import datetime

def input1():
	return int(input())


def input2():
	return map(int,input().split())


def input_array():
	return list(map(int,input().split()))

def keta(N):
	return len(str(N))


def input_daytime(input_time):
	time,distance=input_time.split()
	t=time.split(":")
	se=str(t[-1]).split(".")
	dt1 = datetime.timedelta(hours=int(t[0]),minutes=int(t[1]),seconds=int(se[0]),milliseconds=int(se[1]))
	return dt1

def combinations(n,r):
	return list(itertools.combinations(n,r))

def all_sets(num_list):
	subsets=[]
	for i in range(2,len(num_list) + 1):
		for c in combinations(num_list, i):
			subsets.append(c) 
	return subsets


def CountOneRoots(x,y):
	
	return fact(x+y)/fact(x)/fact(y)



n=input1()
A=input_array()

result=[0 for _ in range(n)]
for i in range(n):
	result[A[i]-1]=str(i+1)
print(" ".join(result))

Solution (Python):

n = int(input())

A = [int(x) - 1 for x in input().split()]

B = [0] * n

for i in range(n):
    B[A[i]] = i

print(' '.join(map(lambda x: str(x + 1), B)))

Solution (Python):
import sys
from io import StringIO
import unittest


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

    b = [(aa, i + 1) for i, aa in enumerate(a)]

    b.sort()

    print(' '.join([str(bb) for i, bb in b]))

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """3
2 3 1"""
        output = """3 1 2"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """5
1 2 3 4 5"""
        output = """1 2 3 4 5"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """8
8 2 7 3 4 5 6 1"""
        output = """8 2 4 5 6 7 3 1"""
        self.assertIO(input, output)

if __name__ == "__main__":
    
    resolve()

Solution (Python):
n=int(input())
l=list(map(int,input().split()))
ans=[None]*n
i=1
for index in l:
  ans[index-1]=str(i)
  i+=1
print (" ".join(ans))

Solution (Python):
from collections import defaultdict
d = defaultdict(int)
N = int(input())
A = list(map(int, input().split()))
for i, v in enumerate(A):
    d[i + 1] = v
ans = []
d_swap = {v: k for k, v in d.items()}
sd = sorted(d_swap.items())
for i, v in enumerate(sd):
    ans.append(v[1])
print(' '.join(map(str, ans)))

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

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

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

print(" ".join([str(temp[1]) for temp in temp_list]))

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

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

for i, name in enumerate(a):
  a_sort[name-1] = str(i + 1)
print(' '.join(a_sort))

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

o_list = [0] * (n + 1)
for i, a in enumerate(a_list):
    o_list[a] = i + 1

print(" ".join([str(o) for o in o_list[1:]]))

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

Solution (Python):
import numpy as np
n = int(input())
aa = list(map(int, input().split()))
oo = [str(a) for a in np.argsort(aa)+1] 
print(" ".join(oo))

Solution (Python):

import sys
input=sys.stdin.readline

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 l in range(N):
    print(ans[l],end=" ")

print("")