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

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

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

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

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

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

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

p.sort(key=lambda x: x[1])
q = list(map(str,[x[0] for x in p]))
r = ' '.join(q)


print (r)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
a=[[a[x],x+1] for x in range(len(a))]
a.sort()
for x in a:
    print(x[1],end=' ')

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

print(' '.join(b))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
arrive_pair = []
for idx in range(len(A)):
	arrive_pair.append([A[idx], idx])
arrive_pair.sort()
arrival = list(map(lambda x: str(x[1] + 1), arrive_pair))
print(' '.join(arrival))

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

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

N = int(input())
A = list(map(int, input().split()))
r = [0] * N

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

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

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

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

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

Ans = ""
for a in R_sorted:
    Ans = Ans + "{0} ".format(str(a[0]))

print(Ans)

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

aa = [0]*N

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

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

aa = sorted(range(N), key=lambda k:A[k])

for x in aa:
    print(x+1,end=" ")

Solution (Python):
n = int(input())
a_array = [int(x) for x in input().split()]
counter = dict()
for index, a in enumerate(a_array, 1):
    counter[a] = index

a = sorted(counter.items(), key=lambda x: x[0])
for i, j in a:
    print(j, end=" ")
print("")

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

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
ans = [0] * n
for num, a in enumerate(A):
    ban = a + 1
    ans[ban - 2] = num + 1
ans = list(map(str, ans))
print(' '.join(ans))

Solution (Python):
N = int(input())
note = [int(j) for j in input().split()]

a = dict()
for index, num in enumerate(note):
    a[num] = index+1


b = sorted(a.items(), key=lambda x: x[0])
for i in b:
    print(i[1], end=" ")
print()

Solution (Python):

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

ret = [0] * a
for i,v in enumerate(b):
    ret[v-1] = i+1
print(" ".join(map(str,ret)))

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

O=[0]*N

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

print(*O)

Solution (Python):
import numpy as np

n = int(input())
stu = list(map(int, input().split()))
stu = np.argsort(stu)

[print(i + 1, end=" ") for i in stu]
print()

Solution (Python):
n = int(input())
a_list = map(int,input().split())
a_dict = {}
for i,a in enumerate(a_list):
  a_dict[a] = i+1
sorted_a = sorted(a_dict.items(),key=lambda x:x[0])
for j in sorted_a:
  print(j[1], end=" ")

Solution (Python):
N = int(input())
INF = 10**6

ans = [INF] * N
num = 1
for i in input().split():
    x = int(i) - 1

    ans[x] = num
    num += 1

print(*ans)

Solution (Python):

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

print(*attend_list)

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

students = [[i+1, A[i]] for i in range(N)]
students = sorted(students, key = lambda s : s[1])
print(' '.join(list(map(str,[s[0] for s in students]))))

Solution (Python):


n=int(input())










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




dic={}
for i in range(n):
    dic[a[i]]=i+1
dic=sorted(dic.items(),key=lambda x:x[0])
ans=[]
for i in range(n):
    ans.append(dic[i][1])
print(*ans)

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

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    l = [0] * N
    for i, v in enumerate(A):
        l[v - 1] = i + 1
    print(' '.join([str(i) for i in 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):
N = int(input())
Students = list(map(int, input().split()))

list=[]
for i, student in enumerate(Students, 1):
    list.append([i, student])

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

list2=[]
for t in range(N):
        list2.append(K[t][0])

print(*list2)

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

N = int(input())
As = [int(i) for i in input().split()]
order = [0]*N

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

Solution (Python):
import heapq

n = int(input())
priority_list = []

student = 0
for priority in list(map(int, input().split())):
    student += 1
    priority_list.append((priority, str(student)))

heapq.heapify(priority_list)

print(' '.join([ heapq.heappop(priority_list)[1] for _ in range(n) ]))

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

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

for i in range(n):
    print(ans_list[i], end=' ')
print('\n')

Solution (Python):
N = int(input())
Ai_list = [number for number in map(int, input().split())]
Ai_And_i_list = {}
for i, Ai in enumerate(Ai_list):
    Ai_And_i_list[Ai] = i + 1
sorted_list = sorted(Ai_And_i_list.items())
for key, value in sorted_list:
    print(value)

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

data = [[0 for i in range(2)] for j in range(n)]
for i in range(n):
    data[i][0] = a[i]
    data[i][1] = i + 1
data.sort()
for i in range(n):
    print(data[i][1], end = " ")

Solution (Python):
N=int(input())
n=[list(range(2)) for i in range(N)]
h=list(map(int,input().split()))
for i in range(N):
    n[i][0]=h[i]
    n[i][1]=i+1
std=sorted(n)
for i in range(N):
    print(std[i][1], end=' ')

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

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

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

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()))
B=[[0,0] for i in range(N)]
for i in range(N):
    B[i][0]=i
    B[i][1]=A[i]
