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):
from collections import OrderedDict
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)


def main():
    n = int(input())
    od = OrderedDict()
    a = list(map(int, input().split()))
    for i in range(len(a)):
        od[a[i]] = i+1

    p = OrderedDict(
        sorted(od.items(), key=lambda x: x[0])
    )

    print(*[v for k, v in p.items()])


if __name__ == '__main__':
    main()

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

Solution (Python):
if __name__ == "__main__":
    n = int(input())
    """studentNumbers = [(x, str(i)) for x, i in
        zip(input().split(), range(1, 1000000))]
    studentNumbers.sort(key=lambda tup: tup[0])
    print(' '.join([x[1] for x in studentNumbers]))"""
    studentNumbers = [int(x) for x in input().split()]
    times = [0 for i in range(n)]
    for i in range(n):
        times[studentNumbers[i] - 1] = str(i+1)
    print(' '.join(times))

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

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

arr2 = sorted(arr1.items(), key=lambda x:x[1])

ans = ''
for k,v in arr2:
		print(k)

Solution (Python):
n = int(raw_input())
a = map(int,raw_input().split())
t = []
for i in xrange(n):
	t.append((a[i],i+1))
t = sorted(t)
print " ".join(str(x[1]) for x in t)

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

for i in range(n):
  ch.append([a[i], i+1])
ch.sort()
for i in range(n):
  if i==n-1:
    print(ch[i][1])
  else:
    print(ch[i][1], end=" ")

Solution (Python):
N = int(input())
A = input().split(' ')
 
t = []
for i in range(N):
    t.append(0)
 
for i in range(N):
    t[int(A[i]) - 1] = str(i + 1)
 
res = ' '.join(t)
 
print(res.strip())

Solution (Python):
_n = int(input())
_records = list(map(int, input().split()))
_order = [0] * _n
_rank = 1
for _i in range(_n):
  _order[_records[_i] - 1] = _i + 1
      
print(" ".join(map(str, _order)))

Solution (Python):
from operator import itemgetter
N = int(input())
A = [(ind+1,int(x)) for ind,x in enumerate(input().split())]
A.sort(key=itemgetter(1))
ans = []
for a in A:
  ans.append(a[0])
print(*ans)

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

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

d={ea:eb for (ea,eb) in zip(a,b)}

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

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

d = dict(zip(a,t))
for k,v in sorted(d.items(), key=lambda x: x[0]):
    print(v, end=" ")

Solution (Python):

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


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

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

