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=[]
for i in range(N):
  B.append(0)
for j in range(N):
  a=A[j]
  B[a-1]=j+1
for k in range(N):
  print(B[k])

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

Solution (Python):
import numpy as np
N = int(input())
Ai = list(map(int, input().split()))


print(' '.join(map(str, np.argsort(Ai) + 1)))

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

for c in l:
    print(c)

Solution (Python):
import sys
import heapq
from collections import deque
if sys.platform =='ios':
    sys.stdin=open('input_file.txt')



N=int(input())
p=list(map(int,input().split()))	
pp=deque(p)
pp.appendleft(0)

q=sorted(range(len(pp)),key=lambda k:pp[k])
qq=deque(q)
qq.popleft()

print(*qq)

Solution (Python):
input1 = int(input())
attend_list = list(map(int, input().split()))
order_list = ([None for _ in range(input1)])

for i in range(input1):
    order_list[attend_list[i] - 1] = i + 1

print(*order_list)

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

ans_list = [0] * N

for index, i in enumerate(A_list):
    ans_list[i - 1] = index + 1

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

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

Solution (Python):

N = int(input())
L1 = list(map(int,input().split()))
L2 = [[] for _ in range(N)]
for i in range(N):
    L2[L1[i]-1] = i
for i in range(N):
    print(L2[i]+1,end=" ")

Solution (Python):
n = int(input())
list1 = list(map(int, input().split()))
list2 = sorted(enumerate(list1), key=lambda x: x[1])

list3 = []
for element in list2:
    list3.append(element[0]+1)
print(' '.join(map(str, list3)))

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

cash={}
cnt = 1
for i in a:
    cash[i] = cnt
    cnt += 1
st = sorted(cash.items(), key=lambda x:x[0])

res = []
for vl in st:
    res.append(str(vl[1]))
print(' '.join(res))

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

x = np.argsort(a)
y = x + 1
z = list(map(str, y))
print(" ".join(z))

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

dict = {}
ni=1
for ai in list(a):
    dict[ai] = ni
    ni = ni +1

print(*list(dict.values()))

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


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

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
num = list(range(1,N+1))
dic = dict(zip(num,A))

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


ans = []
for i in dic_s:
  ans.append(str(i[0]))

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

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

Solution (Python):

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

for i in range(N):

    B[A[i]-1] = i+1

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

Solution (Python):
import numpy as np

n = int(input())
records= np.array([int(i) for i in input().split()])

enrolled = np.argsort(records)

attendance_list = np.array([i+1 for i in range(n)])

attendance_order = np.array(attendance_list[enrolled]).tolist()

for i in attendance_order:
  print('{} '.format(i), end="")
print()

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

Solution (Python):

import numpy as np
n = list(map(int,input().split()))
h = list(map(int,input().split()))
s = 0

x = []

i=0
for hi in h:
    x.append((i+1,hi))
    i = i+1 


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


print(*list(map(lambda k:k[0], xs)))

Solution (Python):
import numpy as np

N = int(input())

A = [int(i) for i in input().split(" ")]
j = np.argsort(A) + 1
j = [str(i) for i in j]

print(" ".join(j))

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

x = np.array(list(map(int,input().split())),dtype=np.int)

print (*np.argsort(x)+1)

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

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

ll = list()
for a in sorted(db, key=lambda x: x[0]):
    ll.append(a[1])

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

Solution (Python):
N = int(input())
student = list(map(int,input().split()))
list= []
for k,i in enumerate(student):
  list.append([i,k+1])

list2 = sorted(list)
ans = [list3[1] for list3 in list2]
for j in ans:
  print(j,end=" ")

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

t = [(i,val) for i, val in enumerate(a)]

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

for tup in sorted_tup:
  print(tup[0]+1, end=' ')

Solution (Python):
n=int(input())
a=map(int,input().split())
h=list(a)
for m in range(n):
 h[m]=h[m]*1000000+m+1
h.sort()
for m in range(n):
 h[m]=str(h[m]%1000000)
print(" ".join(h))

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

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

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

print(*a)

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

key =list(range(N))

def ca_pulse(n):
    return n +1
keys = map(ca_pulse, key)

dic = dict(zip(keys, a))

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

Solution (Python):

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

lst = {}
for i, v in enumerate(A):
    lst[i] = v  
for k, v in sorted(lst.items(), key=lambda x: x[1]):
    print(k+1, end=" ")

Solution (Python):
import sys


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


