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()))
ans=["0"]*n
for i in range(n):
    ans[a[i]-1]=str(i+1)
print(" ".join(ans))

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

memo = [0 for _ in range(n+1)]

for index, i in enumerate(id_list, 1):
    memo[i] = index

del memo[0]
print(*memo)

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

output = list(range(0,N))

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

print(*output)

Solution (Python):

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

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

for i,x in enumerate(input().split(" ")):
    d[str(i+1)] = int(x)


d_sorted = sorted(d.items(), key=lambda x:x[1])
ans = []
for i in range(n):
    ans.append(d_sorted[i][0])
print(' '.join(ans))

Solution (Python):
n=int(input())
s=input().split()
a=[]
for i in range(n):
    x=int(s[i])
    a.append([x,i+1])
a.sort(key=lambda x:x[0])
for i in range(n):
    if i==n-1:
        print(a[i][1])
    else:
        print(a[i][1],end=" ")

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
indices = [i + 1 for i in range(n)]
result = sorted(zip(a, indices))
ans = "{}".format(result[0][1])
for i in range(n)[1::]:
    ans += " {}".format(result[i][1])
print(ans)

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

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

print(*result)

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

print(' '.join([str(_+1) for _ in np.argsort(np.array(a))]))

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
def resolve():
    n=int(input())
    AI=[(a,i) for i,a in enumerate(map(int,input().split()),1)]
    AI.sort()
    I=[i for a,i in AI]
    print(*I)
resolve()

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

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

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

print(" ".join(ans))

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

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

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

print(*ans)

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

X = [[0,0] for i in range(N)]

for i in range(N):
  X[i][0] = A[i]
  X[i][1] = i+1
  
X.sort()

ans = []
for i in range(N):
  ans.append(X[i][1])
  
print(" ".join(map(str, ans)))

Solution (Python):
import math
import numpy as np

def main():
    N = int(input())
    As = list(map(int, input().split()))
    As = np.array(As)
    idx = np.argsort(As)
    ret = ' '.join(map(str, idx+1))
    print(ret)

if __name__ == '__main__':
    main()

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

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

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
r={}
for index, value in enumerate(A):
  r[value]=index+1

for value in r.values():
	print(value, end=" ")

Solution (Python):
from __future__ import print_function

import sys
input = sys.stdin.readline

def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return















































def main():
    n = int(input().strip())
    a = list(map(int, input().strip().split()))
    l = [[a[i],i] for i in range(len(a))]
    l.sort()
    
    
    l_ans=[l[i][1] + 1 for i in range(len(l))]
    print(*l_ans)
    return

if __name__ == '__main__':
    main()

    ''''
    0  1  2 
    2p 3p 1p


    '''

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
    N = I()
    a = LI()
    X = [(i+1, x) for (i, x) in enumerate(a)]
    X = sorted(X, key=lambda x: x[1])
    ans = " ".join([str(x[0]) for x in X])
    print(ans)
main()

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

L = []
for idx, order in enumerate(A):
    L.append((idx + 1, order))

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

for idx, _ in L:
    print(idx, end=' ')

print('')

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

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
dic_A={}
for i in range(N):
    dic_A[A[i]]=i+1
dic_A=sorted(dic_A.items())
ans=[str(v[1]) for v in dic_A]
print(' '.join(ans))

Solution (Python):
def main():
	n = int(input())
	List = list(map(int,input().split()))
	
	ans = []

	for i in range(n):
		ans.append(0)
	
	
	
	for i in range(n):
		
		
		ans[List[i]-1] = i+1
		
		

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

if __name__ == '__main__':
	main()

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

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

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

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

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

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

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

Solution (Python):
a = int(input())
b = list(map(int,input().split()))
test_dict = {}
for i in range(a):
    test_dict[i+1] = b[i]
score_sorted = sorted(test_dict.items(), key=lambda x:x[1])
ans = ''
for i in score_sorted:
    ans += str(i[0])+' '
