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

input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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

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

for i in range(N):print(str(C[i][0])+' ',end="")

Solution (Python):
n = int(input())
men = enumerate(list(map(int,input().split())))
ans = []
for index, item in enumerate(sorted(men,key=lambda x: x[1])):
    if index < n-1:
        print(item[0]+1, end=" ")
    else:
        print(item[0]+1)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
H = [[0] * 2 for i in range(N)]
for i in range(N):
    H[i][0] = i+1
    H[i][1] = A[i]
H.sort(key=lambda x:x[1])
ans = [0]*N
for i in range(N):
    ans[i] = H[i][0]
print(' '.join(map(str, ans)))

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

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

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

s = [0] * n

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

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

Solution (Python):
n = int(input())
src = list(map(int, input().split()))
ma = {}
for i,s in enumerate(src):
    ma[s-1] = i+1
print(*(list(ma.values())))

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

for i in range(len(A)):
    r = A[i] - 1
    R[r] = str(i + 1)


print(" ".join(R))

Solution (Python):


def main():
    N = int(input())
    A = map(int, input().split())
    X = list(map(lambda a: a[1],
                 sorted((int(a), i+1) for i, a in enumerate(A))))

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




if __name__ == '__main__':
    main()

Solution (Python):
import sys
def input() -> str:
    return sys.stdin.readline()
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()))
A2=[0 for j in range(N)]
for i in range(N):
  A2[A[i]-1]=i+1
print(' '.join(str(n) for n in A2))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
dict_ = {i: a for i, a in enumerate(A)}
list_ = []
for k, v in sorted(dict_.items(), key=lambda x: x[1]):
    list_.append(str(k+1))
str_ = ' '.join(list_)
print(str_)

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

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

A_sorted = sorted(A_dict.items(), key=lambda x:x[1])
a = []
for i in A_sorted:
    a.append(int(i[0]))

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

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

result = [None] * N
for i in range(1, N + 1):
    index = a_list[i - 1]
    result[index - 1] = i
print(" ".join(map(str, result)))

Solution (Python):
from operator import itemgetter
n = int(input())
a = list(map(int,input().split()))
b=[]
for i in range(n):
    b.append([i,a[i]])
c = sorted(b, key=itemgetter(1), reverse=False)
d=[]
for i in range(n):
    d.append((str(c[i][0]+1)))
print(" ".join(d))

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

for an, a in enumerate(al):
  dic[a] = an + 1
  
ans = ''

for ns in range(n):
  ans += str(dic[ns+1]) + ' '
  
print(ans.strip())

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

arg = np.argsort(A_list)
for i in arg:
  print(i+1)

Solution (Python):
N = int(input())
students = sorted([(int(j), i+1) for i, j in enumerate(input().split())], key=lambda t: t[0])

print(*[s[1] for s in students])

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

Solution (Python):
N = int(input())
ans = [0]*N
A = [int(n) for n in input().split()]
for i,student in enumerate(A):
    ans[student-1] = i+1
for chat in ans:
    print(str(chat)+" ",end="")

Solution (Python):
from heapq import heappush, heappop

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

order = []

for i, s in enumerate(students):
  heappush(order, (s, i))

print(*[heappop(order)[1] + 1 for x in range(n)])

Solution (Python):

import numpy as np
N = int(input())
lst = list(map(int,input().split()))
a_2d = np.array(lst)
ans = np.argsort(a_2d, axis=0)
a = []
for i in ans:
    a.append(str(i+1))
print(" ".join(a))

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

dic = {}
for i in range(N):
    dic[i] = A[i]
dic_swap = {v: k for k, v in dic.items()}
dic_swap_sorted = sorted(dic_swap.items())

order = []
for tap in dic_swap_sorted:
    order.append(tap[1] + 1)

print(*order)

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

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

Solution (Python):
N = int(input())
a_list = list(map(int, input().split()))
dic = {}
for i in range(N):
    dic[i+1] = a_list[i]
dic_sorted = sorted(dic.items(), key=lambda x: x[1])
ans = " ".join(["{0}".format(key) for (key, value) in dic_sorted])
print(ans)

