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())
C=list(map(int,input().split()))
ans=[0]*(N+1)
for i in range(N):
  ans[C[i]]=i+1
ans.remove(0)
ans=' '.join([str(n) for n in ans])
print(ans)

Solution (Python):



a = []
n = input()
nums = [int(e) for e in input().split()]

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

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

for i in range(int(n)):
    print(str(a_sorted[i][0]+1), end=' ')

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

pairs = list(zip(range(1,N+1),A))
pairs = sorted(pairs, key=lambda x:x[1])
print(*(list(zip(*pairs))[0]))

Solution (Python):
N = int(input())
aaa = list(map(int, input().split()))
x = [(a, i) for i, a in enumerate(aaa, 1)]
x.sort()
ans = []
for a, i in x:
    ans.append(i)
print(*ans)

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

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

print(*t)

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

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

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

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

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate 

from collections import deque,defaultdict,Counter
import decimal
import re












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

def readInts():
  return list(map(int,input().split()))
def I():
  return int(input())
n = I()
A = readInts()
nya = []
for i in range(n):
    nya.append((i+1,A[i]))
nya = sorted(nya,key = lambda x:x[1])
ans = []
for (idx,po) in nya:
    ans.append(idx)
print(*ans)

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

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

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

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

ans = [j for _, j in B]

print(*ans)

Solution (Python):




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


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

al.remove(0)


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

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

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

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]*N

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

print(*B)

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

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

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

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


    
if '__main__' == __name__:
    resolve()

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

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

    dict2=sorted(d.items())

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


resolve()

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,a in enumerate(A):
    ans[a-1] = i + 1
print(*ans)

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

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

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

print(' '.join(b))

Solution (Python):
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

n=int(input())
a=lmp()
l=[]
for i in range(n):
    l.append([a[i],1+i])
l=sorted(l,key=lambda x:x[0])
ans=[]
for i in range(n):
    ans.append(l[i][1])
print(*ans)

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


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

  order = sorted(range(1, N+1), key=lambda i: A[i-1])

  print(*order, sep=' ')


if(__name__ == '__main__'):
  main()

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


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

  order = []
  for i in range(N):
    order.append((i+1, A[i]))
  order = sorted(order, key=lambda x: x[1])
  for i in range(N-1):
    print(order[i][0], end=' ')
  print(order[N-1][0])


if(__name__ == '__main__'):
  main()

Solution (Python):








def solve(N, As):
    students = [(As[i], i) for i in range(N)]
    students.sort()
    ans = ''
    for n, s in students:
        ans += ' ' + str(s + 1)
    print(ans.strip())


if __name__ == '__main__':
    
    N = int(input())
    
    As = [int(i) for i in input().split()]
    
    solve(N, As)

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

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

b = [i for i in range(1, n+1)]

d = dict(zip(a,b))

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

print(' '.join([str(sorted_d[i][1]) for i in range(n)]))

Solution (Python):
from heapq import heappush,heappop
n=int(input())
a=list(map(int,input().split()))
b=[]
for i in range(n):
  heappush(b,(a[i],i+1))
a=[]
for i in range(n):
  c,d=heappop(b)
  a.append(d)
print(*a)

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 = [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 = [None] * 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()))
D = {i: j for i, j in enumerate(A, 1)}
D = sorted(D.items(), key = lambda x: x[1])
print(*list(x[0] for x in D))

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

c=list(range(1,a+1))
d=[]
for i in range(a):
    d.append([c[i],b[i]])
d.sort(key=lambda x: x[1])
ans=[]
for i in range(a):
    ans.append(d[i][0])
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(' '.join(map(str,B)))

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

ans = [""]*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 = [""]*n

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

print(" ".join(ans))

Solution (Python):
import sys
input = sys.stdin.readline
from collections import defaultdict, deque

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

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

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

print(' '.join(t))

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

result = [0] * N
for i, v in enumerate(A):
    result[v-1] = str(i + 1)

print(' '.join(result))

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

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

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

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

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

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

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

Solution (Python):

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

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

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

Solution (Python):
import sys




from collections import deque






def input():
    return sys.stdin.readline().rstrip()


