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

alist =[]
for i in range(n):
    alist.append([i,a[i]])

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

for i in range(n):
    ans = alist[i][0]+1
    print(ans)

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

ans = [0] * n

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

print(" ".join(ans))

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

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

if __name__ == '__main__':
    main()

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

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], end=' ')

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

c = list(zip(a, order))
c.sort()
a, b = zip(*c)
print(*b)

Solution (Python):
def answer():
    N = int(input())
    nums = list(map(int, input().split()))
    order = [0] * N

    for i, num in enumerate(nums):
        order[num - 1] = i + 1

    print(*order)


if __name__ == '__main__':
    answer()

Solution (Python):
n = int(input())
lst = [int(i) for i in map(int, input().split())]
set = []

for i in range(n):
    set += [(lst[i],i+1)]
set.sort()
for i in range(n):
    print(set[i][1],end=" ")

Solution (Python):
def main():
    n, *a = map(int, open(0).read().split())
    a, o = sorted([(a, i) for i, a in enumerate(a)]), []
    for i in range(n):
        o.append(a[i][1]+1)
    print(*o)

if __name__ == "__main__":
    main()

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

AA = []
for i in range(len(A)):
  AA.append([A[i],i+1])
AA.sort()
ANS = []
for a1,a2 in AA:
  ANS.append(a2)
print(*ANS)

Solution (Python):

n=int(input())
a=list(map(int,input().split()))
b=[]
for i in range(n):
    b.append([a[i],i+1])
b.sort()
c=[]
for i in range(n):
    c.append(b[i][1])
print(*c)

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

Solution (Python):

n = int(input())
student = list(map(int,input().split()))
toukou = [0] * n

for i in range(n):
    
    toukou[student[i]-1] = i+1
print(" ".join(map(str,toukou)))

Solution (Python):
from sys import stdin

n = int(input())
a = [int(x) for x in stdin.readline().split()]

p = zip(a, range(1, n+1))
print(*[i for a, i in sorted(p)])

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = [None]*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()))
st = []
ans = []
for i in range(n):
    st.append([A[i], i+1])
st.sort()
for s in st:
    ans.append(s[1])
print(*ans)

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

junban = [0 for _ in range(N+1)]

for k, v in enumerate(map(int, input().split())):
    junban[v] = str(k+1)

print(" ".join(junban[1:]))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
s = [(a, i+1) for i, a in enumerate(A)]
s.sort()
print(" ".join(list(map(lambda x: str(x[1]), s))))

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

def main():
    N = int(input())
    AList = list(map(int, input().split()))
    ABList = [[] for _ in range(N)]
    for i in range(N):
        a = AList[i]
        ABList[i] = [a, i+1]
    ABList = sorted(ABList, key=itemgetter(0))
    for i in ABList:
        print(i[1], end=' ')
    print()

if __name__ == '__main__': main()

Solution (Python):
from sys import stdin

def main():
    input = lambda: stdin.readline()[:-1]
    N = int(input())
    A = map(int, input().split())

    num = [(a, i) for i, a in enumerate(A, start=1)]
    num.sort()
    ans = [a for _, a in num]
    print(*ans)

main()

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
    
print(' '.join(map(str,ans)))

Solution (Python):


def main():
    N = int(input())
    A = list(map(int, input().split()))
    a = [(v, i + 1) for i, v in enumerate(A)]
    a = sorted(a, key=lambda x: x[0])
    a = [i[1] for i in a]
    print(*a)


if __name__ == '__main__':
    main()

Solution (Python):
import sys

lines = sys.stdin.readlines()
n = int(lines[0])
arr = list(map(int, lines[1].split()))
arr_with_index = []
for idx, val in enumerate(arr):
    arr_with_index.append((val, idx))
arr_with_index.sort()
sorted_arr = map(lambda t: str(t[1] + 1), arr_with_index)
print(' '.join(sorted_arr))

Solution (Python):
import sys
from collections import defaultdict, deque
from functools import reduce
import math

input = sys.stdin.readline