Solution (Python):
from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac
import bisect
import sys
import logging
import heapq
logging.basicConfig(level=logging.DEBUG)

input = sys.stdin.readline

setrecursionlimit(1000000)

MOD = 10**9+7

def __lt__(self, other):
    return self[0] < other[0]

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

    ans=[]
    heapq.heapify(ans)
    for i in range(len(A)):
        t=(A[i], i+1)
        heapq.heappush(ans, t)
    
    while ans:
        a = heapq.heappop(ans)
        print(a[1]) 
main()

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

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

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

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

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

Solution (Python):
from collections import defaultdict
from collections import deque
from string import ascii_uppercase
import sys, bisect, math, heapq

stdin = sys.stdin
read_int = lambda : list(map(int,stdin.readline().split()))
read_str = lambda : stdin.readline().rstrip()

N = read_int()[0]
A = read_int()
A2d = [[A[i], i + 1] for i in range(N)]

def solve():
    ans = 0
    A2d.sort(key=lambda x: x[0], reverse=False)
    
    return

if __name__ == "__main__":
    solve()
    for a in A2d:
        print(a[1], end=" ")
    print()

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

dict = {}
for i in range(n):
  dict[a[i]] = i+1
  
for i in range(n):
  print(dict[i+1], end = " ")

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

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

for i in range(N):
    B[i].append(i+1)

B.sort()

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

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

Solution (Python):
import sys
input = sys.stdin.readline
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(v) for v in input().split(' ')]
sorted_index = [str(v + 1) for v in sorted(range(len(A)), key=lambda i: A[i])]

print(" ".join(sorted_index))

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()))
info = []
for k in range(N):
    info.append([a[k], int(k+1)])
info = sorted(info, key=lambda x: x[0])
for i in range(N):
    print(info[i][1], end=" ")

Solution (Python):


import sys

debug = False

def log(text):
    if debug:
        print(text)

def parse_input(lines_as_string = None):

    global debug
    lines = []
    if lines_as_string is None:
        debug = False


        lines.append(input())
        lines.append(input())
    else:
        debug = True
        lines = [e for e in lines_as_string.split("\n")][1:-1]

    n = [int(e) for e in lines[0].split(" ")]

    a = [int(e) for e in lines[1].split(" ")]

    return (n, a)


def solve(n, a):


    b = [(i+1, e) for i, e in enumerate(a)]

    b.sort(key=lambda e: e[1])

    c = [e[0] for e in b]

    return c


def main():
    
    result = solve(*parse_input())
    if isinstance(result, list):
        for r in result:
            print("%s" % r, end=' ')
    else:
        print("%s" % result)

if __name__ == '__main__':

    main()

Solution (Python):
def main():
    n = int(input())
    a = list(map(int, input().split()))
    ans = []
    a = {i: k for i, k in enumerate(a, start=1)}
    a = sorted(a.items(), key=lambda a: a[1])
    for i in a:
        ans.append(i[0])

    print(*ans)


if __name__ == "__main__":
    main()

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

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

import copy

ans_num = copy.deepcopy(nums)

for i in range(n):
    f_n = nums[i]
    ans_num[f_n -1] = i +1
    
map(str,ans_num)
print(' '.join(map(str,ans_num)))

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

Solution (Python):


def main():
    N = int(input())
    num_to_order = [0 for _ in range(N)]

    for student_no, come_order in enumerate(input().split()):
        num_to_order[int(come_order)-1] = str(student_no + 1)
    
    print(' '.join(num_to_order))

main()

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

if __name__ == '__main__':
    main()

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

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

l = []
for i, a in enumerate(al, start=1):
  l.append((str(i), a))
print(" ".join([i[0] for i in sorted(l, lambda x: x[1])]))

Solution (Python):
def solve_c(n, a_list):
    res_list = [0] * n
    for i in range(n):
        res_list[a_list[i] - 1] = i + 1
    return res_list


def main():
    n = int(input())
    a_list = list(map(int, input().split()))
    res_list = solve_c(n, a_list)
    print(" ".join([str(r) for r in res_list]))