B.sort(key=lambda x:x[1])
Ans=[]
for i in range(N):
    Ans.append(B[i][0]+1)
print(*Ans)

Solution (Python):
def main():
  d = {}
  input()
  l = list(map(int, input().split()))
  result_list = [0] * len(l)
  for i in range(len(l)):
    result_list[l[i] - 1] = i+1
  print(' '.join(map(str,result_list)))

main()

Solution (Python):
n, *a = map(int, open(0).read().split())

ans=[0]*(n)
for i, j in enumerate (a, 1):
  ans[j-1] = i
print(" ".join(map(str,ans)))

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

Solution (Python):
num = int(input())
list = [int(item) for item in input().split()]
 
order = dict(zip(range(1,num+1), list))
p_order = sorted(order.items(), key=lambda x:x[1])
 
 
 
[print(item[0], end=' ') for item in p_order]

Solution (Python):
num = int(input())
list = [int(item) for item in input().split()]
 
order = dict(zip(range(1,num+1), list))
p_order = sorted(order.items(), key=lambda x:x[1])
 
 
 
for i in [item[0] for item in p_order]:
    print(str(i) + ' ', end='')

Solution (Python):
n = int(input())
order = input().split(" ")
ans = [0 for _ in range(n)]

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

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

Solution (Python):
n = int(input())
a = [int(item) for item in input().strip().split(' ')]

ordered = [0 for _ in range(len(a))]
for i, item in enumerate(a, 1):
    ordered[item - 1] = i

for item in ordered:
    print(item, end=' ')

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

Solution (Python):
N = int(raw_input())
O = list(map(int, raw_input().split()))

res = {}
for i in range(N):
    res[O[i]] = i

result = []
for i in range(N):
    result.append(res[i+1])

print(' '.join(str(x+1) for x in result))

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

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

Solution (Python):
import sys
def input():
    return sys.stdin.readline()[:-1]

N = int(input())
l = list(map(int, input().split()))
L = [None]*N

for i in range(N):
    n = l[i]
    L[i] = [n,i+1]

L.sort()
ans = [None]*N
for i in range(N):
    ans[i] = str(L[i][1])
print(' '.join(ans))

Solution (Python):
n = int(input())
a = map(int,input().split())
f = {}
count = 1
for i in a:
  f[count] = i
  count+=1
inv_map = {v: k for k, v in f.items()}
[print(inv_map[i],end=' ') for i in range(1,n+1)]

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

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

Solution (Python):
input()
li=list(map(int,input().split()))
enu_li=[[i,value] for i,value in enumerate(li,1)]

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

result=[str(value[0]) for value in enu_li]

print(' '.join(result))

Solution (Python):
from functools import reduce
from itertools import *

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

N = int(input())
A = read()

ans = [None for _ in range(N)]
for i, v in enumerate(A):
    ans[v-1] = str(i+1)
print(" ".join(ans))

Solution (Python):

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

num_list = attend_list.copy()

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

print("{}".format(" ".join(num_list)))

Solution (Python):

N    = int(input())
order=list(map(int,input().split()))
output=[0]*N

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

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

Solution (Python):
def main():
    N = input()
    L = [int(i) for i in input().split()]
    
    siL = sorted(range(len(L)), key=lambda k: L[k])
    for i in siL:
        print(i + 1, end=" ")

if __name__ == "__main__":
    main()

Solution (Python):

