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):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

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

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

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

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    import sys
    input = sys.stdin.readline
    sys.setrecursionlimit(10**7)
    from collections import Counter, deque
    
    from itertools import combinations, permutations, accumulate, groupby
    
    from bisect import bisect_left,bisect_right
    from heapq import heapify, heappop, heappush
    from math import floor, ceil
    

    
    

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

if __name__ == '__main__':
    main()

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

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


for i in range(n):

	ans[data[i]-1] =i+1
L=[str(a) for a in ans]
print(" ".join(L))

Solution (Python):
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
print(*b)

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())
a = list(map(int,input().split()))
b = [0 for j in range(n)]

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

print(*b)

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

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

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

out = [0] * N

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

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

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

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

for s_dic_a in s_dic_a:
    print(s_dic_a[0], end=" ")

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

AB = [(A[i],i) for i in range(N)]

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

B = [AB[i][1]+1 for i in range(N)]

ans = " ".join(map(str,B))
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] = i+1

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

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

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

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

B=[0]*N
i=0
while i<=N-1:
    B[i]=[A[i],i+1]
    i+=1

B=sorted(B)
C = [x[1] for x in B]
print(*C)

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

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

for a in ans:
    print(a)

Solution (Python):
N = int(input()) 
A =  [int(x) for x in input().split()]
B =  [[0 for i in range(2)] for j in range(N)]
for i in range(N):
    B[i][0]=A[i]
    B[i][1]=i+1

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

Solution (Python):
from collections import namedtuple


Record = namedtuple('Record', 'number id')

N = int(input())

records = [
  Record(n, i)
  for i, n in enumerate(map(int, input().split()), 1)
]

records.sort()

print(' '.join(map(str, [r.id for r in records])))

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

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

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

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

print(*ans)

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

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

Solution (Python):
import numpy as np

N = int(input())
A = list(map(int, input().split()))
rank = {}
for i in range(N):
    rank[A[i]] = str(i+1)
    
print(' '.join(rank.values()))

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

N = int(input())
A = list(map(str, np.argsort(np.array(list(map(int, input().split())))) + 1))

print(' '.join(A))

Solution (Python):
import numpy as np
from sys import stdin

def main():
  n = map(int,input().split())
  a = list(map(int, input().split()))
  b = np.argsort(a)+1
  str_ = ""
  for i in b:
    str_ = str_ + "{:d} ".format(i)  
  print(str_)
  
if __name__ == "__main__":
    main()

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

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
keys = []
for i in range(n):
    keys.append(i+1)
dic = {key: val for key,val in zip(keys,a)}
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()))


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

Solution (Python):
import sys
import numpy as np

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N = ir()
A = np.array(lr())
B = np.argsort(A)
B += 1
print(*B)

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

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

ans = []
for j in range(1, n+1):
    ans.append(str(d[j]))

print(" ".join(ans))

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

n = int(input())
a = list(map(int, input().split()))
memo = [[0, 0] for i in range(n)]
for i, j in enumerate(a):
    memo[i][0] = j
    memo[i][1] = i + 1
memo.sort()
for i in range(n):
    print(memo[i][1], end=' ')
print()

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

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

result = [0 for i in range(n+1)]

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