if __name__ == "__main__":
    main()

Solution (Python):
N=int(input())
keys=[i for i in range(1,N+1)]
values=list(map(int,input().split()))
dic=dict(zip(keys, values)) 
a=[k for k, v in sorted(dic.items(), key=lambda x:x[1])]
print(" ".join(repr(e) for e in a))

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

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

print(*B)

Solution (Python):
N = int(input())
a = list(map(int, input().split()))
dic = {}
for i in range(N):
    dic[i+1] = 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()))
d = {}
for i in range(n):
  d[a[i]] = i
print(" ".join([str(d[key] + 1) for key in sorted(d.keys())]))

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


for k in range(N):
    print(ans[k], end = " ")

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

Solution (Python):
import sys

N=int(sys.stdin.readline().rstrip())
AList=list(map(int,sys.stdin.readline().split()))

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

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

print(b[1],end="")
for i in range(2,n+1):
  print(' ' + str(b[i]) ,end="")
print("")

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

a = []
for i, num in enumerate(A):
    a.append((i+1, num))

a = sorted(a, key=lambda a: a[1])
ans = []
for i in range(N):
    ans.append(a[i][0])
print(*ans)

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

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

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

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

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

new_list = []

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

new_list = sorted(new_list)

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

Solution (Python):

import numpy as np
def main():
    N = int(input())
    A = list(map(int,input().split()))
    An = np.argsort(A)
    for i in An:
        print(i+1,end = " ")

if __name__ == '__main__':
    main()

Solution (Python):


    


if __name__ == "__main__":
    Input1 = [input() for i in range(2)]
    N = int(Input1[0])
    A = list(map(int,Input1[1].split()))

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

Solution (Python):
import numpy as np

if __name__ == '__main__':
    N = int(input())
    a = list(map(int, input().split()))

    s = ' '.join(list(map(str, np.argsort(a) + 1)))
    print(s)

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())
inputs = input().split()
a = [int(s) for s in inputs]

ans = [0]*n

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

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

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

tmp = []

for i, num in enumerate(inp, 1):
    tmp.append(list((i,num)))

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

ans = []
for i in range(n):
    ans.append(str(tmp[i][0]))
    
print(" ".join(ans))

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

answer = [0] * N
temp = []

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

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

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

Solution (Python):
N=int(input())
A=[[int(x)] for x in input().split()]
i=1
for a in A:
    a.append(i)
    i+=1
A.sort()
print(*[a[1] for a in A])

Solution (Python):
import sys,queue,copy
sys.setrecursionlimit(10**8)
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

N = int(input())
A = inpl()
Adic = {}
for i in range(1,N+1):
    Adic[i] = A[i-1]

Adic_sorted = sorted(Adic.items(), key=lambda x:x[1])

anslist=list()
for a,b in Adic_sorted:
    anslist.append(str(a))

print(" ".join(anslist))

Solution (Python):
import numpy as np

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

correct = np.zeros(N)

for i in range(N):
    correct[int(H[i]) - 1] = i + 1

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

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

Solution (Python):
import sys
import numpy as np
def main():
    input = sys.stdin.readline
    N = int(input())
    As = list(map(int, input().split()))
    ans = " ".join(list((np.argsort(As)+1).astype("str")))
    print(ans)

if __name__ == '__main__':
    main()

Solution (Python):


N = int(input())
keys = [_ + 1 for _ in range(N)]
values = list(map(int,input().split()))
dct = dict(zip(keys, values))
prt = []
for k, v in sorted(dct.items(), key=lambda x: x[1]):
    prt.append(str(k))

for i in range(len(prt)):
    if i != len(prt) - 1:
        print(int(prt[i]), end = " ")
    else:
        print(int(prt[i]))

Solution (Python):
import sys


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


def main():
    N = int(input())
    nums = map(int, input().split())
    ans = sorted(zip(nums, range(1, N+1)))
    print(*map(lambda x: x[1], ans), sep=' ')


if __name__ == "__main__":
    main()

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