def main():
    N = int(input())
    A = list(map(int, input().split()))
    order_list = [0] * N
    for i in range(N):
        order_list[A[i]-1] = i + 1
    print(' '.join(map(str, order_list)))

if __name__ == '__main__':
    main()

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

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

lista.sort(key= lambda x : x[1])
for i in range(N):
    print(lista[i][0] + 1, end= " ")

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    a_list = list(map(int,input().split()))

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

    answer = ""
    for i in range(n):
        if i != 0:
            answer += " "
        answer += str(d[str(i+1)])

    print(answer)

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

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

for x in l:
    print(x + 1, end = ' ')

Solution (Python):
import numpy as np

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

a_ = np.argsort(a) + 1
for i in range(n):
  print(a_[i],end=" ")

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

dic = {}
for id,num in enumerate(A):
  dic[num] = id + 1

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

Solution (Python):
N = int(input())
A = list(map(int , input().split()))
lst = []
for idx , a in enumerate(A):
    lst.append([a,idx])
lst.sort()
for value in lst:
    print(value[1] + 1 , end = ' ')

Solution (Python):
n=int(input())
A=[int(i) for i in input().split()]
C=[(A[i-1],i) for i in range(1,n+1)]

C.sort()
ans=[]

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

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

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

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

str_list = input().split(' ')
A_list = [int(x) for x in str_list]

import numpy as np
A = np.array(A_list)

arg = np.argsort(A)
arg += 1

for ii in range(N):
    if ii < N-1:
        print('%s ' % arg[ii], end='')
    else:
        print(arg[ii])

Solution (Python):


N = int(input())
row = [0 for i in range(N)]
row2 = [int(x) for x in input().split(" ")]

for i in range(N):
    row[row2[i] - 1] = i + 1

for i, x in enumerate(row):
    if i < N - 1:
        print(x, end=" ")
    else:
        print(x)

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

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


da={}
for i in range(N):
    da[la[i]]=i
la.sort()
for i in range(N):
    print(da[la[i]]+1,end=" ")
print()

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

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

a = np.array(list(map(int, input().strip().split())))
b = np.argsort(a)

for i in range(len(b)):
    if i >= len(b)-1:
        print(b[i]+1)
    else:
        print(b[i]+1,end=' ')

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

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

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

for i in range(n):
    lq[la[i]-1] = str(i+1)

print(" ".join(lq))

Solution (Python):

n = int(input())
a = list(map(int, input().split()))
b = [(a[i], i) for i in range(n)]
b.sort(key = lambda x: x[0])
c = [b[i][1]+1 for i in range(n)]
print(*c)

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

ret = sorted(enumerate(h), key=lambda x:x[1])
for i,j in ret:
    print(i+1, end=' ')

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

Solution (Python):
N = int(input())
h = [int(x) for x in input().split()]
t= [0]*N
for i in range(1,N+1):
  t[h[i-1]-1]=i
print(*t)

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

B = [[i,A[i]] for i in range(N)]
B.sort(key=lambda x: x[1])
C = [B[i][0]+1 for i in range(N)]
print(*C)

Solution (Python):
n = int(input())
l = list(map(int, input().split()))
ll = [0 for i in range(n)]

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

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

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

ans = []
A = sorted(A, key=lambda x:x[1])
for i in range(n):
    ans.append(str(A[i][0]+1))
print(" ".join(ans))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
a_b = []
for i in range(n):
    a_b.append([a[i], i + 1])
a_b.sort(key=lambda x: (x[0]))

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

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

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

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

a.sort()

print(*[a[i][1] for i in range(n)])

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

Solution (Python):

import sys
input = sys.stdin.readline

n = int(input())

ai = list(map(int, input().split()))
dic = {}
for i in range(1, n + 1):
    dic[ai[i-1]] = i

ans = sorted(dic.items())


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

Solution (Python):
from operator import itemgetter

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

x = [(A[i - 1], i) for i in range(1, N + 1)]
x.sort(key=itemgetter(0))
y = [t[1] for t in x]
print(*y)

Solution (Python):
import math
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):
    if i != N - 1:
        print(B[i], end = " ")
    else:
        print(B[i])

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

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

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