for i in range(N):
    print(C[i][0], 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

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

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

B = [0]*N
i = 1
for num in A:
    B[num-1] = i
    i += 1

print(*B)

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

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

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

Solution (Python):
N = int(input())
array = list(map(int, input().split()))
numbers = [100 for i in range(N)]
num = 1


for i in array:
  numbers[i-1] = num
  num += 1

for s in numbers:
  print(s, end =" ")

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

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

Solution (Python):



def main():
    n = int(input())
    a = list(map(int, input().split()))
    d = dict()
    ans = list()

    for i, ai in enumerate(a, 1):
        d[i] = ai

    for j, di in sorted(d.items(), key=lambda x: x[1]):
        ans.append(j)

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


if __name__ == '__main__':
    main()

Solution (Python):
import sys
from collections import deque

input = sys.stdin.readline

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


aq =deque(A)
b= [0]*N

for i in range(N):
    b[aq.popleft()-1] = i+1

print(*b,sep=' ')

Solution (Python):

N = input()
A_str = input().split(" ")
A_int = [int(str) for str in A_str]

res = list(A_int)

for i in range(len(A_int)):
    res[A_int[i]-1] = i+1

res_str = [str(n) for n in res]
res_out = ' '.join(res_str)
print(res_out)

Solution (Python):
import sys


def main():
    n = int(input())
    a = [int(i) for i in sys.stdin.readline().split()]
    ans = [0] * n
    for i in range(n):
        ans[a[i] - 1] = i + 1
    print(*ans)


if __name__ == "__main__":
    main()

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
dic ={}
p=1
for i in a:
   dic[i]=p
   p=p+1
s=sorted(dic)
for t in s:
    print(dic[t],end=" ")

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

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


if __name__ == '__main__':
  main()

Solution (Python):
n=int(input())
a=[[int(x),i+1] for i,x in enumerate(input().split())]
a.sort()
print(' '.join(str(i) for x,i in a))

Solution (Python):
def main():
    N, *A = map(int, open(0).read().split())
    ans = [0] * N
    for k, v in enumerate(A, 1):
        ans[v - 1] = k
    print(" ".join(map(str, ans)))
    return


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    N, *A = map(int, open(0).read().split())
    ans = [0] * (N + 1)
    for k, v in enumerate(A, 1):
        ans[v] = k
    print(" ".join(map(str, ans[1:])))
    return


main()

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

Solution (Python):
def main():
    N, *A = map(int, open(0).read().split())
    ans = [0] * N
    for k, v in enumerate(A, 1):
        ans[v - 1] = k
    print(" ".join(map(str, ans)))
    return


main()

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

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

Solution (Python):
def main():
    N, *A = map(int, open(0).read().split())
    ans = [0] * N
    for k, v in enumerate(A, 1):
        ans[v - 1] = k
    print(" ".join([str(a) for a in ans]))
    return


main()

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

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

print(*ans)

Solution (Python):
from sys import stdin
N = int(stdin.readline().rstrip())
A = sorted([(i+1, int(a)) for i, a in enumerate(stdin.readline().rstrip().split())], key=lambda t: t[1])
for t in A:
    print(t[0], end=" ")

Solution (Python):
import numpy as np
n = int(input())
a = np.array(list(map(int,input().split())))
a_sort = np.argsort(a)
ans = a_sort + 1
for i in (ans):
    print(i, end=" ")

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

print(*come_list)

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

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

print(*ans)

Solution (Python):
n = int(input())
order = [0 for _ in range(n)]
ai_list = list(map(int,input().split()))
i = 1
for ai in ai_list:
    order[ai-1] = i
    i += 1
for x in order:
    print(x,end = ' ')

Solution (Python):
from operator import itemgetter


def main():
    A = {k + 1: v for k, v in enumerate(map(int, open(0).read().split()[1:]))}
    
    print(" ".join([str(i[0]) for i in sorted(A.items(), key=itemgetter(1))]))
    return


main()

Solution (Python):
import numpy as np

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

for i in np.argsort(A) + 1:
    print(i, end=' ')

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

for i in A:
    i = [i,count]
    count += 1
    S.append(i)

S.sort()
for i,j in S:
    print(j+1,end = "")
    count -= 1
    if(count != 0):
        print(" ",end="")

Solution (Python):
def func(N, A_i):
    array = [0]*N
    for i in range(N):
        array[A_i[i]-1] = i+1
    ans = str(array[0])
    for i in range(N-1):
        ans += " " + str(array[i+1])
    return ans

N = int(input())
A_i = list(map(int, input().split(" ")))
print(func(N, A_i))

Solution (Python):
n = input()
arr = map(int, raw_input().split())
new = [0 for i in range(n)]


for i in range(n):
    new[arr[i]-1] = i+1

for k in new:
    print k,

Solution (Python):
import numpy as np

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

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

Solution (Python):
from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string


import random
def I():
    return int(input())
def MI():
    return map(int,input().split())
def LI():
    return [int(i) for i in input().split()]
def LI_():
    return [int(i)-1 for i in input().split()]
def StoI():
    return [ord(i)-97 for i in input()]
def show(*inp,end='\n'):
    if show_flg:
        print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7



show_flg=False
show_flg=True


n=I()
a=LI()
b=[]
b=[(i+1,j) for i,j in enumerate(a)]
b.sort(key=lambda x: x[1])


print(*[i for i,j in b])

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

member = list(map(int, input().split()))
ans = [0]*n

for i,num in enumerate(member):
    ans[num-1] = i+1


print(*ans)

Solution (Python):
def resolve():
    n = int(input())
    a = list(map(int, input().split()))
    b = sorted([(i, ai) for i, ai in enumerate(a)], key=lambda x: x[1])
    print(" ".join([str(i + 1) for i, _ in b]))


if __name__ == "__main__":
    resolve()

Solution (Python):
n = int(input())
a = tuple(map(int, input().split()))
b = dict((j,i + 1) for i, j in enumerate(a))
for i in sorted(a):
    print(b[i], end=' ')

Solution (Python):
from math import *

def next_int():
    return int(input())

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

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

Solution (Python):
n = int(input())
a = list(map(int, input().split(" ")))
dic = {}
i = 0
for a_s in a:
    dic.setdefault(i, a_s)
    i += 1
for k, v in sorted(dic.items(), key=lambda x: x[1]):
    print(k + 1)

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

li = [0]*n
count = 1

for i in a:
    li[i-1] = count
    count += 1

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

Solution (Python):
import numpy as np
N = int(input())
A = list(map(int, input().split()))
print(' '.join([str(one) for one in np.argsort(A)+1]))

Solution (Python):
n = int(input())
a = [[int(i), j + 1] for j, i in enumerate(input().split())]
a.sort()
t = []
for aa in a:
    t.append(str(aa[1]))
print(*t)

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

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

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

Solution (Python):
def main():
    N = int(input())
    A_l = [int(i) for i in input().split()]
    order = [-1 for _ in range(N)]

    for index, A in enumerate(A_l):
        order[A-1] = index+1
    print(" ".join([str(i) for i in order]))


if __name__ == "__main__":
    main()

Solution (Python):
if __name__ == "__main__":
    list = []
    tmp = []
    sort_list = []
    num = int(input())
    list = input().split()
    for i,v in enumerate(list):
        tmp.append([int(v),i+1])
    sort_list=sorted(tmp)
    ans = [str(i[1]) for i in sort_list ]
    print(" ".join(ans))

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

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

Solution (Python):
def resolve():
    N = input()
    targets = list(map(int,input().split()))
    ans = sorted(range(len(targets)), key=lambda k: targets[k])
    for k in ans:
        print(k+1,end=" ")
resolve()

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)