Solution (Python):
n = int(input())
*a, = map(int, input().split())
b = [(j, i) for i, j in enumerate(a)]
b.sort()
print(*[j+1 for i, j in 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)

b = ' '.join(b)
print(b)

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

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

from collections import defaultdict
 
counter = defaultdict(int)
 
for i in range(N):
    counter[i+1] += A[i]

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

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

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

import numpy as np

A = np.array(A)
print(' '.join([str(i + 1) for i in A.argsort()]))

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

    lst = [0 for _ in range(n)]
    for idx, a in enumerate(A):
        lst[a-1] = str(idx + 1)

    print(' '.join(lst))


if __name__ == '__main__':
    solve()

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
ans = ['']*N
for id,name in enumerate(A):
  ans[name-1] = str(id+1)
print(' '.join(ans))

Solution (Python):
import sys
import math

from collections import defaultdict
from collections import deque
def load(vtype=int):
    return vtype(input().strip())
def load_list(seplator=" ", vtype=int):
    return [vtype(v) for v in input().strip().split(seplator)]
def exit():
    import sys
    sys.exit(0)
def perm_sub(li, used):
    if len(li) == len(used):
        return [deque()]
    k = []
    for i in range(len(li)):
        if i in used:
            continue
        used.add(i)
        sub_list = perm_sub(li, used)
        for sub in sub_list:
            sub.appendleft(li[i])
        k.extend(sub_list)
        used.discard(i)
    return k
def perm_li(li):
    return perm_sub(li, set())
def perm_n(n):
    return perm_sub(list(range(n)), set())
def join_i(li, sep=""):
    return sep.join([str(e) for e in li])
def li2n(li):
    n, base = 0, 1
    for i in range(len(li)-1, -1, -1):
        n += li[i] * base
        base *= 10
    return n
def sli2ili(li):
    return [int(s) for s in li] 
def prime_list(n):
    li = [i for i in range(2, n+1)]
    for i in range(len(li)):
        if li[i] >= int(math.sqrt(n)):
            break
        if li[i] == -1:
            continue
        for j in range(i+1, len(li)):
            if li[j] % li[i] == 0:
                li[j] = -1
    return [n for n in li if n != -1]
def gcd(a, b):
    a, b = max(a, b), min(a, b)
    while True:
        r = a % b
        if r == 0: return b
        a, b = b, r
def lcm(a, b):
    return int(a * b / gcd(a,b))
def all_subset(li):
    s = []
    n = len(li)
    for bit in range(0, (1<<(n+1))):
        ss = set()
        for i in range(0, n):
            if (bit & (1 << i)):
                ss.add(li[i])
        s.append(ss)
    return s

n = load()
A = load_list()

result = [0 for i in range(n+1)]
for i in range(n):
    result[A[i]] = i+1

print(join_i(result[1:], " "))

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

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

ans = [0] * N
for k,v in enumerate(A):
    ans[v-1] = k+1

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

Solution (Python):
n = int(input())
L = list(map(int,input().split()))
li = []
for i,j in enumerate(L):
    li.append((i+1,j))

li.sort(key = lambda x:x[1])
ans = []
for i in range(n):
    ans.append(li[i][0])
print(*ans)

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

Solution (Python):
def main():
    N = int(input())
    A = list(map(int,input().split()))
    d = {}
    for i,a in enumerate(A):
        d[a]=i
    for i in range(1,N+1):
        print(d[i]+1,end=" ")
    print()

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

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

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

order = [ [a_i, i + 1] for i, a_i in enumerate(a)]
order.sort(key=lambda x: x[0])

arr = [str(j[1])for j in order]
print(' '.join(arr))

Solution (Python):
n=int(input())
numbers=input().rstrip().split(" ")
order=[0 for i in range(n)]
for (i,number) in enumerate(numbers):
    order[int(number)-1]=i+1

for num in order:
    print(num,end=" ")

Solution (Python):
import sys
import numpy as np

n=int(sys.stdin.readline())








a=list(sys.stdin.readline().split())
b=[0]*n

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

Solution (Python):
from operator import itemgetter

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

B = sorted(B, key=itemgetter(1))

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

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

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

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

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-1):
    print(ans[i],end=" ")
print(ans[N-1])

Solution (Python):

n = int(input()) 
a = list(map(int, input().split()))
l = list(range(1, len(a)+1, 1))
d = dict(zip(a, l))
ans = [str(d[x]) for x in l]
print(' '.join(ans))

Solution (Python):






import numpy as np



n = int(input())

arrA = np.array(input().split(),dtype=np.int64)

ans = [0 for _ in range(n)]
for i,v in enumerate(arrA):
    ans[v-1] = i+1

print(*ans)

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

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

print(*ans)

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

print(*ans)

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

A = []

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

for j in range(len(A)):
  print(A[j][1],end =' ')

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

A = []

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

for j in range(len(A)):
  print(A[j][1],end =' ')

Solution (Python):

n = int(input())
a = list(map(int, input().split()))
aa = sorted([(a[i], i + 1) for i in range(n)])
ans = []
for _, idx in aa:
    ans.append(idx)
print(*ans)

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

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

print(" ".join(res))

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())
num=[i+1 for i in range(n)]
L=list(map(int,input().split()))
ans=[0 for _ in range(n)]
for j in range(n):
    ans[L[j]-1]=num[j]
print(*ans)

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))

def main():
    N = int(input())
    A = input_nums()
    members = {}
    for i in range(1, N+1):
        members[i] = A[i-1]
    members = sorted(members.items(), key=lambda x:x[1])
    res = [str(m[0]) for m in members]
    print(' '.join(res))

