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

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

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

for i in range(n):
    h.append([h_kari[i],i+1])
    
h.sort()    
    
ans = [h[i][1] for i in range(n)]    

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

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


def main():
    N = int(input())
    A = list(map(int, input().split()))
    B = ['']*N

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


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
n = int(input())
a = [(i+1, v) for i, v in enumerate(map(int, input().split()))]
print(' '.join([str(i) for i, _ in sorted(a, key=lambda x: x[1])]))

Solution (Python):
def MAP(): return list(map(int,input().split()))
def INT(): return int(input())
def FLOAT(): return float(input())
MOD = 10**9+7

n = INT()
a = MAP()
res=[0]*n

for i in range(n):
    res[a[i]-1]=i+1
print(*res)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
T = [0 for i in range(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()))
b = []
for i in range(n):
    b.append((a[i], i + 1))
b = sorted(b)
for i in b:
    print(str(i[1]))

Solution (Python):
N=int(input())
 
li=list(map(int,input().split()))
 
ans=sorted(range(N), key=lambda a: li[a])
 
for n in range(N):
  ans[n]+=1
      
print(*ans)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
b = [0 for l in range(n)]

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

for m in range(n):
    print(b[m],end="")
    print(" ",end="")

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

Solution (Python):
N=int(input())
 
li=list(map(int,input().split()))
 
ans=sorted(range(N), key=lambda k: li[k])
 
for n in range(N):
  ans[n]+=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
for i in range(n):
    print( ans[i]," " )

Solution (Python):
N=int(input())
 
li=list(map(int,input().split()))
 
ans=sorted(range(N), key=lambda k: li[k])
 
for n in range(N):
  ans[n]+=1
      
print(*ans)

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

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

Solution (Python):
n = int(input())
a = [(i, idx) for idx, i in enumerate(map(int, input().split()))]
a.sort()
last = a.pop()
for i, idx in a:
    print(idx+1, end=" ")
print(last[1]+1)

Solution (Python):
import copy

N=int(input())

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

ans=copy.copy(li)

ans=sorted(range(N), key=lambda k: li[k])

for n in range(N):
  ans[n]+=1
      
print(*ans)

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

B = [int(0) for n in range(N)]

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







B = [str(n) for n in B]

result = ' '.join(B)

print(result)

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

Solution (Python):
import numpy as np
N = int(input())
li = list(map(int, input().split()))
arr = np.array(li)
ans = arr.argsort() + 1
st = map(str,ans)
x = " ".join(st)
print(x)

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

ans = [0] * N

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

Solution (Python):
from sys import stdin

input = stdin.readline
mi = lambda: map(int, input().split())
lmi = lambda: list(mi())
si = lambda: input().strip('\n')
ii = lambda: int(input())


n = int(input())
arr = [0 for i in range(n+1)]
nums = lmi()
for i in range(n):
    arr[nums[i]] = i+1
print(*arr[1:])

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


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

  
print(" ".join(List))

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

Solution (Python):
N=int(input())
L=[[b,a+1] for a,b in enumerate(map(int,input().split()))]
X=[b for a,b in sorted(L)]
print(" ".join(map(str,X)))

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

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

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

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

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

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

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    l = [None] * N
    for i in range(0, N):
        l[A[i] - 1] = str(i + 1)
    print(" ".join(l))
    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):
import sys


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


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


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    students = int(input())
    arrival_info = {k: v for k, v in zip([int(i) for i in input().split()], [i + 1 for i in range(students)])}

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

if __name__ == '__main__':
    main()

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

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

for a in A:
    B[a-1]=count
    count+=1

for b in B:
    print(b,end=' ')

print()

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

for i, a in enumerate(A):
    ans[int(a-1)] = str(i+1)
print(' '.join(map(str, ans)))

Solution (Python):
n = int(input())
a = [int(x) for x in input().split()]
print(*[i for a, i in sorted(zip(a, range(1, n+1)))])

Solution (Python):
import numpy as np

def plus(n):
  n = int(n)
  return n + 1


n = int(input())
a = [int(x) for x in input().split()]
answer = []

A = np.array(a)
A = A.argsort()

answer = list(map(plus, A))

print(*answer)

Solution (Python):
n,a=open(0);a=a.split();print(*sorted(range(1,int(n)+1),key=lambda x:int(a[x-1])))

Solution (Python):
n = int(input())
ans = [0]*n

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

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