def main():
    N = int(input())
    A = list(map(int, input().split()))
    I = range(1, N+1)
    dic = dict(zip(I, A))
    dic2 = sorted(dic.items(), key=lambda x: x[1])
    ans = []
    for i in dic2:
        ans.append(i[0])
    print(*ans)


if __name__ == '__main__':
    main()

Solution (Python):
import numpy as np
N = int(input())
b = [int(i) for i in input().split()]
s=np.argsort(b)

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

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

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

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

Solution (Python):
import numpy as np

N = int(input())
Stu = list(input().split())
Stu2 = [int(i) for i in Stu]

x = np.argsort(Stu2)
for i in range(N):
    Stu[i] = x[i] + 1

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

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
for i in range(n):
  a[i]=[a[i],i]
a.sort()
s=""
for j in range(n):
  t=str(a[j][1]+1)
  print(t,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):
import numpy as np
N = int(input())
A = list(map(int, input().split())) 
B = np.argsort(A) + 1
L=[str(a) for a in B]
L=" ".join(L)
print(L)

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

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
A_sort=sorted(A)
new_dict=dict(zip(A,A_sort))
dict_sort=sorted(new_dict.items(),key=lambda x:x[0])
for i in dict_sort:
    print(i[1],end=" ")

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


def key_search(dicti, item):
    for k, v in dicti.items():
        if v == item:
            return k



sb = {str(i): As[i-1] for i in range(1, n+1)}
jb = {}
for i in range(1, n+1):
    
    jb[sb[str(i)]] = i
srted = sorted(jb.items())

ans = [srted[i][1] for i in range(n)]
print(*ans)

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

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

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

for (i, p) in enumerate(A):
  order[p-1] = i + 1

print(*order)

Solution (Python):
N=int(input())
come=list(map(lambda x:int(x)-1,input().split()))
answer=[1]*N
for i,x in enumerate(come):
    answer[x]=i+1
print(*answer)

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

h = list(map(int,input().split()))
    
d = {}

i = 1
for a in h:
    d[a] = i
    i += 1
    
for o in range(n):
    print (d[o+1],end = ' ')

Solution (Python):
n = int(input())
li = list(map(int,input().split()))
dct = { i:li[i] for i in range(n)}

for k, v in sorted(dct.items(), key=lambda x: x[1]):
    print(k+1, end = ' ' )

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

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

Ad_sorted = sorted(Ad.items(), key=lambda x:x[1])

ans = ''
for Adi in Ad_sorted:
    ans += ' ' + str(Adi[0] + 1)

print(ans.strip())

Solution (Python):
n = int(input())
students = [int(x) for x in input().split(' ')]
order = [x for x in range(n)]
for i in range(n):
    order[students[i] - 1] = i+1
print(' '.join([str(x) for x in order]))

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

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
roster=[]
for i in range(n):
  roster.append(i+1)
k=dict(zip(a,roster)) 
k=sorted(k.items())
for i in range(len(k)):
  print(k[i][1],end=" ")

Solution (Python):

n = int(input())
list = list(map(int, input().split()))
ans = {}
for n_i in range(n):
    ans[list[n_i]] = n_i + 1
arrive_sorted = sorted(ans.items(), key=lambda x:x[0])
list_2 = []
for n_i in range(n):
    list_2.append(str(arrive_sorted[n_i][1]))
final_ans = ' '.join(list_2)
print(final_ans)

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

ans = list(enumerate(A))
ans2 = sorted(ans, key=lambda x: x[1])
ans3 = [str(x[0]+1) for x in ans2]

f_a = ' '.join(ans3)
print(f_a)

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

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


b.sort(key=lambda b: b[1])
for i in range(n):
  print(b[i][0],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)
print(" ".join(L))

Solution (Python):
if __name__ == '__main__':
    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
    ans_list = map(str, ans)  
    ans_str =' '.join(ans_list)
    print(ans_str)

Solution (Python):
def main():
    N = int(input())
    num_list = [int(i) for i in input().split()]
    order_list = [0 for i in range(N)]

    for index,num in enumerate(num_list):
        order_list[num-1] = index+1
    
    print(" ".join(map(str,order_list)))

if __name__ == "__main__":
    main()

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

for i in A:
  lst[i-1] = str(cnt)
  cnt += 1

print(' '.join(lst))

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

toukou =[]
for i,a in enumerate(an):
    toukou.append([str(i+1),str(a)])
toukou.sort(key=lambda x:int(x[1]))
number = []
for s in toukou:
    number.append(s[0])
print(' '.join(number))

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
student = [[0]] * N
for n in range(0, N):
    student[A[n]-1] = n+1