print(ans)

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

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

    ans_list = [0]*n

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


if __name__ == '__main__':
    main()

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

order = [None] * N

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

print(" ".join(order))

Solution (Python):
N = int(input())
dic = {}

for i, A_i in enumerate(map(int, input().split()), 1):
    dic[i] = A_i

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

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

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

Solution (Python):
import numpy as np

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

B = np.argsort(A, axis=0)
B = [n+1 for n in B]

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

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

Solution (Python):

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

for idx, item in enumerate(A):
    ans_dict[item] = idx+1
    
sorted_dict = sorted(ans_dict.items(), key = lambda x:x[0])

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

Solution (Python):
from operator import itemgetter
N = int(input())
A = list(map(int, input().split()))
B = sorted(enumerate(A, 1), key=itemgetter(1))
print(*list(map(itemgetter(0), B)))

Solution (Python):
N  = int(input())
S = input().split()
C = [0 for i in range(N)]
ans = ""
for i in range(N):
	C[int(S[i])-1] = i+1

for c in C:
	ans += str(c) + " "

print(ans)

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 + 1)
    for i, j in enumerate(a):
        ans[j] = i + 1
    print(*ans[1:])

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, j in enumerate(a):
        ans[j-1] = i + 1
    print(*ans)

if __name__ == '__main__':
    main()

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

stu = []

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

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

for i in range(N):
    print(stu[i][0]+1)

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
new_a = list("0"*len(a))

for i, a_i in enumerate(a):
    new_a[a_i-1] = str(i+1)
    
print(" ".join(new_a))

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
t= [[i] for i in range(1,n+1)]
for i in range(n):
  t[i].append(A[i])
t1=sorted(t,key=lambda x: x[1])
for i in range(n-1):
  print(str(t1[i][0])+" ",end="")
print(t1[-1][0])

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = sorted(range(len(A)), key=lambda k:A[k])
print(' '.join(list(map(lambda x:str(x+1), ans))))

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

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

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
B=sorted([[n,a] for n,a in enumerate(A,1)],key=lambda x:x[1])
R=[]
for r in B:
    R.append(r[0])
print(' '.join(map(str,R)))

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

for i, j in enumerate(a, 1):
  result[j-1] = i

print(*result)

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

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

Solution (Python):
from itertools import *
from math import *

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

for idx, ai in enumerate(A):
    invmat[ai] = idx + 1

print(" ".join(map(str, [invmat[i + 1] for i in range(N)])))

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

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

R = [None for _ in range(N)]

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

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

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

arr2 = []

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

arr2.sort(key=lambda x:x[0])

ans =[]

for j in range(n):
	ans.append(arr2[j][1])

arrr = ' '.join(str(k) for k in ans)
print(arrr)

Solution (Python):
n = int(input().strip())
a_s = [int(s) for s in input().split()]

ret = [0] * n

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

print(' '.join([str(r) for r in ret]))

Solution (Python):
import numpy as np
N=int(input().strip())
A=np.array(list(map(int,input().strip().split())))
ans=[0]*N
for i in range(N):
    ans[A[i]-1]=i+1
for i in range(N):
    print(ans[i], end=" ")

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

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

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

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

x = [0] * n

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

print(*x)

Solution (Python):
import numpy as np
N = int(input())
a = list(map(int,input().split()))
ans = list(np.argsort(a)+1)
for i in range(len(ans)):
    if i == N-1:
        print(ans[i])
    else:
        print(ans[i],end=' ')

Solution (Python):

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

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

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

for no, order in enumerate(L, 1):
    P[order - 1] = no

print(*P)

Solution (Python):
N = int(input())
A = list(int(x) for x in input().split())
d = {}

for i in range(N):
    d[i] = A[i]
d_sorted = sorted(d.items(), key=lambda x:x[1])
for key, value in d_sorted:
    print(key+1, end=" ")

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

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