mojiretsu=" ".join(ans)
print(mojiretsu)

Solution (Python):
N = int(input())
a_list = list(map(int, input().split()))
items = []
for i in range(N):
    items.append((a_list[i], i+1))
items = sorted(items, key=lambda x:x[0])

for a in items:
    print(a[1])

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

if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):

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

B = [0]*N






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

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

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

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

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

h = []

for i in range(len(A)):
    heapq.heappush(h,(A[i],i+1))

ans = []
for i in range(len(A)):
    ans.append(heapq.heappop(h)[1])

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

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

Solution (Python):
import sys
from functools import reduce
import copy
import math
from pprint import pprint


sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def int_inputs(num_of_input):
    ins = [int(input()) for i in range(num_of_input)]
    return ins


def solve(inputs):
    A = string_to_int(inputs[0])
    order = {x: i for i, x in enumerate(A)}
    r = []
    for i in range(len(A)):
        r.append(order[i+1]+1)
    return r


def string_to_int(string):
    return list(map(int, string.split()))


if __name__ == "__main__":
    input()
    ret = solve(inputs(1))
    for i, r in enumerate(ret):
        if i == len(ret) - 1:
            print(r)
        else:
            print('{} '.format(r), end='')

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

arr = [0]*N

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

print(*arr)

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

def sort(N, A):
    l = [None] * N
    for i, v in A:
        l[v-1] = str(i)
    return l

print(' '.join(sort(N, A)))

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

def sort(N, A):
    l = [None] * N
    setitem = l.__setitem__
    for i, v in A:
        setitem(v-1, str(i))
    return l

print(' '.join(sort(N, A)))

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

res = [0] * N
for i, a in enumerate(A):
    res[a - 1] = i + 1

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

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

map = {a[i]:str(i+1) for i in range(n)}
print(" ".join(map[i] for i in range(1, n+1)))

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

map = {a[i]:str(i+1) for i in range(n)}
print(" ".join([map[i] for i in range(1, n+1)]))

Solution (Python):

n=int(input())
print(" ".join(list(map(lambda x: str(x[1]),sorted(zip(list(map(int,input().split())),range(1,n+1)),key=lambda x: x[0])))))

Solution (Python):

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