D = {(i+1):a for i,a in enumerate(A)}


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

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

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

print(" ".join(newA))

Solution (Python):
import sys

N=input()
A=map(int, sys.stdin.readline().split())

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

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

for x,y in L:
	print y,

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

def main():
    N = int(input())
    A = [int(x) for x in input().split()]
    B = []
    for i in range(1, N + 1):
        B.append([A[i - 1], i])

    B_sorted = sorted(B, key=itemgetter(0))

    for x in B_sorted:
        print(x[1], end=" ")
    

if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
tmp=[-1 for _ in range(N)]
for ind,i in enumerate(A):
    tmp[i-1]=ind+1
ans=list(map(str,tmp))
print(" ".join(ans))

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

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

Solution (Python):
import sys
from io import StringIO
import unittest

class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)
    def test_入力例_1(self):
        input = """3
2 3 1"""
        output = """3 1 2"""
        self.assertIO(input, output)
    def test_入力例_2(self):
        input = """5
1 2 3 4 5"""
        output = """1 2 3 4 5"""
        self.assertIO(input, output)
    def test_入力例_3(self):
        input = """8
8 2 7 3 4 5 6 1"""
        output = """8 2 4 5 6 7 3 1"""
        self.assertIO(input, output)
def resolve():
    N=int(input())
    A=[int(i) for i in input().split()]
    B=[[A[i],i+1] for i in range(N)]

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

    C=[str(i[1]) for i in B]
    print(" ".join(C))


if __name__ == "__main__":
    resolve()

Solution (Python):

import string
import sys
from itertools import chain, dropwhile, takewhile

INF = float("inf")


def read(
    *shape, f=int, it=chain.from_iterable(sys.stdin), whitespaces=set(string.whitespace)
):
    def read_word():
        w = lambda c: c in whitespaces
        nw = lambda c: c not in whitespaces
        return f("".join(takewhile(nw, dropwhile(w, it))))

    if not shape:
        return read_word()
    elif len(shape) == 1:
        return [read_word() for _ in range(shape[0])]
    elif len(shape) == 2:
        return [[read_word() for _ in range(shape[1])] for _ in range(shape[0])]


def readi(*shape):
    return read(*shape)


def readi1(*shape):
    return [i - 1 for i in readi(*shape)]


def readf(*shape):
    return read(*shape, f=float)


def reads(*shape):
    return read(*shape, f=str)


def arr(*shape, fill_value=0):
    if len(shape) == 1:
        return [fill_value] * shape[0]
    elif len(shape) == 2:
        return [[fill_value] * shape[1] for _ in range(shape[0])]


def dbg(**kwargs):
    print(
        ", ".join("{} = {}".format(k, repr(v)) for k, v in kwargs.items()),
        file=sys.stderr,
    )


def main():
    N = readi()
    A = readi(N)
    print(
        " ".join(str(i) for i, _ in sorted(enumerate(A, start=1), key=lambda p: p[1]))
    )


if __name__ == "__main__":
    main()

Solution (Python):
def argsort(seq):
    return sorted(range(len(seq)), key=seq.__getitem__)

def read():
    N = int(input().strip())
    A = list(map(int, input().strip().split()))
    return N, A

def solve(N, A):
    keys = argsort(A)
    keys = [k+1 for k in keys]
    return ' '.join(list(map(str, keys)))

if __name__ == '__main__':
    inputs = read()
    print("%s" % solve(*inputs))

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

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

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

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

ans_list = []
for i in range(len(ans_dict)):
    ans_list.append(ans_dict[i][0])

hoge = map(str, ans_list)
ans = " ".join(hoge)
print(ans[:len(ans)])

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

res = [-1]*(n+1)
for _i, _a in zip(range(n), a):
    res[_a] = str(_i+1)
        
print(' '.join(res[1:]))

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

Solution (Python):
N = int(input())
A = map(int, input().split())
iA= list(enumerate(A, start=1))
iA.sort(key=lambda x: x[1])
print(' '.join([str(x[0]) for x in iA]))