st = ''
for a in ans:
    st += str(a)+' '

print(st)

Solution (Python):
n=int(input())
A=tuple(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()))
t = []
for i in range(1,n+1):
    t.append((a[i-1],i))
t = sorted(t)
arr = []
for k in range(n):
    arr.append(t[k][1])
print(*arr)

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

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


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

  
print(" ".join(List))

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

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


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

  
print(" ".join(List))

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

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    n = int(input())
    a = [int(x) for x in input().strip().split()]
    b = []
    for i in range(1, n+1):
        b.append(i)

    a, b = zip(*sorted(zip(a, b)))
    print(*b)


if __name__ == "__main__":
    main()

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

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

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

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

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

b
c=[i+1 for i in range(N)]

ans=[]

for i in range(len(b)):
    ans.append([b[i],c[i]])
    
ans1=sorted(ans)
ans2=[i[1] for i in ans1]

print(*ans2)

Solution (Python):
n, *a = map(int, open(0).read().split())
ans = {}
for i, num in enumerate(a):
    ans[str(num)] = i+1
ans = sorted(ans.items(), key=lambda x: int(x[0]))
for key, val in ans:
    print(val)

Solution (Python):
n = int(input())
a_list = list(map(int, input().split()))
b_list = []
for i in range(n):
	b_list.append(0)

for i in range(n):
	b_list[a_list[i]-1] = i+1
	
b_list =[str(z) for z in b_list]
b_list=' '.join(b_list)
print(b_list)

Solution (Python):
if __name__ == '__main__':
    N = int(input())
    order_list = list(map(int, input().split()))
    present_list = list(range(1, N+1))
    temp = zip(order_list, present_list)
    temp = sorted(temp)
    order_list, present_list = zip(*temp)
    print(' '.join(map(str,present_list)))

Solution (Python):
j = 1
a = 0
i = 0
N = 0



A = [int(input()) for _ in range(1)]

mylist = [0]*A[0]

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

for i in range(A[0]):
    mylist[h[i]-1]=i+1
print(*mylist)

Solution (Python):

n = int(input())
a = list(map(int, input().split()))
order = {}
for i in range(n):
    order[a[i]] = i+1
sorted_order = sorted(order.items(), key=lambda x: x[0])
for o in sorted_order:
    print(o[1], end=' ')

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

a = 0
ans = [str(i) for i in a_list]

for i in a_list:
    a += 1
    ax = str(a)
    ans[i-1] = ax

answer = ''
for i in ans:
    answer += i
    answer += ' '

print(answer)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
n = [i for i in range(1,N+1)]
ans =[]
jyuni = dict(zip(A,n))

for cnt in jyuni.values():
  ans.append(cnt)

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

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

d =[]

for e in range(n+1):
    d.append(e+1)

f = dict(zip(a,d))

g = sorted(f.items())

r = []
for i in g:
    r.append(str(i[1]))

s = " ".join(r)

print(s)

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
li1, li2 = sorted(a), sorted(range(len(a)), key=lambda k: a[k])
li22 = list(map(lambda x: x+1, li2))
print(*li22)

Solution (Python):

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

for i in range(len(A)):
	A[i] = [A[i], i]
A.sort()
for j in range(len(A)):
	A[j] = str(A[j][1]+1 )
print(' '.join(A))

Solution (Python):
n = int(input())
a_list = input().split()
ret = [0]*n

for i, a in enumerate(a_list):
    ret[int(a)-1] = str(i + 1)

print(" ".join(ret))

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

l = sorted(range(len(a)), key=a.__getitem__)
for i in l:
    print(i + 1, end = " ")

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

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

Solution (Python):
import numpy as np
N = int(input())
A = [int(x) for x in input().split()]
list= np.arange(1,N+1)
for i in range(N):
    list[A[i]-1]=i+1

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

Solution (Python):

n = int(raw_input())
li = map(int, raw_input().split())

listb = []
listb = sorted(range(len(li)), key=lambda k: li[k])

s = str(map(lambda x: x+1, listb))

print s.replace("[","").replace("]","").replace(",","")

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
s = list(range(1, N+1))
c = [0]*N

for x in range(len(A)):
  c[A[x]-1] = str(s[x])
print(' '.join(c))

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

values = [i for i in range(1, N+1)]
dic = dict(zip(keys, values))
keys.sort()
for i in range(1, N+1):
    value = dic[i]
    print('{} '.format(value), end='')

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

