Problem:
 Score : 300 points    Problem Statement  Takahashi is a teacher responsible for a class of N students.  The students are given distinct student numbers from 1 to N .  Today, all the students entered the classroom at different times.  According to Takahashi's record, there were A_i students in the classroom when student number i entered the classroom (including student number i ).  From these records, reconstruct the order in which the students entered the classroom.      Constraints   1 \le N \le 10^5  1 \le A_i \le N  A_i \neq A_j  (i \neq j)  All values in input are integers.         Input  Input is given from Standard Input in the following format:  N  A_1  A_2  \ldots  A_N       Output  Print the student numbers of the students in the order the students entered the classroom.        Sample Input 1 3
2 3 1      Sample Output 1 3 1 2  First, student number 3 entered the classroom.  Then, student number 1 entered the classroom.  Finally, student number 2 entered the classroom.       Sample Input 2 5
1 2 3 4 5      Sample Output 2 1 2 3 4 5       Sample Input 3 8
8 2 7 3 4 5 6 1      Sample Output 3 8 2 4 5 6 7 3 1

Solution (Python):
N = int(input())
A_ls = list(map(int, input().split(' ')))
rst = [ [] for i in range(N) ]
for idx, val in enumerate(A_ls):
    rst[val - 1] = idx + 1
[ print(i, end=" ") for i in rst ]

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

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
dct = dict(enumerate(A))
ad = sorted(dct.items(), key=lambda x:x[1])
ans = []
for i in ad:
    j = i[0] + 1
    ans.append(j)
a = map(str, ans)
b = ' '.join(a)
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
print(*b)

Solution (Python):
N = int(input())
A_ls = list(map(int, input().split(' ')))
rst = [ [] for i in range(N) ]
for idx, val in enumerate(A_ls):
    rst[val - 1] = idx + 1
[ print(i, end=" ") for i in rst ]

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

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

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

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

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

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

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

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

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())
rst = [ [] for i in range(N) ]
A_ls = list(map(int, input().split(' ')))
for i, j in enumerate(A_ls):
    rst[j - 1] = i + 1
[ print(i, end=" ") for i in rst ]

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


print(' '.join(list(map(str, sorted(range(1,N+1), key=lambda v:A[v-1])))))

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

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

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

Solution (Python):

def main():
    N = int(input())
    R = [-1] * (N+1)
    A = list(map(int,input().split()))
    for idx, a in enumerate(A):
        R[a] = idx+1

    for idx in range(1, len(R)):
        print(R[idx], end=" ")
    print("\n")
    

if __name__ == "__main__":
    main()

Solution (Python):
def resolve():
    n = int(input())
    a = tuple(map(int,input().split()))
    attend = [0]*n
    for i,j in enumerate(a):
        attend[j-1] = i+1
    print(*attend)
resolve()

Solution (Python):
N=int(input())
Alist=list(map(int,input().split()))
index=[i+1 for i in range(N)]
Adict=dict(zip(Alist,index))
for i in range(1,N+1):
    print(Adict[i],end=' ')

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

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

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

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

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

a_tmp=list(map(int,input().split()))
a=[]
for i in range(n):
    a.append([a_tmp[i],i+1])
a.sort(key=lambda x:x[0])

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

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

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

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

P = [0]*n

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

print(*P,sep=' ')

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

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

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

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    m = {}
    for i in range(N):
        m[A[i]] = i + 1

    ans = []
    ms = sorted(m.items(), key=lambda x :x[0])
    for i in range(N):
        ans.append(ms[i][1])

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



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

if __name__ == '__main__':
    main()

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

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

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

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

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

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

ans_h = {}
ans = []

for (i, ele) in enumerate(a):
    ans_h[ele] = i + 1

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

print(" ".join(ans))

Solution (Python):

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

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

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[a[i]-1] = str(ans[a[i]-1])
print(" ".join(ans))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
arriv = {}
l = []

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

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

for i in range(n):
    l.append(str(arriv_2[i][0]))

print(' '.join(l))

Solution (Python):
def abc142c_go_to_school():
    n = int(input())
    a = list(zip(range(1, n+1),list(map(int, input().split()))))
    a.sort(key=lambda x: x[1])
    for item in a:
        print(item[0], end=' ')

abc142c_go_to_school()

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

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
b = [None] *n
for idx,person in enumerate(a):
    b[person-1] = idx+1
for j in b:
    print(j,end=' ')

Solution (Python):


def main():
    N = int(input())
    A = list(map(int, input().split()))
    B = [[a, i + 1] for i, a in enumerate(A)]
    B.sort()
    for i, j in B:
        if i == N:
            print(j)
        else:
            print(j, "", end='')


if __name__ == "__main__":
    main()

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

for i in range(n):
    if (i != n - 1):
        print(lst2[i], end = ' ')
    else:
        print(lst2[i])

Solution (Python):
import numpy as np

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

ans = np.argsort(a)
print(*ans + 1)

Solution (Python):

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

L = {}