print(*sorted(range(1, N+1), key=lambda x: A[x-1]))

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

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


A_NUM = list(enumerate(A, start=1))

A_NUM.sort(key=lambda n:n[1])

ret = [a[0] for a in A_NUM]
print(" ".join(map(str, ret)))

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

idx = sorted(range(1,N+1), key=lambda x:A[x-1])
print(*idx)

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

Solution (Python):

n = int(input())

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

xn = [(i,a) for i,a in enumerate(an)]



xn.sort(key=lambda a:a[1] )

for i, x in xn:
    print(i+1, end=' ' if x !=n else '\n')

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

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

ans = [0] * n

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

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

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

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

ans = [0] * n

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

print(" ".join([str(s) for s in ans]))

Solution (Python):


''' 
------------------------
author : iiou16
------------------------
'''

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

    s = {}
    for i in range(N):
        s[A[i]-1] = i
    
    out = ""
    for j in range(N):
        out += str(s[j]+1)
        out += " "
    print(out[:-1])

if __name__ == '__main__':
    main()

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

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

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

li2 = []
for i in range(n):
    li2.append([li[i],i+1])
li2.sort()

for i in range(len(li2)):
    print(li2[i][1],end = " ")

Solution (Python):

import sys
input = sys.stdin.readline


def get_key(item):
    return item[1]

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

    for (k, v) in enumerate(A):
        B.append((k,v))

    B = sorted(B, key=get_key)
    B = [i[0]+1 for i in B]

    print(*B)


if __name__ == '__main__':
    main()

Solution (Python):
import heapq
N = int(input())
idx_list = [0] * N
Hn = list(map(int,input().split(' ')))
for i in range(N):
    number = Hn[i]
    idx_list[number -1] = i +1
print(' '.join(map(str,idx_list)))

Solution (Python):
N = int(input())
As = [int(x) for x in input().split()]
rs = list(range(1,N+1))
for i,A in enumerate(As):
    rs[A-1] =i+1

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

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

ans = list(map(lambda p: str(p[1]), sorted([(a[i], i + 1) for i in range(n)])))
print(' '.join(ans))

Solution (Python):


a = int(input())
s = input().split()

b = []

for item in s:
    b.append(int(item))

my_dict = dict()

for i in range(len(b)):
    my_dict[b[i]] = i+1

out = []
for i in range(len(b)):
    out.append(str(my_dict[i+1]))

print(" ".join(out))

Solution (Python):
import numpy as np

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

C = np.argsort(A) + 1

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

Solution (Python):
import sys
readline = sys.stdin.readline
N = int(readline())
a = list(map(int, readline().split()))

aa = []
for i in range(N):
    tmp = [a[i], i]
    aa.append(tmp)

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

aaa = []
for i in range(N):
    aaa.append(str(aa[i][1] + 1))

print(' '.join(aaa))

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()))
mydic ={}
for i in range(n):
	mydic[a[i]] = i+1
sortedDict = sorted(mydic.items())
s =[]
for j in range(n):
    s.append(str(sortedDict[j][1]))
print(" ".join(s))

Solution (Python):



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

ret = [ -1 for x in range(len(arr_a)) ]
for i in range(len(arr_a)):
    ret[arr_a[i]-1] = i+1

print(" ".join([ "{0:d}".format(x) for x in ret ]))

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

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

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

Solution (Python):
R = lambda: map(int, input().split())
n, = R()
a = list(R())
print(*sorted(range(1, n + 1), key=lambda x: a[x - 1]))

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

B=[0]*len(A)

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

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

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=list(range(1,int(input())+1))
a=list(map(int,input().split()))
na=[list(x) for x in zip(*sorted(zip(a, n)))]
asdf=""
for i in na[1]:
  asdf+=str(i)+" "
print(asdf[:-1])

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

b = []
for i,k in enumerate(a):
	b.append([k,i])
b.sort()
for i in range(n-1):
	print("%d " % (b[i][1]+1),end="")
print("%d" % (b[n-1][1]+1))

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

ans=[]
for i,a in enumerate(A):
  ans.append([i+1,a])