print(" ".join(list(map(lambda x: str(x[1]),sorted(zip(tem,range(1,n+1)),key=lambda x: x[0])))))

Solution (Python):

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

Solution (Python):

n=int(input())
l=[]
tem=list(map(int,input().split()))
for i in range(n):
    l.append((tem[i],i+1))
l=sorted(l,key=lambda s: s[0])
print(" ".join(list(map(lambda x: str(x[1]),l))))

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

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

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

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

Solution (Python):

n=int(input())
l=[]
tem=list(map(int,input().split()))
for i in range(n):
    l.append((tem[i],i+1))
l=sorted(l,key=lambda s: s[0])
for x in range(n):
    if x==0:
        print(l[x][1],end="")
    else:
        print(" %d"%l[x][1],end="")

Solution (Python):

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

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

Solution (Python):
n,*a=map(int,open(0).read().split());print(*[i+1for x,i in sorted([(x,i)for i,x in enumerate(a)])])

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

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20

N = int(input())
A = list(map(int,input().split()))
answers = [-1 for _ in range(N)]
for i in range(N):
    answers[A[i]-1] = i+1
print(" ".join(map(str,answers)))

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

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

Alist.sort()

A=[Alist[i][1] for i in range(N)]

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

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

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

attendees = [int(i) for i in input().split()]

numbers = []
for i, j in enumerate(attendees, 1):
    numbers.append([i, j])

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

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

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


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

a.sort()
for i in range(n):
    a[i]=a[i][1]
print(*a)

Solution (Python):
import numpy as np
n = int(input())
order =  list(map(int, input().split()))
for i in list(np.argsort(order)+1):
    print(i, end=" ")

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

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

d = {}
for i, s in zip(range(1, N + 1), A):
    d[i] = s
d_sorted = sorted(d.items(), key=lambda x: x[1])

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

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

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

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

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

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

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


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

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



for i in range(N):
  ans+=str(B[i])
  if i!=N-1:
    ans+=" "

print(ans)

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

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

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

Solution (Python):
import sys
import math
from collections import defaultdict

sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]

mod = 10**9 + 7

def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N,num):
    if N<=0:
        return [[]]*num
    elif num==1:
        return [I() for _ in range(N)]
    else:
        read_all = [tuple(II()) for _ in range(N)]
        return map(list, zip(*read_all))



from operator import itemgetter
def index_sort(A):
    return sorted(enumerate(A),key=itemgetter(1))

N = I()
A = III()

x = index_sort(A)
y = []
for i in range(N):
    y.append(x[i][0]+1)

print(*y)

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

print(*[t[1] for t in sorted(zip(A, range(1, N + 1)))])

Solution (Python):
from operator import itemgetter

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

print(*[t[0] + 1 for t in sorted(enumerate(A), key=itemgetter(1))])

Solution (Python):
N = int(input())
L = list(map(int, input().split()))
 
M = []
 
for i in range(len(L)):
    l = (L[i], i+1)
    M.append(l)
 
M = sorted(M)
 
for x in M:
    print(x[1])

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

M = []

for i in range(len(L)):
    l = (L[i], i+1)
    M.append(l)

M = sorted(M)

for x in M:
    print(x[1])

Solution (Python):


import math
import os
import sys


DEBUG = 'DEBUG' in os.environ


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


def dprint(*value, sep=' ', end='\n'):
    if DEBUG:
        print(*value, sep=sep, end=end)


def main():
    N = int(inp())
    A = [int(e) for e in inp().split()]

    S = [(a, i + 1) for i, a in enumerate(A)]
    S.sort()
    print(*[s[1] for s in S])


if __name__ == '__main__':
    main()

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

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

b=[0]*n

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

print(*b)

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

Solution (Python):
n = int(input())
ary = []
for i,j in enumerate(list(map(int,input().split()))):
    ary.append([i+1,j])
ary.sort(key=lambda l:(l[1]))
print(*[ary[i][0] for i in range(n)],sep=" ")

Solution (Python):
import numpy as np

n = int(input())
a = np.array(list(map(int, input().split())), dtype=np.int)
i = a.argsort() + 1
for sid in i:
  print(sid, end=' ')