count = N
for s in student:
    print(str(s), end="")
    count -= 1
    if count != 0:
        print(' ', end="")

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

li = sorted( enumerate(A, 1), key=lambda x: x[1])

print(" ".join([str(i[0]) for i in li]))

Solution (Python):
from collections import OrderedDict

n = int(input())
a_list = map(int, input().split())

a_dict = {i+1: a for i, a in enumerate(a_list)}  


a_dict_sorted = OrderedDict(sorted(a_dict.items(), key=lambda kv: kv[1]))  


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

Solution (Python):
def main():
    N = int(input())
    A = list(map(int, input().split()))
    ans_list = [None for _ in range(N)]

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

    for v in ans_list:
        print(v + 1, end=" ")

    print()


if __name__ == "__main__":
    main()

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(1,n+1)]
ab = dict(zip(a, b))
ab2 = sorted(ab.items())
m = []

for i in range(n):
    m.append(str(ab2[i][1]))
else:
    print(" ".join(m))

Solution (Python):
n=int(input())
a=[int(x) for x in input().split()]
vl =[]
tmp =[]
ans=[0]*n
for i,value in enumerate(a):
  tmp.append(i)
  vl.append(value)
for i in range(n):
  ans[vl[i]-1]=tmp[i]+1
print(*ans)

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

print(" ".join(a))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
AN = list(enumerate(A))
sAN = sorted(AN, key=lambda x: x[1])
ans = []
for i in range(N):
    ans.append(sAN[i][0]+1)
ans2 = [str(ans[i]) for i in range(len(ans))]
print(" ".join(ans2))

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

r = [0]*N

for index in range(N):
    l = li[index]
    r[l-1] = str(index+1)

print(" ".join(r))

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

Solution (Python):
n=int(input())
a_lis=list(map(int,input().split()))
lis = sorted(range(n), key=lambda k: a_lis[k])
for i in range(n):
    lis[i]=str(lis[i]+1)
print(' '.join(lis))

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

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

a_new = sorted(range(len(a)), key=lambda k: a[k])
for ii in range(n):
    print(a_new[ii]+1)

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

r = []
for i, a in enumerate(A):
    r.append([i + 1, a])
r = sorted(r, key=lambda x: x[1])
r = map(lambda x: str(x[0]), r)
print(' '.join(r))

Solution (Python):


N=int(input())
A=list(map(int,input().split()))
B=[0 for h in range(N)]
for i in range(1,N+1):
    B[A[i-1]-1]=i
for j in range(N):
    print(B[j],end=" ")

Solution (Python):
n = int(input())
a_i = input().split()
ans = ""
ans_l = [0] * n
for i in range(len(a_i)):
  ans_l[int(a_i[i])-1] = i + 1
for j in range(n):
  ans += str(ans_l[j])
  if j != (n - 1):
    ans += " "
print(ans)

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    student = list()
    for i in range(N):
        student.append(i + 1)
    dic = dict(zip(A, student))
    dic_sorted = sorted(dic.items(), key=lambda x: x[0])
    
    ans = ""
    for i in range(N):
        ans += str(dic_sorted[i][1]) + " "
    print(ans[:-1])
    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 = input()
A = list(map(int,input().split()))

B = list(range(1,len(A)+1))

C = zip(A,B)
C = sorted(C)

a, b = zip(*C)

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

Solution (Python):

N = int(input())

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


dict_a = dict(zip(a,b))

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

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

A_dict = {x: y for x, y in zip(range(1, N+1), A)}

A_dict_sort = sorted(A_dict.items(), key=lambda x: x[1])

for a in A_dict_sort:
    print(a[0], end=' ')

Solution (Python):
import numpy

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


junban = numpy.argsort(A_list)
junban = numpy.array(junban) + 1
junban2 = map(str,junban)
result = ' '.join(junban2)
print(result)

Solution (Python):
import numpy as np

n = int(input())
a = list(map(int, input().split()))
a = np.array(a)
b = np.argsort(a)
for x in b:
    print(x+1, end=" ")

print()

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

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

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

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

for x in range(len(a)):
    print(str(a[x]) + " ", end="")

Solution (Python):
n = int(input())
records = list(map(int, input().split()))
order = sorted([ [i + 1, r] for i, r in enumerate(records) ], key=lambda x: x[1])
order = ' '.join([ str(x[0]) for x in order ])
print(order)

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

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

data.sort()


for i in data:
  print(str(i[1]), end=" ")

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

import numpy as np

def main():
    n = int(input())
    a_list = np.array(list(map(int, input().split())))

    print(*np.argsort(a_list)+1)


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
p_list = list(map(int, input().split()))
p_dict = {}
for i, p in enumerate(p_list):
    p_dict[p] = i