if __name__ == '__main__':
    main()

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

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
"""
for i in range(N):
    print("{:}".format(A.index(i+1)+1),end=" ")"""
a = list(range(1,N+1,1))

A_ = dict(zip(A,a))


A__ = sorted(A_.items())


for i in range(N):
    print("{:}".format(A__[i][1]),end=" ")

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

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

    come = [None] * N

    for i, x in enumerate(A):
        come[x - 1] = (i + 1)

    print(*come)


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):




import numpy as np



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

    B=np.argsort(A)

    for b in B:
        print(b+1,end=' ')




resolve()

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
  
for b in B:
  print(b, end=" ")

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

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

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

Solution (Python):
N=int(input())
A = [int(x) for x in input().split()]
B = [0 for _ in range(N)]
for ind,num in enumerate(A):
  B[num-1]=ind+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] = i + 1
print(' '.join(map(str, B)))

Solution (Python):
def main():
    n=int(input())
    tmp=input().split()
    a=[[int(tmp[i]),str(i+1)] for i in range(n)]
    a.sort()
    print(" ".join([a[i][1] for i in range(n)]))
if __name__ == '__main__':
    main()

Solution (Python):
_, *a = map(int, open(0).read().split())
print(*[i for i, __ in sorted(enumerate(a, 1), key = lambda l: l[1])])

Solution (Python):
import numpy as np
N, A = int(input()), np.array(input().split()).astype('i8')
print(' '.join((np.argsort(A)+1).astype('str')))

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

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

if __name__ == '__main__':
    main()

Solution (Python):
import sys
from bisect import *
from heapq import *
from collections import *
from itertools import *
from functools import *

sys.setrecursionlimit(100000000)
input = lambda: sys.stdin.readline().rstrip()

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

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

Solution (Python):


def submit():
    n = int(input())
    alist = list(map(int, input().split()))
    order = [-1 for _ in range(n)]

    for i, a in enumerate(alist, start=1):
        order[a - 1] = i

    print(*order, sep=" ")
    


if __name__ == "__main__":
    submit()

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

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

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

Solution (Python):
def solve():
    N = int(input())
    A = list(map(int, input().split()))
    B = []
    for a, b in enumerate(A):
        B.append((b, a+1))
    B.sort()
    l = []
    for (a, b) in B:
        l.append(b)
    print(*l)




solve()

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

for i in range(n):
  c.append([h[i],i+1])
  
c.sort()
for i , k in c:
  print(k)

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

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

info.sort()
for s, o in info:
    print(o)

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

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

tmp.sort()
s = ""
for i in range(N):
    s += str(tmp[i][1]+1) + " "

print(s)

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

def make1d(n):
  lst = []
  for i in range(n):
    lst.append(0)
  return lst

def attend(n, lst):
  res = make1d(n)
  for i in range(n):
    res[lst[i]-1] = i+1
  return res

print(*attend(N, List))

Solution (Python):

n=int(input())
a=list(map(int,input().split()))
ans=[0]*(n)
for seito,junban in enumerate(a):
    ans[junban-1]=seito+1
for i in ans:
    print(i)

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

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
d = {a:i for a,i in enumerate(A)}
print(*[k+1 for k, v in sorted(d.items(), key=lambda item: item[1])])

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

arrive_l = {}
cnt = 1
for i in range(n):
    arrive_l[l[i]] = cnt
    cnt+=1

arrival_order = sorted(arrive_l.items())
ans = ""
for i in range(n):
    ans += str(arrival_order[i][1]) + " "
    
print(ans.strip())

Solution (Python):
import numpy
N = int(input())
A = list(map(int, input().split()))
inds = numpy.argsort(A)
inds+=1
for ind in inds:
  print(ind, end=' ')

Solution (Python):
import numpy as np

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

ans = np.argsort(a)
ans += 1

print(*ans)

Solution (Python):

"""
Created on Tue Mar 10 21:34:10 2020

@author: Kanaru Sato
"""

n = int(input())
memo = list(map(int, input().split()))
attend = [0]*n

for i in range(0,n):
    attend[memo[i]-1] = i+1

ans = [str(attend[i]) for i in range(0,n)]
ans = " ".join(ans)