for i, x in sorted(enumerate(a), key=lambda x:x[1]):
	print(i+1)

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

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

Solution (Python):


N = int(input())
A = {}
for i, order in enumerate(map(int, input().split())):
    A[i] = order

A_sorted = sorted(A.items(), key=lambda x:x[1])

for i in A_sorted:
    print("{} ".format(i[0]+1), end='')

Solution (Python):


import sys

def I(): return int(input())


def IsIl(): return list(map(lambda x: int(x), input().split()))


def InIl(n): return [input() for i in range(n)]


def IsIt(): return map(lambda x: int(x), input().split())


def InIl(n): return map(input() for i in range(n))


def SsSl(): return list(map(lambda x: x, input()))




def SSd():
    from collections import defaultdict
    A = input() 
    dd=defaultdict(int)
    for a in A:
        dd[a]+=1
    return dd






from heapq import heappop, heappush

n = I()

lis_a = IsIl()



q = []
for num, item in enumerate(lis_a):
    heappush(q,(item,num+1))

ans = ''
for num in range(n):
    a, num = heappop(q)
    ans += str(num)+' '


print(ans)

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

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

for i, num in enumerate(L):
    b[num-1] = i+1

print(*b)

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

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

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

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

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

ans = []
for i in sorted(t, key=lambda x: x[1]):
    ans.append(i[0])
print(" ".join(map(str, ans)))

Solution (Python):

from operator import itemgetter
N=int(input())
A=list(map(int,input().split()))
ans=[i+1 for i,_ in sorted(enumerate(A),key=itemgetter(1))]

print(*ans)

Solution (Python):
from operator import itemgetter

number_of_student = int(input())
student = list(map(int, input().split()))


recontructed = [
    t[0] + 1 for t in sorted(enumerate(student), key=itemgetter(1))]

print(*recontructed)

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

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

Solution (Python):
n = int(input())
s = [[i, j] for i, j in zip(map(int, input().split()), range(1, n+1))]
s = sorted(s, key=lambda x: x[0])
for i in range(n):
    print(s[i][1], end=" ")
print()

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

Solution (Python):
import numpy as np

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

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

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

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

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

print(*[v[0] for v in lst])

Solution (Python):
_ = input()
s = map(int,input().split())
ans = []
di = {}
for ind,num in enumerate(s):
    di[num] = ind+1
for key,value in sorted(di.items(),key=lambda x:x[0]):
    ans.append(str(value))
print(" ".join(ans))

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

Solution (Python):
from operator import itemgetter

N = int(input())
A = list(map(int,input().split()))
index_A = sorted([[i+1,x] for i,x in enumerate(A)],key=itemgetter(1))
A = [i[0] for i in index_A]

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

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

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

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

print(*ans)

Solution (Python):
from numpy import argsort, array

def f(x):
	return str(x+1)

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

sort_index = list(map(f, argsort(a)))

print(' '.join(sort_index))

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

Solution (Python):
from collections import OrderedDict
n = int(input())
a = list(map(int, input().split()))

key_value = {}
for i in range(1, n + 1):
	key_value[i] = a[i-1]
sorted_key_value = OrderedDict(sorted(key_value.items(), key=lambda x:x[1]))
stu_num_order = list(sorted_key_value.keys())
print(*stu_num_order)

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

shusseki_dict = {}
for i in range(N):
    key = str(i+1)
    shusseki_dict.setdefault(key, '')
    shusseki_dict[key] = students[i]

sorted_shusseki = sorted(shusseki_dict.items(), key=lambda x:x[1])

sorted_students = [i[0] for i in sorted_shusseki]

print(' '.join(sorted_students))

Solution (Python):
N=int(input())
h=list(map(int,input().split()))
listH = []
cnt=1
ans=[]
for i in h:
  listH.append([i,cnt])
  cnt=cnt+1