res_list = []
for key in sorted(list(p_dict.keys())):
    res_list.append(str(p_dict[key]+1))
print(' '.join(res_list))

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

Solution (Python):
n = int(input())
a = list(int(i) for i in input().split())
c = list()
l = sorted(range(len(a)), key=lambda k: a[k])
for i in range(n):
    b = l[i] + 1
    c.append(b)
print(" ".join( repr(e) for e in c ))

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

Solution (Python):
n = int(input())
aList = list(map(int, input().split()))
l = []
for i, a in enumerate(aList):
    l.append((a, i))
l = sorted(l, key=lambda x:x[0])
ansList = [a[1] + 1 for a in l]
print(' '.join(map(str, ansList)))

Solution (Python):
import numpy as np
N = int(input())
arr = list(map(int,input().split()))

s =np.zeros(N)
for i in range(len(arr)):
  s[arr[i]-1]=i+1


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

Solution (Python):
import numpy
N = int(input())
A = list(map(int, input().split()))
key = numpy.argsort(A) + 1
print(' '.join(map(str, key)))

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

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

print(' '.join(number))

Solution (Python):
N = int(input())
a = input().split()
 




new_list =[0] * N
for i , b in enumerate(a):
  new_list[int(b)-1] = i + 1
print(' '.join(map(str, new_list)))

Solution (Python):
num = int(input())
lines = input().split(" ")
numline = [int(i) for i in lines]
numbers = [i+1 for i in range(num)]
dic = dict(zip(numbers, numline))

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

for i in range(num):
  arr.append(str(dic2[i][0]))
  
print(" ".join(arr))

Solution (Python):
import sys
input = sys.stdin.readline
n = int(input())
a = [int(i) for i in input().split(' ')]

dict = {}
for i, value in enumerate(a):
    dict[value] = i + 1

a.sort()

for i in a:
    print(dict[i], end=' ')
print()

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

A_number = [0]*N
A_list = [[0 for i in range(2)] for j in range(N)]

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

A_new = sorted(A_list, key=lambda x:x[0])

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

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

for i in range(1,n+1):
    if i != n+1:
        print('{} '.format(dict[i]),end="")
    else:
        print(dict[i])

Solution (Python):
if __name__ == "__main__":
	num = int(input())
	a = list(map(int, input().split()))

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

	for a_n in range(0, num):
		
		sort[a[a_n] - 1] = a_n + 1

	for sorted in sort:
		print(sorted, end = " ")

	print("")

Solution (Python):


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

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

for li in l:
    print(str(li[0]) + " ", end="")

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

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

Solution (Python):
import numpy as np

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

a = np.array(a)
sorted_a = np.argsort(a)
sorted_a = map(lambda x:x+1, sorted_a)
print(*sorted_a)

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    students = list(map(int, input().split()))
    submit = [","] * n
    for i in range(n):
        submit[students[i] - 1] = str(i + 1)
    print(" ".join(submit))

Solution (Python):
a = int(input())
b = list(map(int,input().split()))
c = []
for val in range(a):
    c.append(5)
for val in range(a):
    c[b[val]-1] = val+1
d = str()
for val in range(len(c)-1):
    print(c[val], end = ' ')
print(c[-1])

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

i = 1
ans=[0]*N

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

Solution (Python):
import numpy as np

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

k = np.argsort(l)

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

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

Solution (Python):
from collections import defaultdict
mike=int(input())
boid=[int(i) for i in input().split()]

boid2=defaultdict(int)
for i in range(len(boid)):
    boid2[i+1]=boid[i]
    

ans = sorted(boid2.items(), key=lambda x: x[1])

for i in range(len(boid2)):
    print(ans[i][0],end=" ")

Solution (Python):
import copy
N=int(input())
L=[int(x) for x in input().split()]
Ans=[0]*N

for i in range(N):
	Ans[L[i]-1]=i+1

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

Solution (Python):
n = int(input())
a_n = list(int(i) for i in input().split())

result = [0 for x in range(n)]
for i in range(n):
    result[a_n[i]-1] = i + 1

print(" ".join(str(r) for r in result))

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

Solution (Python):


N = int(input())
A = list(map(int,input().split()))
L =[]
for i in range(1,N+1):
    L.append(i)

d = dict(zip(A,L))

d_sorted = sorted(d.items())

L=[]
for i in range(N):
    L.append(d_sorted[i][1])

for i in L:
    print(i, end = ' ')
print('')