print(ans)

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

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
idx = sorted(range(1, N + 1), key=lambda x: A[x - 1])
idx = list(map(str, idx))
print(" ".join(idx))

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

for i, a in sort_A:
    print(i, end=" ")

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

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

for x in range(len(A)):
    out[x + 1] = A[x]

outlist = []
for k, v in sorted(out.items(), key=lambda x: x[1]):
    outlist.append(str(k))

print(" ".join(outlist))

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

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

idx = [0] * n

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

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

i = 0
person = []
for j in range(n):
    person.append(0)
ans = []
for k in a:
    i += 1
    person[k-1] = i

a.sort()
for l in a:
    ans.append(str(person[l-1]))

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

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

Solution (Python):
f=input;f();print(*list(zip(*sorted((int(i),e+1) for e,i in enumerate(f().split()))))[1])

Solution (Python):
input();print(*list(zip(*sorted((i,e+1) for e,i in enumerate(map(int,input().split())))))[1])

Solution (Python):
input()
l=sorted([(i,e+1) for e,i in enumerate(map(int,input().split()))])
print(*list(zip(*l))[1])

Solution (Python):
n=int(input())
lt=sorted([(e+1,i) for e,i in enumerate(map(int,input().split()))], key=lambda k:k[1])
print(*list(zip(*lt))[0])

Solution (Python):
def main():
    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)
main()

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

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

import numpy as np

a = np.array(a)
arg = a.argsort()

for i in arg:
    print(i+1, end=' ')

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
d={}
for i in range(n):
    d[A[i]-1]=i+1
ans=[]
for i in range(n):
    ans.append(d[i])
print(*ans)

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

Solution (Python):

import sys
import numpy as np

def solve(N: int, A: "List[int]"):
    k = (np.argsort(A)+1)
    print(*k)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  
    A = [int(next(tokens)) for _ in range(N)]  
    solve(N, A)

if __name__ == '__main__':
    main()

Solution (Python):
from operator import itemgetter
N=int(input())
A=list(map(int,input().split()))
B=[(i+1,A[i]) for i in range(N)]
B=sorted(B,key=itemgetter(1))
for k in range(N):
  print(B[k][0],end=" ")

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

Solution (Python):
n = int(input())
for a,_ in sorted(enumerate(list(map(int,input().split())),start=1),key=lambda x: x[1]):
    print(a,end=" ")

Solution (Python):
N=int(input())
mylist=list(map(int,input().split()))
numberlist=[]

for i in range(1,N+1):
    numberlist.append(i)
mydic=dict(zip(mylist,numberlist))



anslist=sorted(mydic.items())


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

Solution (Python):
num = int(input())
a_list = list(map(int, input().split(" ")))
ans_list = [0] * num

for i in range(num):
    ans_list[a_list[i]-1] = i+1

for i in range(num-1):
    print(ans_list[i], end=" ")
print(ans_list[num-1])

Solution (Python):
N = int(input())
S = [int(i) for i in input().split(" ")]
L = [0]*N

for j in range(0,N):
  L[S[j]-1] = j+1
for k in range(N):
    if k==N-1:
        print("{}".format(L[k]),end="")
    else:
        print("{} ".format(L[k]),end="")
print("\n",end="")

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

b =[]
for i in range(0,len(a)):
    b.append([a[i],i+1])
b.sort()

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

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

L = [0]*n

for i, order in enumerate(l, 1):
    L[order-1] = i

print(*L)

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

Solution (Python):
from sys import stdin

n = int(stdin.readline().rstrip())
a = {i + 1: int(x) for i, x in enumerate(stdin.readline().rstrip().split())}

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

final = []
for i in range(n):
    final.append(a_sorted[i][0])

print(*final)

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

c = [i for i in range(n)]
sorted_c = sorted(c, key=lambda i: a[i])
sorted_c = [x+1 for x in sorted_c]
print(*sorted_c)

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

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

print(" ".join(ans))

Solution (Python):
import math
import sys
import numpy as np

def input():
    return sys.stdin.readline()[:-1]

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

ans = [0] * (N+1)

for i, a in enumerate(A):
    ans[a] = i+1
ans.pop(0)


print(*ans)

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

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

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

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

ans = ""
for r in rank[1:]:
    if ans != "":
        ans += " "
    ans += str(r)

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

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

Ans = [0 for _ in range(n)]

for i in range(n):
    Ans[List[i]-1] = i + 1

print(*Ans)

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

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