ans.sort(key=lambda x:x[1])
for a in ans:
  print(a[0],end=' ')

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

a_list = list(map(int,input().split()))
a_n_list = []
for i in range(N):
    a_n_list.append([a_list[i],i+1])
a_n_list.sort()
ans = ""
for i in range(N):
    print(a_n_list[i][1], end=" ")

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

AA = []

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

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

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

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

import numpy as np
print(' '.join(map(str, np.array(A).argsort() + 1)))

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

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
D = dict()
for i in range(N):
    D[A[i]] = (i+1)
ans = []
for i in range(N):
    ans.append(D[i+1])
d = []
for i in range(N):
    d.append(str(ans[i]))
result = ' '.join(d)
print(result)

Solution (Python):
from heapq import heappush, heappop

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

q = list()
for i, num in enumerate(A):
    heappush(q, (num, i + 1))

ans = list()
while len(q) > 0:
    _, num = heappop(q)
    ans.append(num)

print(' '.join([str(x) for x in ans]))

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
li = list(map(int,stdin.readline().rstrip().split()))
li2 = [0 for _ in range(n)]
for i in range(len(li)):
    li2[li[i]-1] = i+1
print(' '.join(map(str, li2)))

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

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

m = {}
for i in range(n):
  m[a[i] - 1] = i + 1

b = []
for i in range(n):
  b.append(str(m[i]))

print(" ".join(b))

Solution (Python):
n = int(input())
a = [int(x) for x in input().split()]
b = []
for i in range(n):
    b.append([a[i], i+1])
b.sort()
for x in b[:-1]:
    print(x[1], end=' ')
print(b[n-1][1])

Solution (Python):
import sys
stdin = sys.stdin
mod = 10**9 + 7

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
sa = lambda h: [list(map(int, stdin.readline().split())) for i in range(h)]

n = ni()
a = na()
b = range(n)


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

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

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

h = sorted(h.items(), key = lambda x: x[0])

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

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

Solution (Python):
N=int(input())
l1=list(map(int,input().split()))
l2=[0]*N
for i,j in enumerate(l1):
  l2[j-1]=str(i+1)
print(' '.join(l2))

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import heapq

def main():
    n = int(input())
    ans = [0] * n
    for i, a in enumerate(input().split(' ')):
        ans[int(a)-1] = str(i+1)
    print(' '.join(ans))



if __name__ == '__main__':
    main()

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

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
ans = [0]*N
dic = {}

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

print(' '.join(ans))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
s = []
for i, ai in enumerate(a):
    s.append((ai, i + 1))
s = sorted(s, key=lambda x: x[0])
print(*(si[1] for si in s))

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

B = [0] * N
ans = ''
for i, num in enumerate(A):
    B[num-1] = i + 1
print(' '.join(map(str, B)))

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_N = list(map(int, input().split()))

print(' '.join([str(i[0]+1) for i in sorted(enumerate(A_N), key=lambda x: x[1])]))

Solution (Python):


import numpy as np


def solve(N, A):
    return np.array(A).argsort() + 1


if __name__ == '__main__':
    N = int(input())
    A = list(map(int, input().split()))

    ans = solve(N, A)

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

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

B = (sorted(range(len(A)), key=lambda k: A[k]))

for i in B:
    print(i+1,end=" ")
print("")

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

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
e = [(v, i+1) for i, v in enumerate(a)]
e.sort()
for i,v in e:
    print(v,end=' ')

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

dic = {}
for i in range(N) :
    dic[i+1] = A_list[i]

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

s = ""
for item in dic :
    s += str(item[0]) + " "
s += "\r\n"
print(s)

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

ans = sorted(ans)
_ans = [x for (_a, x) in ans]
print(' '.join(map(str, _ans)))

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

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

pairs.sort()
print(" ".join([str(x[1]) for x in pairs]))

Solution (Python):
n=int(input())
h=[int(i) for i in input().split()]
a=[[h[i-1],i] for i in range(1,n+1)]
a.sort()
b=[a[i][1] for i in range(n)]
print(*b)

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

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

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