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):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  

N = I()
A = LI()
for i in range(N):
    A[i] = (A[i],i)
A.sort()

print(*[A[i][1]+1 for i in range(N)])

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 i,a in ail:
    ans.append(a)

print(*ans)

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

ans= [0] * len(A)
for i,a in enumerate(A):
    ans[a-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):
def some():
    n = int(input())
    h = map(int, input().split(" "))
    h = sorted((i, index) for index, i in enumerate(h, 1))
    print(" ".join(str(num) for _, num in h))
some()

Solution (Python):
import sys
import numpy as np
import numba
from numba import jit

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

@jit
def main(n, a):
  ans = np.zeros(n)
  for i, j in enumerate(a):
    ans[j-1] = i+1
  for i in ans:
    print(int(i), end=' ')
n = int(readline())
a = np.array(readline().split(), np.int64)
main(n,a)

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

ans_list = [0]*n
for i, j in enumerate(num_list):
    ans_list[j-1] = str(i+1)

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

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

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

Solution (Python):
n=int(input())
a=[int(x) for x in 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()))

aa = [[a[i], i] for i in range(n)]
aa.sort()

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

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

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

order=dict(zip(num,a))

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

ans=[]

for i in range(n):
  ans.append(order2[i][0])

print(' '.join([str(n) for n in ans]))

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

n_lis=[i for i in range(1,n+1)]
dic={i:j for i,j in zip(l,n_lis)}
num_lis=[str(dic[i]) for i in range(1,n+1)]
print(' '.join(num_lis))

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

a = [int(e) for e in 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())

a = [int(e) for e in 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())
l=list(map(int,input().split()))
ans=[0]*n
for i in range(len(l)):
    ans[l[i]-1]=i+1
print(*ans)

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

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=" ")

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=" ")

Solution (Python):
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy


import heapq
sys.setrecursionlimit(10**6)

INF = 10**18
import bisect
import statistics
mod = 10**9+7

import numpy

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

a = numpy.argsort(A)
b = []
for i in range(N):
    b.append(str(a[i]+1))

print(" ".join(b))

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

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

res = ' '.join(attend)

print(res)

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

a = [(a[i], i+1) for i in range(n)]
a.sort(key=lambda x: x[0])
b = list(zip(*a))
ans = b[1]

print(*ans)

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

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

for i in a:
  num[i-1]=count
  count=int(count)
  count+=1
  count=str(count)
  
print(" ".join(num))

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy








def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

n = inp()
l = inpl()
dic = {}
for i in range(0, len(l)):
    dic.setdefault(i, l[i])
sl = sorted(dic.items(), key=lambda x:x[1])
ans=[str(x[0] + 1) for x in sl]
print(' '.join(ans))

Solution (Python):
import sys, bisect, math, itertools, string, queue, copy








def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])

n = inp()
l = inpl()
dic = {}
for i in range(0, len(l)):
    dic.setdefault(i, l[i])
ans = ''
sl = sorted(dic.items(), key=lambda x:x[1])
for d in sl:
    ans = ''.join([ans,' ', str(d[0] + 1)])
print(ans)

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

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

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

Solution (Python):
import numpy as np

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()))
order = [0] * n
for i in range(n):
    order[a[i]-1] = i+1
for i in range(n):
    print(order[i], end=" ")

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

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

Solution (Python):

import sys 
input = sys.stdin.readline

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

d = {}
for i in range(n):
    d[i] = a[i]

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

print(ans)

Solution (Python):
n = int(input()) 
a_list = list(map(int, input().split()))
res = sorted(range(n), key=lambda k: a_list[k])
print(' '.join(list(map(lambda x: str(x+1), res))))

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

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

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

sorted_a.sort()

ans = []
for i in range(n):
    ans.append(sorted_a[i][1]+1)
print(*ans)

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

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

b=sorted([(a[i],str(i+1)) for i in range(n)],key=lambda x:x[0])

print(' '.join([c for _,c in b]))

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

Solution (Python):
N = int(input())
A = list(map(lambda a: int(a), input().split(" ")))
B = [{"id": i + 1, "order": A[i]} for i in range(len(A))]

B.sort(key=lambda b: b["order"])

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

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):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


n = int(input())
a = list(map(int, input().split()))
aa = [(num,i) for i,num in enumerate(a)]
aa.sort()
write(" ".join(map(str, [item[1]+1 for item in aa])))

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

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

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

print(" ".join(ans))

Solution (Python):
n = int(input())
l = list(map(int, input().split()))
c = {}
for i in range(n):
  c[l[i]] = i + 1
c = sorted(c.items())
[print(s[1], end=" ") for s in c]

Solution (Python):
def gotoS(org, n):
	res = [0] * n
	for i in range(1, n+1):
		res[org[i-1]-1] = i
	return res
n = int(input())
org = list(map(int, input().split()))
print(*gotoS(org, n))

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

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):
if __name__ == '__main__':
    N = int(input())
    A = list(map(int, input().split()))
    D = [0]*(N)
    for i, a in enumerate(A):
        D[a-1] = i+1
    
    print(*D)

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

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

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

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

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










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