N = int(input())
As = list((map(int, input().split())))
ardic = {}
for i in range(N):
    ardic[As[i]] = i + 1 
result = [ardic[i] for i in range(1,N+1)]
print(' '.join(list(map(str,result))))

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()] 
answer = [0 for _ in range(n)]
 
for index, aa in enumerate(a):
  answer[aa-1] = index+1

for an in answer:
  print(an)

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

index_order = sorted(range(len(A)), key=lambda x: A[x])

res = [0]*N

for i,index in enumerate(index_order):
    res[i] = index + 1

print(*res)

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    a = list(map(int, input().split(' ')))
    b = sorted(list(zip(a, range(len(a)))), key=lambda x: x[0])
    [print(x[1] + 1, end=' ') for x in b]

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

X = list(range(1,N+1))

d = dict(zip(A, X))
d_sort = dict(sorted(d.items(), key=lambda x: x[1]))

ans_list = list(d_sort.values())
B = map(str, ans_list)
ans = ' '.join(B)
print(ans)

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

inc = 0
for val in a:
    p[val-1] = inc
    inc+=1

ans = ""
for x in p:
    ans += str(x + 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(str(ans[i]), end=" ")

Solution (Python):

N = int(input())
lis = []
lis = list(map(int,input().split()))
first = [0]*N

for i in range(N):
    num = lis[i] - 1
    first[num] = i

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

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

Solution (Python):

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

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

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

list = [(A_list[i],i+1) for i in range(N)]
heapq.heapify(list)

for i in range(N):
    print(heapq.heappop(list)[1], end=" ")

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

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

print(' '.join(B))

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

li = [0 for _ in range(N)]
for i, a in enumerate(A):
    li[a-1] = str(i+1)
    
print(" ".join(li))

Solution (Python):
a = input()
b = input()


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

come_order = [[A[x],x+1] for x in range(len(A))]
come_order.sort()

result = [x[1] for x in come_order]
print(*result)

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

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

print(*B[1:])

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

Solution (Python):

import numpy as np
import sys
input = sys.stdin.readline


def main():
    n = int(input())
    a = list(map(int, input().split()))
    a = np.argsort(np.array(a))+1
    
    
    
    
    print(*a, sep=' ')


if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
import sys
N = int(input())
A = list(map(int,input().split()))
ans = np.argsort(A)+1
for a in ans:
    sys.stdout.write(str(a))
    sys.stdout.write(" ")

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

list = [] * n

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

answer = []
for i in sorted(list):
    answer.append(i[1])

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = []
index = list(range(1, n+1))
dic_a = dict(zip(a, index))

sorted_dic_a = dict(sorted(dic_a.items()))
for i in sorted_dic_a.values():
    print(i,end=" ")

Solution (Python):
n = int(input())
_ = list(map(int, input().split()))
a = []
for i in range(1,n+1):
  a.append([_[i-1], i])
  
ans = []
a_sort = (sorted(a, key=lambda x: x[0]))
for i in range(n):
  ans.append(a_sort[i][1])
  
print(' '.join(list(map(str, ans))))

Solution (Python):
N = int(input())
A = sorted([(int(ai),i+1) for i,ai in enumerate(input().split(" "))], key=lambda x: x[0])
for _,i in A: print(i, end=" ")

Solution (Python):
N = int(input())
order = [int(v) for v in input().split()]
order = [(v, i + 1) for i, v in enumerate(order)]
order.sort()
res = [str(i[1]) for i in order]
res = ' '.join(res)
print(res)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = []
index = list(range(1, n+1))
dic_a = dict(zip(a, index))

sorted_dic_a = dict(sorted(dic_a.items()))
for i in sorted_dic_a.values():
    print(i,end=" ")
print()

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 = [(i+1, k) for i, k in enumerate(map(int, input().split()))]
print(' '.join([str(x[0]) for x in sorted(A, key=lambda x: x[1])]))

Solution (Python):
n = int(input())
s = list(map(int,input().split()))
d = {}
for i in range(n):
  d[s[i]] = i
s = []
for k, v in sorted(d.items()):
  s.append(str(v+1))
s = " ".join(s)  
print(s)

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

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

ans = []
for j in school_order.values():
  ans.append(j)
print(" ".join([str(n) for n in ans]))

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

l = []
for idx,elem in enumerate([int(x) for x in input().split()],1):
  l.append([idx,elem])

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

for i in m:
  print(i[0],end=' ')

Solution (Python):

"""
Created on Fri Oct  4 10:11:27 2019

@author: Md abdul momin
"""

N = int(input())
ans=[0 for i in range(0,100005)]
Val =[int(x) for x in input().split()]
for i in range(1,N+1):
    ans[Val[i-1]]=i
for i in range(1,N+1):
    print(ans[i])

Solution (Python):
n = int(input())
a = [int(ocu) for ocu in input().rstrip().split()]

paired_a = list(zip(range(1, n+1), a))

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

print(" ".join([str(pair[0]) for pair in paired_a]))

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








my_list = [0] * N
for i in range(len(A_list)):
    my_list[A_list[i] - 1] = i + 1
for val in my_list:
    print(val, end=" ")
print()

Solution (Python):
N = int(input())
A_list = list(map(int, input().split()))
my_list = []
for i in range(len(A_list)):
    my_list.append((A_list[i], i+1))
my_list.sort()
for val in my_list:
    print(val[1], end=" ")
print()

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

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

student_dic = {}

index = 1

for x in a:
    student_dic[x] = index
    index += 1

for x in range(len(student_dic)):
    print(student_dic[x + 1], end=' ')

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

s = sorted(range(n), key=lambda x:l[x])

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

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
ans=list()
i=0
while i < n :
    ans.append(0)
    i=i+1

i=0
j=0
while i < n:
    j=int(a[i])
    ans[j-1]=i+1
    i=i+1
i=0
while i < n:
    print(ans[i],end=" ")
    i=i+1

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

print(*order)

Solution (Python):
from operator import itemgetter

N = int(input())
A = list(map(int, input().split()))
ans = []
for i in range(1, N+1):
    ans.append([i, A[i-1]])
ans.sort(key=itemgetter(1))
for i in range(0, N-1):
    print(str(ans[i][0]), end=" ")
print(str(ans[N-1][0]))

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

Solution (Python):
if __name__ == '__main__':
	
	n = int(input())

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

	B = [0] * n

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

	print(*B)

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

d={}
for i in range(n):
  d[al[i]]=i+1

l=[]
for k,v in sorted(d.items()):
  l.append(v)
  
print(*l,sep=" ")

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

Solution (Python):



def main():


    n = int(input())
    attendList = list(map(int,input().split()))
    ansList = [0]* n

    for i,k in enumerate(attendList):
        ansList[k-1] = str(i+1)
    print(' '.join(ansList))
        



if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
std_num = list(map(int,input().split()))[:N]
std_id = list(range(N))
for index in range(N):
	id = index + 1
	i = std_num[index] - 1
	std_id[i] = id
print(*std_id)

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

d = {}
list = []
for value,key in enumerate(class_list):
    d[key]=value+1
for i in range(N):
    list.append(d[i+1])
print(' '.join(map(str, list)))

Solution (Python):
import numpy as np

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

lis = np.argsort(A)

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

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

l_2 = list(zip(range(1, N+1), l))
l_2.sort(key = lambda x: x[1])

print(*[l_2[i][0] for i in range(N)])

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])
for j in range(N):
  if j == N-1:
    print(B[j][0])
  else:
    print(B[j][0] ,end=" ")