listH.sort()
for j in listH:
  ans.append(j[1])

print(*ans)

Solution (Python):
N=int(input())
h=list(map(int,input().split()))
listH = []
cnt=1
ans=[]
for i in h:
  listH.append([i,cnt])
  cnt=cnt+1
listH.sort()
for j in listH:
  ans.append(j[1])

print(*ans)

Solution (Python):
from operator import itemgetter
n = int(input())
a = [(int(y),x) for x,y in enumerate(input().split())]
a.sort(key=itemgetter(0))
print(*[x[1]+1 for x in a], sep=' ')

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

ans = [0]*N
for i, order in enumerate(lists):
    ans[order-1] = i+1
print(*ans)

Solution (Python):
import numpy as np
from operator import itemgetter
N = input()
a = np.array(input().split()).astype(int)
print(" ".join(np.array(sorted(np.array([a, np.arange(1, len(a)+1)]).T.tolist(), key = itemgetter(0),reverse=False)).T[1].astype(str)))

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

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

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

ans = sorted(ans)

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

print()

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
anslist = [0] * n 
for idx,elem in enumerate(a, start=1):
    anslist[elem - 1] = str(idx)
print(' '.join(anslist))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
B = list(range(1,N+1,1))
C = zip(A,B)
D = sorted(C)
a, b = zip(*D)
print(" ".join(str(x) for x in b))

Solution (Python):
print(*[i for i in{m:i+1for i,m in zip(range(int(input())),map(int,input().split()))}.values()])

Solution (Python):

import numpy as np
N = int(raw_input())
A = np.array(map(int, raw_input().split()))

order = np.argsort(A) + 1
print " ".join(["%d"%i for i in order])

Solution (Python):
[print(i,end=' ')for i in{m:i+1for i,m in zip(range(int(input())),list(map(int,input().split())))}.values()]

Solution (Python):
N = int(input())
members = list(map(int, input().split()))
junban = {}

for i,member in zip(range(N), members):
  junban[member] = i+1
  
for i in junban.values():
  print(i,end=' ')

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

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

ans_lst=[None]*n
for i,h[i] in enumerate(h):
    ans_lst[h[i]-1]=i+1
print(*ans_lst)

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

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

L = [0] * N

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

print(*L)

Solution (Python):

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


s = sorted(range(len(s)), key=lambda k:s[k])
ans = [x+1 for x in s]
print(*ans)

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

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

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

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

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

Solution (Python):
import sys


import math
from fractions import gcd
from collections import deque
import bisect

sys.setrecursionlimit(1000000)


def main():
    
    

    N = int(input())
    A = list(map(int, input().split()))
    combi = list(zip(range(1, N+1), A))
    combi.sort(key=lambda x: x[1])
    for key in combi:
        print(key[0], end=' ')
    print('')


if __name__ == "__main__":
    main()

Solution (Python):
n = int(raw_input())
a = map(int, raw_input().split())
pair = []
for i in range(len(a)):
    pair.append([i+1, a[i]])

pair.sort(key=lambda x:x[1])
pair = map(lambda x:str(x[0]), pair)
print " ".join(pair)

Solution (Python):
n=int(input())
a=[int(i) for i in input().split()]
a1={}
for i in range(n):
  a1[a[i]]=i+1
a2=sorted(a1.items(),key=lambda x:x[1])
a2.sort()
a3=[i[1] for i in a2]
print(*a3)

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

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

Solution (Python):
import operator

n = input()
s = [(int(v),i+1) for i,v in enumerate(input().split())]
s = sorted(s,key=operator.itemgetter(0))
total = ""
for si in s :
  total += str(si[1])+" "

total = total[:len(total)-1]
print(total)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
d = {a:i for i, a in zip(range(1, N+1), A)}

print(*d.values())

Solution (Python):
from operator import itemgetter