sl = sorted(l, key=lambda x: x[1])
sl0 = [r[0] for r in sl]
print(' '.join([str(_) for _ in sl0]))

Solution (Python):
import math
import numpy as np

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










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

sl = sorted(l, key=lambda x: x[1])
sl0 = [r[0] for r in sl]
print(' '.join([str(_) for _ in sl0]))

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

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





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

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

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

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

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

Solution (Python):

import numpy as np

n = int(input())
a = list(map(int, input().split()))
ans = np.zeros(n, dtype=np.int)

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

print(' '.join([str(i) for i in ans]))

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

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

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

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

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

result = ' '.join(map(str,res))
print(result)

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

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

print(" ".join(l))

Solution (Python):
N=int(input())
import numpy as np
h=np.array(list(map(int,input().split())))
print(*(np.argsort(h)+1).tolist(), sep=' ')

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

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

Solution (Python):
import sys

input = sys.stdin.readline


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

    ans = [0] * N
    for i, a in enumerate(A, 1):
        ans[a - 1] = i

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


if __name__ == "__main__":
    main()

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

B = [(i+1, k) for i, k in enumerate(A)]


def func(x):
    return x[1]


B.sort(key=func)
res = ""
for b in B:
    res += str(b[0]) + " "

print(res)

Solution (Python):
import math
from math import gcd
INF = float("inf")

import sys
input=sys.stdin.readline
import itertools
from collections import Counter

def main():
    n = int(input())
    a = list(map(int , input().split()))
    ans = [0]*n
    for i, num in enumerate(a):
        ans[num-1] = i+1
    print(" ".join(map(str,ans)))

if __name__=="__main__":
    main()

Solution (Python):
import math
from math import gcd
INF = float("inf")

import sys
input=sys.stdin.readline
import itertools
from collections import Counter

def main():
    n = int(input())
    a = list(map(int , input().split()))
    ans = [0]*n
    cnt = 1
    for i in a:
        ans[i-1] =cnt
        cnt += 1
    print(" ".join(map(str,ans)))

if __name__=="__main__":
    main()

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

print(" ".join(x))

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

print(" ".join(x))

Solution (Python):
import math


def resolve():
    import sys
    input = sys.stdin.readline
    
    n = int(input().rstrip())
    ans = ["" for _ in range(n)]
    a_list = [int(x) for x in input().rstrip().split(" ")]
    for i, a in enumerate(a_list):
        ans[a-1] = str(i+1)

    print(" ".join(ans))



if __name__ == "__main__":
    resolve()

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

s = ""
for i in B:
    s = s + str(i) + " "

print(s.strip())

Solution (Python):
import math
from collections import defaultdict,deque

ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
ips=lambda:input().split()

"""========main code==============="""

n=ii()
a=ll()
lol=[]
for i in range(n):
    lol.append([a[i],i+1])
lol.sort()
for i in lol:
    print(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()))

l = {a: i for i, a in enumerate(A, start=1)}
print(' '.join([str(l[i+1]) for i in range(N)]))

Solution (Python):
n = int(input())
m = [(x, 0) for x in range(1, n+1)]

for i, x in enumerate(map(int, input().split())):
  m[i] = (m[i][0], x)
m.sort(key=lambda x : x[1])
print(' '.join([str(x[0]) for x in m]))

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

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

ans.sort()
for i in range(N-1):
    print(ans[i][1],end=' ')
print(ans[-1][1])

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

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

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

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

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

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
a_dict = {}
for i, value in enumerate(a):
    a_dict[i+1] = value
print(*[key for key, value in sorted(a_dict.items(), key=lambda k:k[1])])

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

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

print(*B)

Solution (Python):
import sys


inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inintm())
instr = lambda: sys.stdin.readline()
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())

n = inint()
A = inintl()

st = [""]*n

cnt = 0

for a in A:
    cnt += 1
    st[a-1] = str(cnt)

print(" ".join(st))

Solution (Python):
from sys import stdin,stdout
def INPUT():return list(int(i) for i in stdin.readline().split())
import math
def inp():return stdin.readline()
def out(x):return stdout.write(x)
import math as M
MOD=10**9+7
import random

n=int(input())
A=INPUT()
D=[0]*(n+1)
for i in range(n):
    D[A[i]]=(i+1)
print(*D[1:])

Solution (Python):
import sys
import collections
import bisect


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


if __name__ == '__main__':
    main()

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

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

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

A = dict(zip(A, B))
A = sorted(A.items())
ans = [str(x[1]) for x in A]


print(" ".join(ans))

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

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

Solution (Python):

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

ans = []
for i, _ in sorted(enumerate(X), key=lambda x: x[1]):
    ans.append(i + 1)

print(*ans)

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

a = [0] * N

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

res = " ".join(a)

print(res)

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

dic = {i:0 for i in range(1, N + 1)}


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

for i in range(1, N + 1):
    print(dic[i], end="")
    if i != N:
        print(" ", end="")

print()

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

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