a, b = zip(*sorted(zip(a,b)))
print(*b)

Solution (Python):


N = int(input())
num_list = list(map(int, input().split()))
order_list = sorted(range(len(num_list)), key=lambda k: num_list[k])
order_list = list(map(lambda x: x+1, order_list))
[print(' '.join([str(i) for i in order_list]))]

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

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

score_sorted = dict(sorted(score.items(), key=lambda x:x[0]))
result = "" 
for A, i in score_sorted.items():
    result += str(i) + " "
print(result)

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

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

res = [0]*n

rest = ""

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

res = map(str, res)

print(' '.join(res))

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

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

Solution (Python):
import numpy as np

n = int(input().strip())
a_list = np.array([int(e) for e in input().strip().split()])

order = np.argsort(a_list) + 1
print(" ".join(map(str, order)))

Solution (Python):
N = int(input())
listA = list(map(int, input().split()))
listB = []
for j in listA:
  listB.append(0)
c = 1

for i in listA:
  listB[i-1] = c
  c += 1

for k in listB:
  print(k)

Solution (Python):
n = int(input())
al = list(map(int, input().split()))
cl = []
for j in range(n):
    cl.append([al[j], j + 1])
cl.sort()
bl = []
for i in range (n):
    bl.append(cl[i][1])
print(*bl, sep=' ')

Solution (Python):
N = int(input())
A = map(int, input().split())
dict_A = {}
j = 0
for i in A:
    dict_A[j] = i
    j += 1

attend_order = [k + 1 for k, v in sorted(dict_A.items(), key=lambda x: x[1])]
print(*attend_order, sep=" ")

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

brr = [0]*n

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

Solution (Python):
N = int(input())
s = raw_input().split()
h = [0]*N

for i in range(N):
    h[i] = int(s[i])
    h[i] = (h[i], i+1)


h.sort()


for i in range(N-1):
    print h[i][1],

print h[N-1][1]

Solution (Python):
N=int(input())
A=list(map(int,input().split(" ")))
order=[0 for i in range(N+1)]
text=""
for i in range(len(A)):
    order[A[i]]=i+1
for i in range(1,len(A)+1):
  	text+=str(order[i])+" "
print(text)

Solution (Python):
def solve():
    N = int(input())
    A = [(a,i) for i,a in enumerate(map(int, input().split()))]
    A.sort()
    for l in A:
        print(l[1]+1, end=' ')
if __name__ == '__main__':
    solve()

Solution (Python):
import numpy as np
 
N = int(input())
A_i = np.array(list(map(int, input().split())))
stu = [[nums+1,student] for nums, student in enumerate(A_i)]
 
emp = np.full(N, np.nan)
for i, j in stu:
    emp[j-1] = i

print(*emp.astype('int'), sep=" ")

Solution (Python):

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

output = [0] * N
for a,i in zip(A,range(len(A))):
    output[a-1] = i+1

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

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



def solve(args: list) -> str:
    N = int(args[0])
    A = list(map(int, args[1].split()))
    a = [(i+1, A[i]) for i in range(N)]
    ret = map(lambda t: t[0], sorted(a, key=lambda t: t[1]))
    return str(' '.join(map(str, ret)))


if __name__ == "__main__":
    print(solve([input() for _ in range(2)]))

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

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()] 
A.insert(0, 0)
B = [0]*N
mydict={}
for i in range(1,N+1):
    mydict[A[i]]=i
sorted(mydict.items(), key=lambda x: x[1])
for i in range(1,N+1):
    B[i-1]=mydict[i]
print(' '.join(map(str, B)))

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

sorted_result = sorted(J , key=lambda i: +A[i])
print(" ".join(map(str,sorted_result)))

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

pre = {}
for i in range(0, len(A)):
  pre[A[i]]  = i+1

tmp = sorted(pre.items())

ans = []
for tp in tmp:
  ans.append(str(tp[1]))
print(' '.join(ans))

Solution (Python):
tmp = int(input())
timing = [int(i) for i in input().split()]
num_dict = {}
for i  in range(0,tmp):
    num_dict[timing[i]] = i+1

for i in range (0,tmp):
    print(num_dict.pop(i+1),end="")
    if i <tmp-1:
        print(" ",end="")

Solution (Python):
n = int(input())
a=list(map(int,input().split()))
j = 1
ans = [0] * n
while j <= n:
    ans[a[j-1]-1] =  j
    j = j+1