for i in range(N):
    L[i] = a[i]

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

for j in sort_L:
    print(j[0]+1, end =" ")

Solution (Python):
N = int(input())
alist = list(map(int, input().split()))
blist = []
for i in range(N):
    blist.append([alist[i],i+1])
blist.sort()
for i in range(N):
    print(blist[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)
    ans[a[i]-1]=str(ans[a[i]-1])
print(" ".join(ans))

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

order = [0] * n

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

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

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

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

Solution (Python):


from typing import *
import collections
import functools
import itertools
import math
import sys

INF = float('inf')


def solve(N: int, A: "List[int]"):
    return " ".join(str(v+1) for v, _ in sorted(enumerate(A), key=lambda a: a[1]))


def main():

    sys.setrecursionlimit(10 ** 6)

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


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
an = list(map(int,input().split()))
zyunban = [0]*n
t = 1

for x in an:
  zyunban[x-1] = t
  t += 1
  


zyunban = list(map(str,zyunban))

print(" ".join(zyunban))

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):
N = int(input())
arr = list(map(int, input().split()))
arr2 = [0]*N
for i in range(N):
    arr2[arr[i]-1] = i+1
print(*arr2)

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

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


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

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

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

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


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

dic = sorted(dic.items(), key=lambda x:x[1])
for d in dic:
  print(d[0]+1, end=" ")

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

ans = ''
for i in range(N):
  ans += (l[i] + ' ')
  
print(ans)

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

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

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

Solution (Python):

N = int(input())

order_number = {}


for num, order in enumerate(map(int, input().split())):
    order_number[num+1] = order

for order, number in sorted(order_number.items(), key=lambda x: x[1]):
    print(order, end=" ")
print()

Solution (Python):

"""
Created on Wed Sep  9 02:37:37 2020

@author: liang
"""
"""
key = lambda x:x[1]
"""
N = int(input())
A = [int(i) for i in input().split()]
B = [(i+1,A[i]) for i in range(N)]
B.sort(key=lambda x: x[1])

res = [str(b[0]) for b in B]

print(' '.join(res))

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

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

print(*b)

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

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

l = sorted([(a[i], i+1) for i in range(n)])
c = [y for x, y in l]
print(' '.join(list(map(str, c))))

Solution (Python):

import sys
input=sys.stdin.readline

def main():
    attended_people=[]
    sorted_attended_people=[]
    index_number=[]
    answer=[]
    n = int(input())
    attended_people=list(map(int,input().split()))
    index_number=[[idx,number] for idx,number in enumerate(attended_people)]
    sorted_attended_people=sorted(index_number,key=lambda x:x[1])
    for idx,data in sorted_attended_people:
        answer.append(str(idx+1))
    print(" ".join(answer))

if __name__=="__main__":
    main()

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

Solution (Python):

n = int(input())
a = [int(x.strip()) for x in input().split()]
b = []
ans = str('')
for i in enumerate(a):
  b.append(i)
b.sort(key=lambda x:x[1])
for i in b:
  print(i[0]+1)

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

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

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

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

for i in enumerate(arr):
    brr.append(i)


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

for i in brr:
    print(i[0]+1)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
for i in range(N):
  A[i] = (A[i],i+1)
A.sort()
ans = ''
for tup in A:
  v, i = tup
  ans+=str(i)+' '
print(ans)

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

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

Solution (Python):

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

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

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

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

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

Solution (Python):
N = int(input())
S = list(map(int,input().split()))
m = [0 for _ in range(N)]
for i in range(N):
  m[S[i]-1] = i+1
print(*m,sep=" ")

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

for i in range(len(a)):
    ans[a[i]]=i

ans.pop(0)

print(*ans)

Solution (Python):
N = int(input())
list = input().split()
answer = [0] * N

for i in range(N):
  answer[int(list[i]) - 1] = str(i + 1)

print(' '.join(answer))

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 l:
    print(i,end=" ")

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

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

B.sort()

ans = []
for b in B:
    ans.append(b[1])

print(*ans)

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

Solution (Python):
import numpy
N = int(input())
A = [int(x) for x in input().split()]
a = numpy.argsort(A)
a += 1
print(*a)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
B = [[A[i],i+1]for i in range(N)]
B.sort()
ans = [B[i][1]for i in range(N)]
print(" ".join(map(str,ans)))

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
ans = [0 for j 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()))
time = [0 for i in range(N)]

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

for j in range(N):
    print(time[j],end=" ")

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
nu={}
for i in range(len(a)):
  nu[a[i]+1]=i+1
nu=sorted(nu.items())
b=[]
for i in nu:
  b.append(str(i[1]))
mojiretu = ' '.join(b)
print(mojiretu)

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

student_arr = [(A[i], i) for i in range(N)]
student_arr.sort()

res = ''
for i in range(N):
    res += str(student_arr[i][1] + 1)
    if i < N - 1:
        res += ' '

print(res)

Solution (Python):
import numpy as np

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

A_sorted = np.argsort(A)