ans.sort()

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

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

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
d = {}
ans = ''

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

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

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

print(ans)

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
from numba import njit
import sys
sys.setrecursionlimit(10**7)

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

N = I()
A = LI()

B = range(1,N+1)
AB = zip(A,B)

sAB = sorted(AB)

_,ans=zip(*sAB)
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())
A = [int(i) for i in input().split()]
A_tupple = [(idx+1, value) for idx, value in enumerate(A)]
A_tupple.sort(key=lambda x:x[1])
for a in A_tupple:
  print(a[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] = i+1
print(*ans)

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

import numpy as np
x = np.argsort(a)

for i in range(n):
  print(x[i]+1)

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

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

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

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
N = sorted(range(1, n + 1), key=lambda x: A[x - 1])
print(*N)

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

N = list(range(1, n + 1))
c = sorted(zip(A, N))
A, N = zip(*c)

print(*N)

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
A = [int(x) for x in stdin.readline().rstrip().split()]

ans = [0] * n

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

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

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

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

print(*order[1:])

Solution (Python):
n = int(input())
an = [int(num) for num in input().split()]

answer = [0 for _ in range(n)]
for index in range(n):
  answer[an[index] - 1] = str(index + 1)

print(" ".join(answer))

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

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

print(*arr)

Solution (Python):























































global FLAG_LOG
FLAG_LOG = False


def log(value):
    
    
    if FLAG_LOG:
        print(str(value))


def calculation(lines):
    
    N = int(lines[0])
    
    values = list(map(int, lines[1].split()))
    
    
    
    
    
    
    

    lst = [0] * N

    for n in range(N):
        lst[values[n]-1] = str(n+1)

    return [' '.join(lst)]



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['3', '2 3 1']
        lines_export = ['3 1 2']
    if pattern == 2:
        lines_input = ['5', '1 2 3 4 5']
        lines_export = ['1 2 3 4 5']
    if pattern == 3:
        lines_input = ['8', '8 2 7 3 4 5 6 1']
        lines_export = ['8 2 4 5 6 7 3 1']
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    global FLAG_LOG
    if len(args) == 1:
        mode = 0
        FLAG_LOG = False
    else:
        mode = int(args[1])
        FLAG_LOG = True
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(2)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



if __name__ == '__main__':
    main()

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

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

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

Order = []

for i in range(N+1):
    Order.append(0)

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

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

ans = ""

for i in range(1, N+1):
    ans += str(Order[i])
    if i != N + 1:
        ans += " "

print(ans)

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

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

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

def main(n,a):
    aa=[]
    for i in range(n):
        aa.append((i+1,a[i]))
    aa.sort(key=lambda x:x[1])
    b=[]
    for i in range(n):
        b.append(aa[i][0])
    return b

if __name__=='__main__':
    n,a=readinput()
    ans=main(n,a)
    print(' '.join(map(str,ans)))

Solution (Python):
import sys, math, itertools, collections, bisect 
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8') 
inf = float('inf') ;mod = 10**9+7 
mans = inf ;ans = 0 ;count = 0 ;pro = 1

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

Solution (Python):
import sys, math, itertools, collections, bisect 
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8') 
inf = float('inf') ;mod = 10**9+7 
mans = inf ;ans = 0 ;count = 0 ;pro = 1

n=int(input())
A=[(e,i) for i,e in enumerate(list(map(int,input().split())))]

A.sort(key=lambda tup: tup[0])

for e,i in A:
    print(i+1)

Solution (Python):
n = int(input())
a = sorted([(i, int(ai)) for i, ai in zip(range(1, n + 1), input().split())], key=lambda x: x[1])
for i in range(n):
    print(a[i][0], 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, sep=' ')

Solution (Python):
import numpy as np
N = int(input())
A = [int(a) for a in input().split()]
ans = np.argsort(A) + 1

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

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

if __name__ == "__main__":
    main()

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

if __name__ == "__main__":
    main()

Solution (Python):
t = 1


def max(a,b):
	if a > b:
		return a
	return b
while t > 0:
	t -= 1
	n = int(input())
	
	v = list(map(int,input().strip().split()))[0:n]
	
	l = []
	for i in range(n):
		l.append(0)
	
	j = 1
	for i in v:
		l[i-1] = j
		j += 1
	
	for i in l:
		print(i,end=" ")

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
B=[1]*N
for x in range(N):
  B[A[x]-1]+=x
for y in B:
  print(y,end="")
  if y!=B[N-1]:
    print(" ",end="")
print("\n")

Solution (Python):
N = int(input())
ls = list(map(int,input().split()))
ls2 = []
for i in range(N):
    ls2.append([i,ls[i]])

ls3 = sorted(ls2, key=lambda x: x[1])
ls4 = []
for i in ls3:
    ls4.append(i[0]+1)

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

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
ans=''
for i in range(n):
  ans+=str(b[i])+' '
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
ans=''
for i in range(n):
  ans+=str(b[i])+' '
print(ans)

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

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

for k, v in sorted(D.items()):
    print(v, end=" ")

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(x, end=' ') for x in B]