print(' '.join(map(str, ans)))

Solution (Python):
str = input()

n = int(str)
str2 = input().split()


d = {}

i = 0
for s in str2:
    ss = int(s)
    d[ss] = i + 1
    i += 1

d = sorted(d.items())


for v in d:
    print(v[1], end=' ')

Solution (Python):
import numpy as np

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

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

Solution (Python):
d = {}

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

for i, num in enumerate(P, 1):
  d[num] = i

order = ''
for i in range(N):
  order += str(d[i+1]) + ' '

print(order)

Solution (Python):
N = int(input())
As = [int(i) for i in input().split()]
ans = [0]*N
for i, A in enumerate(As):
    ans[A-1] = str(i+1)
joined_ans = ' '.join(ans)
print(joined_ans)

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
a=[]
for i in range(n):
  a.append([i+1,A[i]])
b=sorted(a,key=lambda x:x[1])
lst=[]
for k in range(n):
  lst.append(b[k][0])
print(*lst)

Solution (Python):
import numpy as np

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

num = np.argsort(A)

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

Solution (Python):
N =int(input())
dic = {}
j=1
for i in map(int, input().split()):
    dic[i]=j
    j+=1
for n in range(1, N+1):
    print(dic.get(n))

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

order = [(x, i) for i, x in enumerate(A)]
order.sort()
enter_order = [str(x[1] + 1) for x in order]
print((' ').join(enter_order))

Solution (Python):
def convert_1d_to_2d(a):
    return [a[i:i+1] for i in range(0,len(a),1)]
n=int(input())
a=convert_1d_to_2d(list(map(int,input().split())))
for i in range(n):
    a[i].append(i+1)
a=sorted(a,key=lambda x:x[0])
for i in range(n):
    print(a[i][1],end=' ')

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

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

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

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

n_list = list(range(1,n+1))

h_dict = dict(zip(h,n_list))


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

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

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

Solution (Python):

import bisect
n = int(input())
a = list(map(int, input().split()))
num = list(range(1, n+1))
dic = {key: val for key, val in zip(num, a)}


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

ans = [i[0] for i in result] 
print(*ans)

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

Solution (Python):
N = int(input())
p = [i for i in range(1,N+1)]
q = list(map(int,input().split()))
list = []
re_list = []

for p,q in zip(p,q):
  x = [p,q]
  list.append(x)

new_list = sorted(list,key=lambda x:x[1])
for j in range(len(new_list)):
  re_list.append(str(new_list[j][0]))
print(" ".join(re_list))

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

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

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

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

print(*ans)

Solution (Python):
from collections import deque
N = int(input())
A = [int(i) for i in input().split()]
values = [str(i+1) for i in range(N)]
dic = {key: val for key, val in zip(A, values)}
dic_s = deque(sorted(dic.items()))
s =deque()
for i in range(N):
    s.append(dic_s[i][1])

ans = ' '.join(list(s))
print(ans)

Solution (Python):
import numpy as np
N = input()
cum_numbers = input()

array_cum_numbers = np.array(list(map(int, cum_numbers.split(" "))))

studentId_order = array_cum_numbers.argsort() + 1

print(" ".join(map(str, list(studentId_order))))

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

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

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

print(*ans)

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

s=sorted(range(len(a)), key=lambda k: a[k])

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

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

new_A = list(enumerate(A, 1))
sorted_A = sorted(new_A, key=lambda new_A:new_A[1])

for num in sorted_A:
    print(num[0], end=" ")

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

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

for i in range(N):
	turn_list.append([student_list[i], i+1]) 

turn_list.sort()
for i in range(N-1):
	print('{} '.format(turn_list[i][1]), end='')
print(turn_list[N-1][1])

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

Solution (Python):
def sub_c():
    n = int(input())
    a_list = list(map(int, input().split()))

    a_tuple_list = []
    for i, a in enumerate(a_list):
        temp = (a, i)
        a_tuple_list.append(temp)
    a_tuple_list.sort()

    ret = ''
    for t in a_tuple_list:
        ret += str(t[1]+1) + ' '
    print(ret)


if __name__ == '__main__':
    sub_c()

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

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

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

Solution (Python):
n = int(input())
l = [int(x) for x in input().split(" ")]
numdict = {}
count = 1
for i in l:
  numdict[count] = i
  count += 1