def main():
    N = int(input())
    A = [[i,int(a)] for i,a in zip(range(N),input().split())]
    A.sort(key = itemgetter(1))
    for i,a in A:
        print(i+1)

main()

Solution (Python):
n = int(input())
a=[]

b = list(map(int, input().split()))
for i in range(n):
    a+=[[i+1, b[i]] ]
    
    
import operator as op
a.sort(key = op.itemgetter(1))

x=""
for i in range(n):
    x+=str(a[i][0])
    if i!=n-1:
        x+=" "

print(x)

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

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

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

Solution (Python):
import sys
if sys.platform =='ios':
	sys.stdin=open('Untitled.txt')
input = sys.stdin.readline

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

AS = [[a,idx+1] for idx,a in enumerate(A)]
AS.sort()

for a in AS:
	print(a[1], end=" ")

Solution (Python):

import math
import heapq
import bisect

MOD = 10**9+7

N = int(input())


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


L = []
for i,v in enumerate(A):
    a = tuple([i+1,A[i]])
    L.append(a)
L = sorted(L, key=lambda x:x[1])

for i in range(N):
    print(L[i][0])

Solution (Python):

import math
import heapq
import bisect

MOD = 10**9+7

N = int(input())


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


L = []
for i in range(N):
    a = tuple([A[i],i+1])
    L.append(a)
L = sorted(L, key=lambda x:x[0])

for i in range(N):
    print(L[i][1])

Solution (Python):
n = int(input())
arr = [[i + 1, int(v)] for i, v in enumerate(input().split())]
sorted_arr = list(map(lambda x: str(x[0]), sorted(arr, key=lambda x: x[1])))

print(" ".join(sorted_arr))

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


def solve():
    readline = sys.stdin.buffer.readline
    mod = 10 ** 9 + 7
    n = int(readline())
    a = list(map(int, readline().split()))
    ans = []
    for i, v in enumerate(a):
        ans.append([i, v])
    ans.sort(key=lambda x: x[1])
    ls = []
    for i in range(n):
        ls.append(ans[i][0] + 1)
    print(*ls)


if __name__ == '__main__':
    solve()

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

ans = []

for i in range(n):
    ans.append(l[i][1])

ans = list(map(str, ans))

print(" ".join(ans))

Solution (Python):
import numpy as np
n = int(input())
a = [int(i) for i in input().split()]
ans = np.zeros(n, dtype=int)
for i in range(n):
    s = a[i]
    ans[s-1] = i+1
print(" ".join([str(i) for i in ans]))

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

N = int(input())
li = list(map(int,input().split()))
ans = [0] * N
for i in range(N):
    ans[li[i]-1] = i+1
for j in range(N):
    print(ans[j],end = ' ')

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

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

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
n = [i for i in range(1,n+1)]
d = dict(zip(l,n))
print(' '.join(map(str,list(d.values()))))

Solution (Python):

from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


def ceil(a, b):
    return (a + b - 1) // b


def sum_of_arithmetic_progression(s, d, n):
    return n * (2 * s + (n - 1) * d) // 2


def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)


def lcm(a, b):
    g = gcd(a, b)
    return a / g * b


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

    ans = []
    for p in sorted(v):
        ans.append(p[1])

    print(*ans)


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


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()] 
out = [0] * n

for i in range(n):
  out[a[i]-1] = str(i + 1)
  
print(' '.join(out))

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

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

b = ' '.join(map(lambda x: str(x[0] + 1), a))

print(b)

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

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

import sys














def main():
    n, *a = [int(x) for x in sys.stdin.read().split()]
    a = list(enumerate(a, 1))
    a.sort(key=lambda x: x[1])
    for i in a:
        print(i[0], end=' ')

if __name__ == "__main__":
    main()

Solution (Python):
N=int(input())
A=list(map(int, input().split()))
B=A.copy()
for i in range(N):
  B[A[i]-1]=int(i+1)
for t in B:
  print(t,end=" ")