print(*A_sorted+1)

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

l = [0]*N
for i,a in enumerate(A):
  l[a-1]=i+1
  
for x in l:
  print(x, end=' ')

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

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


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    n = int(input())
    a_list = list(map(int, input().split()))
    lst = [[i, x] for i, x in enumerate(a_list)]
    lst.sort(key = lambda x: x[1])

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

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] = str(i + 1)

Ans = ' '.join(ans)
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):
import sys
input = sys.stdin.readline

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

def main():
    mod=10**9+7
    N=I()
    A=LI()
    L=[]
    for i in range(N):
        L.append([A[i],i])
        
    L.sort()
    ans=[]
    for i in range(N):
        ans.append(L[i][1]+1)
        
    print(' '.join(map(str, ans)))

main()

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

sorted_students = [str(x[0] + 1) for x in sorted([x for x in enumerate(students)], key=lambda x: x[1])]

print(' '.join(sorted_students))

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

Solution (Python):
a=int(input())
b=list(map(int,input().split()))
c=[0]*a
"""
for i in range(a):
    c.append(b.index(i+1)+1) 
"""
for i in range(a):
    c[b[i]-1]=i+1
result = ' '.join(map(str,c))
print(result)

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

Solution (Python):
import numpy as np
N = int(input())
A = list(map(int, input().split()))
ans = np.zeros(N)
for i in range(N):
  ans[A[i]-1] = i + 1
  
ans = list(map(int, ans))
ans = list(map(str, ans))
print(" ".join(ans))

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

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

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

rank_line = [0 for i in range(num)]

for i in range(num):
    rank_line[num_line[i] - 1] = i+1

for i in range(num):
    print(rank_line[i],end="")
    if(i != num-1):
        print(" ",end="")

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

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

    order = [0 for i in range(n)]

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




    print(*order)


if __name__ == '__main__':
    main()

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

for i, v in enumerate(a):
    x[v - 1] = i + 1

print(*x)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
D = {}
for i in range(N):
	i+=1
	D.update([(A[i-1], i)])

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

str_ans = list(map(str, ans))
print(' '.join(str_ans))

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

Solution (Python):


n = int(input())
a = list(map(int, input().strip().split()))
appear_attendance_number = {}
for i in range(n):
    appear_attendance_number[a[i]-1] = i+1
res = []
for i in range(n):
    res.append(appear_attendance_number[i])
print(' '.join(map(str, res)))

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

Adict = {}

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

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

print(" ".join(ans))

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

Solution (Python):
n=int(input())
a=[x for x in input().split()]
ans=[0]*n
for i in range(n):
    ans[int(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.append(0)
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())
toko = [int(i) for i in input().split()]

ans = [int(0) for i in range(n)]

for j in range(n): 
  ans[toko[j]-1] = j + 1
  
print(' '.join(map(str, ans)))

Solution (Python):
import sys
from collections import deque
import numpy as np
import math
sys.setrecursionlimit(10**6)
def S(): return sys.stdin.readline().rstrip()
def SL(): return map(str,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def IL(): return map(int,sys.stdin.readline().rstrip().split())

def solve():
    la = [(item,i+1) for i,item in enumerate(a)]
    la.sort()
    for rep in la:
        print(f"{rep[1]} ",end="")
    return

if __name__=='__main__':
    n = I()
    a = list(IL())
    solve()

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

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

a = list(map(int, input().split()))
b = list(enumerate(a))
c = sorted(b, key=lambda x:x[1])


print(*[c[i][0]+1 for i in range(n)])

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

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

for i in range(n):
    lists[a[i] - 1] = i + 1
    
for i in lists:
  print(i , end =' ')

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

ans = map(str, ans)
print(' '.join(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
for b in B:
  print(b+1)

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

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)
A.sort()

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

Solution (Python):
import sys

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

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

ans = []
for (a, n) in sorted(B):
    ans.append(n)

print(*ans)

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

Solution (Python):
N, *A = map(int, open(0).read().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()))
ls = [(A[i], i) for i in range(N)]
ls.sort()
ans = [ls[i][1]+1 for i in range(N)]
print(*ans)

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

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

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


ans=[]
for j in b:
    ans.append(j[0])

print(*ans)

Solution (Python):
N = int(input())
A = {int(x): key for key, x in enumerate(input().split(), 1)}
sort_a = sorted(A.items(), key=lambda x: x[0])

print(' '.join([str(key) for x, key in sort_a]))

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

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

N = int(input())
As = list(mapint())

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

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

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

print(*ans)

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

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

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(" ".join([str(x) for x in ans]))

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

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

memo = [0]*N

for i in range(len(A)):
    memo[A[i]-1] = i+1
print(*memo)

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

arr = [(x, i + 1) for i, x in enumerate(a)]
arr.sort()

ans = [x[1] for x in arr]

print(*ans)

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

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right 
import sys,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

n = inp()
a = inpl()
res = [0] * n
for i,x in enumerate(a):
    res[x-1] = i+1
print(*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(*ans)