Solution (Python):
def main():
    N = int(input())
    data = list(map(int, input().split()))

    indexed_data = list(zip(range(1, N + 1), data))

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

    for index, _ in indexed_data:
        print(index, end=' ')

    print()


if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
n = int(input())
a = list(map(int,input().split(" ")))
b = [0]*n
order = ""
for i in range(n):
	b[a[i]-1]= i+1
for i in b:
  order += str(i) + " "
order.rstrip
print(order)

Solution (Python):
import copy
import heapq

def j(n):
    if n:print("Yes")
    else:print("No")
    exit(0)
rem = 10 ** 9 + 7

"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def ipmultiplerow(n):
    a = []
    for i in range(n):
        a.append(ip())
    return a
def printrow(a):
    for i in a:
        print(i)

n = ip()
a = iprow()
s = [0 for i in range(n+1)]
for i in range(n):
    ans = a[i]
    s[ans] = i+1
for i in range(1,n+1):
    print(s[i],end = "")
    if i!=n:
        print(" ",end  = "")

Solution (Python):
N = int(input())
A_l = [int(_) for _ in input().split()]
N_l = list(range(N))
tmp = sorted(zip(N_l, A_l), key = lambda x:x[1])
N_l, A_l = zip(*tmp)
N_l = [x+1 for x in N_l]
print(*N_l,sep=' ')

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