Solution (Python):
n,*a=map(int,open(0).read().split());print(*list(zip(*sorted([[i+1,j]for i,j in enumerate(a)],key=lambda x:x[1])))[0])

Solution (Python):

def main():
    N, *A = map(int, open(0).read().split())
    ans = [0] * (N + 1)
    for i, j in enumerate(A, 1):
        ans[j] = i
    print(" ".join(map(str, ans[1:])))


if __name__ == "__main__":
    main()

Solution (Python):

def main():
    N, *A = map(int, open(0).read().split())
    ans = [0] * (N + 1)
    for i, j in enumerate(A, 1):
        ans[j] = i
    print(*ans[1:])


if __name__ == "__main__":
    main()

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






A = sorted(range(N), key = lambda i: A[i])
for i in range(N):
    print(A[i]+1, end = " ")

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

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

l = [0] * N

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

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

A = list(enumerate(A))
A.sort(key = lambda x: x[1])

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

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

sjun=dict(zip(s,jun))
ssj=sorted(sjun.items(), key=lambda x:x[1])
for i in range(n):
    print(ssj[i][0], end=' ')

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

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

for i in range(N):
    ans[i][0]=A[i]

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

ANS=sorted(ans)

ans_new=''

for i in range(N):
    ans_new+=str(ANS[i][1])
    ans_new+=' '
    
print(ans_new)

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

Solution (Python):
import heapq as hq

n = int(input())
a = list(map(int, input().split()))
b = [i for i in range(1, n+1)]
p = list(zip(a, b))

q = []
hq.heapify(q)
for i in range(len(p)):
    hq.heappush(q, p[i])

while len(q) != 0:
    print(q[0][1], end=' ')
    hq.heappop(q)

Solution (Python):
n = int(input())
a = tuple(map(int, input().split()))
b = map(lambda x: x[0], sorted(enumerate(a, 1), key=lambda x: x[1]))
print(*b)

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

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

print(' '.join(b))

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

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

ans = [0]*n

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

print(*ans)

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

student = {str(i + 1):num_list[i] for i in range(N)}


sorted_student = sorted(student.items(), key=lambda x:x[1])

result = ""
for j in range(N):
    result += sorted_student[j][0] + " "

print(result.strip())

Solution (Python):
from collections import Counter
mod = 1000000007


def inverse(a):
    return pow(a, mod - 2, mod)


def usearch(x, a):
    lft = 0
    rgt = len(a) + 1
    while rgt - lft > 1:
        mid = (rgt + lft) // 2
        if a[mid] <= x:
            lft = mid
        else:
            rgt = mid
    return lft


def update(x, y, new_value, dp):
    if 0 <= x < len(dp) and 0 <= y < len(dp):
        dp[x][y] = min(dp[x][y], new_value)

def main():
    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(str(i)  for i in b))

main()

Solution (Python):

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

anss = [0] * N
for i, a in enumerate(A):
    anss[a - 1] = i + 1
    
for ans in anss:
    print(ans)

Solution (Python):
from numpy import*;_,a=open(0);print(*argsort(int32(a.split()))+1)

Solution (Python):
from numpy import*;_,a=open(0);print(*argsort(list(map(int,a.split())))+1)

Solution (Python):
input()
print(' '.join([str(y[1]) for y in sorted([(int(x),i+1) for i, x in enumerate(input().split())])]))

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

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

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

print(' '.join(t))

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

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

res = [0] * (n+1)

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

print(*res[1:])

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


if __name__ == '__main__':
    main()

Solution (Python):

import sys
sys.setrecursionlimit(12345678)
import itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop


def main():
    n = int(input())
    al = list(map(int, input().split()))
    al = [(i, a) for i, a in enumerate(al)]
    al.sort(key=lambda a: a[1])
    al = [i + 1 for i, a in al]
    print(' '.join(map(str, al)))


if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
attends = dict(enumerate(list(map(int, input().split())), start=1))
attends_sorted = sorted(attends.items(), key=lambda x: x[1])
arr = [x[0] for x in attends_sorted]
print(*arr)

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

ans = [0]*(N+1)
for i, a in enumerate(A_list):
    ans[a] = i + 1

[print(ANS) for ANS in ans[1:]]