sortedlist = sorted(numdict.items(), key=lambda x:x[1])
for i in sortedlist:
    print(i[0], end=' ')

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

Solution (Python):

N = int(input())
A = input().split()

ans = [0] * N

for i, a in enumerate(A):
  ans[int(a) - 1] = i + 1
  
print(' '.join(map(str, ans)))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
adic = dict()
for i in range(N):
    adic[A[i]] = i+1
s = str()
for i in range(1, N+1):
    s += str(adic[i]) + " "
print(s[:-1])

Solution (Python):
b =int(input())
a = [int(a) for a in input().split()]
aa=[]
for ii in range (b):
  aa.append(0)
for i in range (b):
  az=a[i]
  ax=i+1
  aa[az-1]=ax
print(( " ".join( repr(e) for e in aa ) ))

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

Solution (Python):
import sys


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

if __name__ == '__main__':
    main()

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

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


l=list(sorted(l))

ll=[]

for i in range(N):
    ll.append(l[i][1])

print(*ll)

Solution (Python):
n = int(raw_input())
data = raw_input().split()
tab = range(n)

for i in range (0, n):
    tab[int(data[i]) - 1] = i + 1
s = ''
for i in tab:
    s += str(i) + ' '

print (s)

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

Solution (Python):
import numpy as np
N=int(input())
A=list(map(int,input().split()))
s=list(np.argsort(A))
print(' '.join(repr(e+1) for e in s))

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

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

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())
ar = list(map(int, input().split()))
dic = {}
for i in range(len(ar)):
    dic[i] = ar[i]

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

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

l = []
d = {}

for addnum, record in enumerate(A):
    d[(addnum + 1)] = record

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


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

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

Rank = [0]*n

kyousitu =0
count =0

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

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

aa = [1]*n

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

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

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

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

Solution (Python):
import numpy as np
def calc_1(x):
    return x+1

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

x = np.argsort(a)
hoge = list(map(calc_1,x))

ans = [str(a) for a in hoge]
ans = " ".join(ans)
print(ans)

Solution (Python):
n = input()
a = list(map(int,input().split()))
b = []
for i, j in enumerate(a):
    b.append([i + 1,j])
b.sort(key=lambda x:x[1])
for i, p in enumerate(b):
    if i + 1 == n:
        print(p[0])
    else:
        print(p[0], end= " ")

Solution (Python):
from sys import stdin
from itertools import accumulate, dropwhile, takewhile, groupby




'''
条件に合うものを絞り込む
data = [1, 2, 3]
s = [x for x in data if x % 3 == 0]
'''

'''
文字配列を数値に
l_si = ['-10', '0', '100']

l_si_i = [int(s) for s in l_si]
'''

'''
a = [2, 4, 6, 8]
b = [3, 6, 9]

print(list(set(a) | set(b)))  
print(list(set(a) & set(b)))  
'''

'''
N = int(stdin.readline().rstrip())
A = [int(x) for x in stdin.readline().rstrip().split()]
count = 0
while len([x for x in A if x % 2 == 0]) == N:
    A = list(map(lambda y: y / 2, A))
    count += 1
print(count)
'''

'''
.append(要素)
.insert(場所,要素)
-1で末尾で末尾から一つ前
'''


num = int(stdin.readline().rstrip())
data = stdin.readline().rstrip().split()
lis = [''] * num
res = ''
count = 1
for el in data:
    lis[int(el)-1] = str(count)
    count += 1
print(' '.join(lis))

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

shusseki_jun=[' ' for _ in range(N)]
for i in range(N):
    ind = A[i]
    shusseki_jun[int(ind)-1] = str(i+1)

print(' '.join(shusseki_jun))

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

li = list(zip(A, range(1, N+1)))
li = sorted(li)
li = list(zip(*li))[1]

print(*li)

Solution (Python):

_N = int(input())
order_list = input().split(" ")


ordered_id_list = [None for i in range(0, _N)]

for i,v in enumerate(order_list):
    _order = i + 1
    _id = int(v)
    ordered_id_list[(_id - 1)] = str(_order)


print(" ".join(ordered_id_list))

Solution (Python):
import heapq

N = int(input())
A = [int(i) for i in input().split()]
num = [i for i in range(1, N+1)]
dic = {key: val for key, val in zip(A, num)}

C = []
heapq.heapify(A)
for i in range(N):
    a = heapq.heappop(A)
    c = dic[a]
    C.append(c)
print(*C)