Solution (Python):

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

d = [0]*N
for i,j in enumerate(a):
    d[j-1] = str(i+1)

print(' '.join(d))

Solution (Python):


N = int(input())

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

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

for x in A:
    B[x - 1] = i
    i += 1

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

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

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

Solution (Python):
a = int(input())
b = list(map(int, input().split()))
c = [0]*len(b)
for (i, j) in zip(b,range(len(b))):
  c[i-1] = j+1
for k in c:
  print(k,end=' ')

Solution (Python):
import copy
N = int(input())
A = list(map(int,input().split()))
B = copy.deepcopy(A)
B.sort()
num = [i for i in range(N)]
data = dict(zip(A,num))
ans = []
for i in B:
    ans.append(data[i]+1)
for i in ans:
    print(i,end=" ")

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

B = [0]*N
j = 0
for i in A:
    j += 1
    B[int(i)-1] = j

resutl = ""
for i in B:
    resutl += (str(i) + " ")
print(resutl.rstrip())

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

for i in range(n):
    an[li[i]-1]=i+1

print(*an)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
num = [i for i in range(1, N+1)]
L = list(zip(num, a))
L.sort(key=lambda x: x[1])
ans = [x[0] for x in L]
print(*ans, sep=' ')

Solution (Python):

from sys import stdin
import heapq

N = int(input())
As = [int(x) for x in stdin.readline().rstrip().split()]
ans = [0] * N

for i in range(N):
    x = As[i]
    ans[x-1] = i + 1

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

Solution (Python):
from collections import deque

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



dict1={}
for i in range(N):
  dict1.update({i+1:array[i]})
dct = sorted(dict1.items(), key=lambda x:x[1])

for num in dct:
  print(str(num).split(",")[0].lstrip("("),end=" ")

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

anser = [0]*n

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

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

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

s = [0] * n

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

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

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

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

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

class student:
    def __init__(self, number, name):
        self.number = number
        self.name = name

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

reorder = sorted(order, key=lambda u: u.number)

for i in range(n):
    if i == n-1:
        print(reorder[i].name)
    else:
        print(reorder[i].name, end=" ")

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

data = {}
for i, num_student in enumerate(As):
    data[i + 1] = num_student
sorted_dict = sorted(data.items(), key=lambda x: x[1])
print(' '.join(map(str, [x[0] for x in sorted_dict])))

Solution (Python):
import numpy as np

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

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

L = [[int(i)+1] for i in range(N)]

for i in range(N):
    L[i].append(A[i])

L.sort(key=itemgetter(1))

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

print(*ans)

Solution (Python):

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


N=int(input())
A=acinput()

x=list(zip(A,range(1,N+1)))

x=sorted(x,key=lambda x:x[0])
res=list(map(lambda y:str(y[1]),x))
print(" ".join(res))

Solution (Python):
import numpy as np
N = int(input())
A = input().split()
B = [[],[]]
for i in range(N):
  B[0].append(i + 1)
  B[1].append(int(A[i]))

C = np.array(B).T  
C = C.tolist()
D = sorted(C,key=lambda x: x[1])

E = []
for i in range(N):
  E.append(D[i][0])
  print(E[i],end=" ")

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

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

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

Solution (Python):
N = int(input())
H = input().split()
h = []
cnt = 0
for i in range(N):
  h.append(int(H[i]))

h1 = [0 for i in range(N)]
for i in range(N):
  h1[h[i] - 1] = i+1
  
      
str1 = map(str, h1)
str1 = " ".join(str1)
print(str1)

Solution (Python):
import numpy as np


N=int(input())

A=np.array([list(map(int, input().split()))])


B=np.argsort(A[0,:])
for b in B:
  print(b+1, end=' ')

Solution (Python):
import numpy as np

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

npa = np.array(a)
print(*(np.argsort(npa) + 1))

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

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

l.sort()

print(" ".join([str(l[i][1]) for i in range(0, n)]))

Solution (Python):
from operator import itemgetter

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

result =[]
for i in range(len(entry)):
    result.append([i+1, entry[i]])
result2 = sorted(result, key=itemgetter(1))
    
for i in range(len(result)):
    print(result2[i][0], " ", end="")

Solution (Python):
n=int(input())
l = map(int, input().split())
kitazyun=[]

for i, kita in enumerate(l):
    kitazyun.append([kita,i+1])




ll=sorted(kitazyun)


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

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

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

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

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

dict = {}
for i in range(n):
    dict[str(i)] = h[i]

dict_sorted = sorted(dict.items(), key=lambda x:x[1])


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

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