Solution (Python):
def main():
    N = int(input())
    A = [int(i) for i in input().split()]
    B = [0 for i in range(N)]
    for i in range(N):
        B[A[i]-1] = i + 1
    for i in range(N):
        print(B[i],end = " ")
    print()

if __name__ == "__main__":
    main()

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

Solution (Python):


n=int(input())
a=list(map(int,input().split()))
res=[]
for i,e in enumerate(a,1):
    res.append((i,e))

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

for e in res:
    print(e[0],end=' ')
print()

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

import numpy as np
a = np.array(a)
a_sort = np.argsort(a)
a_sort = a_sort + 1

print(*a_sort)

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

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

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

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

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

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

print(" ".join(m))

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

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

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

B.sort(key=lambda x: x[0])
print(' '.join([str(x[1]) for x in B]))

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

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

ans.sort()

fa = [ans[i][1] for i in range(n)]
print(' '.join(map(str, fa)))

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

for i,x in enumerate(a):
    l[x-1] = i+1

ans = list(map(str, l))
print(" ".join(ans))

Solution (Python):
if __name__ == '__main__':
    N = int(input())
    A = list(map(int, input().split()))
    A = sorted([(i + 1, a) for i, a in enumerate(A)], key=lambda x: x[1])
    for i, a in A:
        print(i, end=" ")
    print()

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

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

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

C = []
for b in B:
    C.append(b[0])

print(*C)

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

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

Solution (Python):
import numpy as np
import math
import sys
sys.setrecursionlimit(10000000)

def main():
    N = int(input())
    A = [int(c) for c in input().split()]
    B = [0] * (N + 1)

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

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



if __name__ == '__main__':
    main()

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

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
G = {i:A[i-1] for i in range(1,N+1)}
B = list(G.items())
B = sorted(B,key=lambda x:x[1])
C = [B[i][0] for i in range(len(B))]
print(*C)

Solution (Python):
n = int(input())
h_list = input().split()
h_list = [int(one) for one in h_list]

st_dict = dict()

for i,one in enumerate(h_list):
    st_dict[i+1] = one

tmp = sorted(list(st_dict.items()),key=lambda x:x[1])

out_str = ""
for one in tmp:
    out_str += "{} ".format(one[0])
print(out_str[:-1])

Solution (Python):
import math
import queue
import bisect
import heapq

mod = 1e9+7

def swap(a,b):
    return (b,a)

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

def divisors(a):
    divisors = []
    for i in range(1,int(a**0.5)+1):
        if a%i==0:
            divisors.append(i)
            if i!=a//i:
                divisors.append(a//i)
    return divisors

def main():
    n = int(input())
    a = [x for x in map(int,input().split())]
    A = []
    for i in range(1,n+1):
        A.append([a[i-1],i])
    A.sort()
    for i in range(n):
        print(A[i][1])
    return

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    n=int(input())
    a=list(map(int,input().split(' ')))
    t=[0]*n
    for n,i in enumerate(a):
        t[i-1]=n+1
    for i in t:
        print(i,'',end="")
if __name__ == '__main__':
    main()

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

for i,j in l:
  print(j,end=" ")

Solution (Python):
import sys
from heapq import heappush, heappop

def main():
    input = sys.stdin.readline
    N = int(input())
    A = list(map(int, input().split()))
    heap = []
    for i, a in enumerate(A, start=1):
        heappush(heap, (a, i))
    
    ans = []
    while heap:
        _, a = heappop(heap)
        ans.append(a)

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

if __name__ == '__main__':
    main()

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

B = []
for idx, val in enumerate(A):
    B.append((val, idx+1))
B = sorted(B)


for i in range(len(B)):
    if i < N - 1:
        print(B[i][1], end=" ")
    else:
        print(B[i][1])

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

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

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

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 sys
from bisect import *
from collections import *
from copy import deepcopy
from heapq import *
from itertools import *
from math import *
from operator import *
from pprint import *

sys.setrecursionlimit(10**8)

input = sys.stdin.readline

def main():
    """ main """
    N = int(input())
    AS = list(map(int, input().split()))
    ans = []
    for i in range(N):
        ans.append((AS[i],i+1))
    ans.sort()
    ans2 = []
    for a,b in ans:
        ans2.append(b)
    print(*ans2)

if __name__ == '__main__':
    main()

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

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

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

for i,a in C:
	print(i, end=' ')

print()

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

B = [(a, i+1) for i, a in enumerate(A)]
B = list(sorted(B))

ans = []
for _, i in B:
    ans.append(str(i))
print(' '.join(ans))

Solution (Python):

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

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

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

def list_print(A):
	length = len(A)
	for i in range(length - 1):
		print(A[i], end="")
		print(" ", end="")
	print(A[- 1])

list_print(s_list)

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = False
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]

    N = II()
    A = LMIIS()
    for i in range(N):
        A[i] = [A[i],i]
    A.sort()


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

        