def main():
    N = int(input())
    A = list(map(int, input().split()))
    l = list()
    for i in range(N):
        l.append((A[i],i+1))
    l.sort()
    for i in range(N):
        print(l[i][1],end=" ")

if __name__ == "__main__":
    main()

Solution (Python):
import sys

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

N = I()
A = LI()

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

A.sort()

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

print(*B)

Solution (Python):


import sys
import math


from sys import stdin,stdout
from collections import deque,defaultdict
from math import ceil,floor,inf,sqrt,factorial,gcd,log2
from copy import deepcopy
ii1=lambda:int(stdin.readline().strip())
is1=lambda:stdin.readline().strip()
iia=lambda:list(map(int,stdin.readline().strip().split()))
isa=lambda:stdin.readline().strip().split()
mod=int(1e9 + 7)

n=ii1()
dp=[0]*(n+1)
arr=iia()
a=list(zip(arr,range(1,n+1)))
a.sort()
for i in range(n):
    print(a[i][1],end=' ')
print()

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
print(*rev)

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

lst = [[] for _ in range(n)]
for i in range(1,n+1):
  lst[al[i-1]-1] = i
print(*lst)

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

N = int(input())
A = list(map(int,input().split()))
Ac = list(range(1,N+1))
Alis = [[i,j]  for i,j in zip(A,Ac)]
As = sorted(Alis)
for a in As:
    print(a[1],end = " ")

Solution (Python):
import sys

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

tmp = {v: k+1 for k, v in enumerate(A)}
ans = []
for v, k in sorted(tmp.items(), key=lambda x: x[0]):
    ans.append(k)

print(*ans)

Solution (Python):

def solve():
    dp = [0] * N
    for i in range(N):
        dp[A[i]-1] = i+1
    for i in range(N):
        print(dp[i], end=" ")


if __name__ == "__main__":
    N = int(input())
    A = list(map(int, input().split()))
    solve()

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 in range(1, N + 1):
    ans[A[i - 1] - 1] = i

print(*ans)

Solution (Python):
N = int(input())
Alist = list(map(int, input().split()))
 
Alist = [[idx+1, a] for (idx, a) in enumerate(Alist)]
 
Alist.sort(key=lambda x:x[1])
 
ans = [str(a) for a, _ in Alist]
print(" ".join(ans))

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

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

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

print(*newa, sep=" ")

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


ans=[0]*N


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

print(' '.join(ans))

Solution (Python):
def main():
    n = int(input())
    inlis = list(map(int, input().split()))
    anslis = [0] * n
    for i in range(n):
        num = inlis[i]
        anslis[num-1] = i+1
    print(*anslis)
    
if __name__ == "__main__":
    main()

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

al = list(map(int, input().split()))
ail = []
for i,a in enumerate(al):
    ail.append((a,i+1))

ail.sort()
ans = []
for a,i in ail:
    ans.append(i)

print(*ans)

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

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

print(" ".join(alist))

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

Solution (Python):
def main():
    N = input()
    A = [(a, idx) for idx, a in enumerate(map(int, input().split()), start=1)]
    A.sort(key = lambda x: x[0])
    print(" ".join([str(a[1]) for a in A]))


if __name__ == '__main__':
    main()

Solution (Python):
n, *a = map(int, open(0).read().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()))
li = []

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


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

a = [li[i][1] for i in range(N)]
print(*a)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
for i, a in enumerate(A.copy(), 1):
    A[a - 1] = i
for a in A:
    print(str(a) + ' ', end='')