dic = {}

for i,num in enumerate(a):
    dic[num-1] = i+1


for i in range(n):
    print(dic[i],end=' ')

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

b = [i for i in range(N)]

for i in range(N):
    b[list[i]-1] = i+1

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

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

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

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

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

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

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

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

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

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

D=dict(zip(A,numbers))                  
for a in sorted(A):
    print(D[a],end=" ")

Solution (Python):
n=int(input())
dumA=list(map(int,input().split()))
numbers=list(range(1,n+1))              
A=dumA[:n]                              

D=dict(zip(A,numbers))                  
for a in sorted(A):
    print(D[a],end=" ")

Solution (Python):
from sys import stdin
import numpy as np

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

print(" ".join([str(x) for x in np.argsort(a_lst) + 1]))

Solution (Python):

N=int(input())
A=list(map(int,input().split()))
An=[]
count=1
for i in A:
    An.append((count,i))
    count=count+1
An.sort(key=lambda x:x[1])
ans=[str(m[0]) for m in An]
ans=" ".join(ans)
print(ans)

Solution (Python):

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

















index_list = [i for i in range(1,N+1)]
class_dict = dict(zip(A_list,index_list))



class_sorted = sorted(class_dict.items(),key=lambda x:x[0])
ans = [i[1] for i in class_sorted]
print(' '.join(map(str, ans)))

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

Solution (Python):
student_num = int(input())
already = list(int(i) for i in input().split())
order = list(0 for i in range(student_num))

for i in range(student_num):
  order[already[i]-1] = i
             
for i in order:
  print(str(i+1), end=" ")

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

for i in xrange(len(a)):
    a[i] = [a[i], i + 1]

a.sort()

out = []
for x, y in a:
    out.append(str(y))

print ' '.join(out)

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

li_wk = sorted([(idx, a) for idx, a in enumerate(li_a)], key=lambda x:x[1])

print(" ".join(str(w[0] + 1) for w in li_wk))

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

ans={}

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

for k, v in sorted(anｓ.items(), key=lambda x: x[1]):
    print(str(k))

Solution (Python):
N = int(input())
records = [(order, index + 1) for index, order in
           enumerate(map(int, input().split(' ')))]


def get_index(record):
    order, index = record
    return str(index)


print(' '.join(map(get_index, sorted(records))))

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

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

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

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

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

B = sorted(A, key=lambda x: x[1])
ans = [t[0] for t in B]
print(*ans, sep=' ')

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
lst = [0] * N
for i, v in enumerate(A, 1):
    lst[v-1] = i
print(*lst, sep=' ')

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

T = [0] * N

for i in range(N):
  T[A[i] - 1] = i + 1
  
for i in range(N):
  print(T[i], end = " ")

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

for i in range(len(h)):
  ans[h[i]-1] = i+1

print(*ans)

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

Solution (Python):
N=int(input())
A=[int(i) for i in input().split(" ")]
d={}
for i,a in enumerate(A):
    d[a]=i+1

retval=[str(d[i+1]) for i in range(N)]
print(" ".join(retval))

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

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

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

D2=[]
for i in range(n):
  D2.append(str(D_sorted[i][0]))


print(' '.join(D2))

Solution (Python):
from numpy import *
input()
print(" ".join(map(str,argsort(list(map(int,input().split())))+1)))

Solution (Python):
N = int(input())
A = [[int(i),int(j)] for i,j in enumerate(input().split())]
A.sort(key=lambda x: x[1])
for n in range(N):
    print(A[n][0]+1, end=' ')

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

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

print(*B)