if __name__ == '__main__':
    main()

Solution (Python):













N = int(input())
As = [int(i) for i in input().split(" ")]
for i in [i + 1 for i, j in sorted(enumerate(As), key=lambda x: x[1])]:
  print(i)

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

b = {}
for i, aa in enumerate(a):
    b[aa] = i + 1
b = sorted(b.items())
ans = ''
for k, v in b:
    if ans != '':
        ans += ' '
    ans += str(v)
print(ans)

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
n=int(input())
aa=map(int,input().split())
indexed=sorted(list(zip(range(1,n+1),aa)), key=lambda x: x[1])
print(' '.join(str(x[0]) for x in indexed))

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

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

lss=[]
for idx,seito in enumerate(ls):
    lss.append([seito,idx+1])
lsss=sorted(lss)
mapped_list = list(map(lambda x: x[1], lsss))
print(" ".join(list(map(str,mapped_list))))

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

tlist=[]
for i in range(N):
    tlist.append([A[i],i])
tlist.sort()

tmp=[]
for i in range(N):
    tmp.append(str(tlist[i][1]+1) )
print(' '.join(tmp))

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

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

r=list(zip(a,[i+1 for i in range(N)]))
x=sorted(r)

initFlag=False
for it in x:
    if initFlag==False:
        initFlag=True
    else:
        print(" ",end="")
    
    print(it[1],end="")
print()

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

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

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

Solution (Python):


import sys


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

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


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



print(*b)

Solution (Python):


import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N = INT()
A = []
A.append(LIST())
A.append(list(range(N)))

A = list(zip(*A))
A.sort()
A = list(zip(*A))
A[1] = [a+1 for a in A[1]]

print(*A[1])

Solution (Python):
import sys


def main():
    n = int(sys.stdin.readline().strip())
    a = [int(s) for s in sys.stdin.readline().strip().split()]

    tuples = []
    for i in range(n):
        ai = a[i]
        tuples.append((ai, i+1))
    tuples.sort()
    ans_list = [str(tup[1]) for tup in tuples]
    print(' '.join(ans_list))


main()

Solution (Python):
from collections import defaultdict as dd
N = int(input())
A = list(map(int, input().split()))

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

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

cnt = 1
for x in A:
    ans[x-1] = cnt
    cnt += 1

print(*ans)

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

li = []
for idx, ele in enumerate(a):
    li.append((ele, idx+1))

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

print(*ans)

Solution (Python):
input = raw_input


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

L = [[0,0] for i in range(N)]
for i in range(N):
    L[i][0] = i + 1
    L[i][1] = A[i]
L.sort(key = lambda x: x[1])
print(" ".join(map(lambda x: str(x[0]), L)))

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

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

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

print(*ans)

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

print(' '.join([str(i+1) for i, j in sorted(enumerate(an), key=lambda a: a[1])]))

Solution (Python):
import sys

input = sys.stdin.readline


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

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

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



if __name__ == '__main__':
    AtCoder().main()

Solution (Python):
n=int(input())
lista = [int(i) for i in input().split()]
ans = [0]*n
for i in range(n):
    num = lista[i]
    ans[num-1] = i+1
for i in range(n):
    print(str(ans[i])+" ",end="")