print()

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
ans=[None for i in range(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=[None for i in range(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_list = [None for _ in range(n)]
for i in range(0, n):
    ans_list[a[i] - 1] = str(i + 1)
print(" ".join(ans_list))

Solution (Python):
import numpy as np
n = int(input())
A = list(map(int, input().strip().split()))
arr = np.array(A)


print(' '.join(map(str, np.argsort(arr) + 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):


import sys

input = sys.stdin.buffer.readline

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

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

Ans = list()
for x,y in XY:
    Ans.append(y)

print(*Ans)

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

Solution (Python):
import numpy as np

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

A = np.argsort(A)

for a in A:
    print(a+1, end=" ")

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

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = {a:i for i,a in enumerate(A,1)}

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

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

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

print(*order)

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

dic = {}
ans = ''
for i in range(n):
    dic[a[i]] = i+1

for i in range(n):
    ans = ans + str(dic[i+1]) + ' '

print(ans)

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

A2 = [0]*N

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

print(*A2)

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

A2 = [0]*N

i =1
for a in A:
  A2[a-1] = i
  i+=1

print(*A2)

Solution (Python):
from math import gcd
n=int(input())
a=list(map(int,input().split()))
dic={}
for i,v in enumerate(a):
    dic[i+1]=v

dic_sorted = list(sorted(dic.items(), key=lambda x:x[1]))
for i in range(n):
    if i!=n-1:
        print(dic_sorted[i][0],end=' ')
    else:
        print(dic_sorted[i][0])

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

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

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

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

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

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

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

n=int(input())
lst=list(map(int,input().split()))
for i in range(n):
    lst[i]=[lst[i]]
for i in range(n):
    lst[i].append(i)
lst=sorted(lst,key=lambda x:x[0])
ans=[]
for i in lst:
    ans.append(i[1]+1)
print(" ".join(map(str,ans)))

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

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

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

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

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


sortedNum = sorted(d.items(), key=lambda x:x[1])
print(*[s[0] for s in sortedNum])

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

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, *aa = map(int, open(0).read().split())

print(*(x[1] for x in sorted(zip(aa, range(1,n+1)))))

Solution (Python):



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

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


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

for student in students:
    print(student[0], end=' ')
print()

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

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
S = [0] * (10 ** 5 + 2)
for i,a in enumerate(A):
    S[a] = i + 1
    
    

for n in range(1,N + 1):
    if n == N + 1 or n == N:
        print(S[n])
    else:
        print(S[n],end=" ")

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

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

L = " ".join([str(i) for i in X])
print(L)

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

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

L = " ".join([str(i) for i in X])
print(L)

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

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

L = " ".join([str(i) for i in X])
print(L)

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

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

L = " ".join([str(i) for i in X])
print(L)

Solution (Python):
n = int(input())
lst = list(map(int, input().split()))
dic = {}
for i in range(n):
  dic[lst[i]] = i + 1
s = ''
for i in range(n):
  s += str(dic[i + 1]) + ' '
print(s[:-1])

Solution (Python):
from operator import itemgetter
n = int(input())
lst = list(map(int, input().split()))
lst2 = []
for i in range(n):
  lst2.append((i + 1, lst[i]))
lst2.sort(key=itemgetter(1))
s = ''
for i in lst2:
  s = s + str(i[0]) + ' '
print(s[:-1])

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

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

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

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

del ans[0]
print(*ans)

Solution (Python):
"""
    こんにちは。これはクシャルです
    
    Author : thekushalghosh (クシャル)
    Team   : CodeDiggers
 
    I prefer Python language over the C++ language :p :D
        
    Visit my website : thekushalghosh.github.io
"""
import sys,math,cmath,time
start_time = time.time()



def solve():
    n = inp()
    a = inlt()
    q = sorted([[a[i],i + 1] for i in range(n)])
    print(*[q[i][1] for i in range(n)])
            


 
def main():
    global tt
    if not ONLINE_JUDGE:
        sys.stdin = open("input.txt","r")
        sys.stdout = open("output.txt","w")
    t = 1
    for tt in range(t):
        solve()
    if not ONLINE_JUDGE:
        print("Time Elapsed :",time.time() - start_time,"seconds")
        sys.stdout.close()
    

def inp():
    return(int(input()))
def inlt():
    return(list(map(int,input().split())))
def insr():
    return(input().strip())
def invr():
    return(map(int,input().split()))
 

def counter(a):
    q = [0] * max(a)
    for i in range(len(a)):
        q[a[i] - 1] = q[a[i] - 1],1
    return(q)
 
def string_counter(a):
    q = [0] * 26
    for i in range(len(a)):
        q[ord(a[i]) - 97] = q[ord(a[i]) - 97],1
    return(q)

def factors(n):
    q = []
    for i in range(1,int(n ** 0.5) + 1):
        if n % i == 0: q.append(i); q.append(n // i)
    return(list(sorted(list(set(q)))))

def prime_factors(n):
    q = []
    while n % 2 == 0: q.append(2); n = n // 2
    for i in range(3,int(n ** 0.5) + 1,2):
        while n % i == 0: q.append(i); n = n // i
    if n > 2: q.append(n)
    return(list(sorted(q)))

ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
    input = sys.stdin.readline
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
print(*ans)

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

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

print(" ".join(map(str,T[1:])))

Solution (Python):
n=int(input())
l=list(map(int,input().split()))
s=list(range(n))
s.sort(key=lambda i: l[i])
newl=""
for i in range(n):
    newl+=str(s[i]+1)+" "
newl=newl.strip()
print(newl)

Solution (Python):

N = int(input())
a = list(map(int, input().split()))
s = [-1]
s.extend(0 for _ in range(N))

for i, item in enumerate(a):
    s[item] = i+1

result = " ".join(map(str, s[1:]))
print(result)

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

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

student = list(range(0,N))

student.sort(key = lambda x:A[x])

for s in student:
    print(s+1,end= " ")

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
B = [[i, (idx + 1)] for idx, i in enumerate(A)]
B.sort()
for idx, j in enumerate(B):
    if idx != 0:
        print(" ", end="")
    print(j[1], end="")
print()

Solution (Python):









N = int(input())
list_A = list(map(int, input().split()))
student = list(range(N))

student.sort(key=lambda i: list_A[i])

ans = ""
for i in range(N):
    ans += str(student[i]+1) + " "
    
ans = ans.strip()

print(ans)

Solution (Python):
import sys
input = sys.stdin.readline
n = int(input())
a_li = [int(w) for w in input().split()]
student = list(range(0, n))
student.sort(key=lambda x: a_li[x])
for n in student:
    print(n + 1, end=" ")

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

Solution (Python):
N=int(input())
print(' '.join([str(s[1]) for s in sorted([(ai,bi) for ai,bi in zip(map(int,input().split()),range(1,N+1))],key=lambda x:x[0])]))

Solution (Python):
def INT():
    return int(input())

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

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

N = INT()
A = LI()

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

ans = []

for i in range(N):
    ans.append(A[i][0])
    
print(*ans)

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

Solution (Python):
import numpy as np

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

a = np.argsort(A)

a = list(a)

a = map(lambda x: x+1, a)

print(*a)

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

print(' '.join(ans))

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

print(' '.join(ans))

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

print(*ans)

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

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = map(int, read().split())

    B = [(a, i) for i, a in enumerate(A, 1)]
    B.sort()

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

    return


if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
N = int(input())
A = np.array([int(x) for x in input().split()])
Sort = [str(x) for x in np.argsort(A)+1]
print(' '.join(Sort))

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

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

a_ind_val_l = []
for i, a in enumerate(al):
    a_ind_val_l.append((a,i))

a_ind_val_l.sort()
ans = []
for aiv in a_ind_val_l:
    ans.append(aiv[1]+1)

print(*ans)

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

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

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

print(' '.join(a))

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

Solution (Python):
N = int(input())
A_s = list(map(int, input().split()))
A_s = list(map(lambda x:(x[1],x[0]+1), enumerate(A_s)))
A_s = sorted(A_s, key=lambda x:x[0])
print(" ".join(list(map(lambda x:str(x[1]), A_s))))

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

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

def main():
    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)

if __name__ == '__main__':
    main()

Solution (Python):
from collections import deque

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

ans=[]

A_dict={}

for n in range(N):
    a = A.popleft()
    A_dict[a]=n+1
    
for n in range(N):
    ans.append(A_dict[n+1])

print(*ans, sep=' ')

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

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

t = [0 for _ in range(N)]
for i, a in enumerate(A):
    t[a-1] = i+1
print(*t)

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

Solution (Python):
def main():
    n = int(input())
    a = [int(x) for x in input().split()]
    ans = [None] * n
    for idx, ea in enumerate(a):
        ans[ea-1] = idx+1
    print(*ans)
    
if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
print(*[i for i,a in sorted([[i+1, a] for i,a in list(enumerate(A))], key=lambda x: x[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,sep=' ')

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

print(*ans,sep=' ')

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

junban = {}

for i in range(n):
    junban[a[i]] = i

a.sort()

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

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

for i in B:
    print(i)

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