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



Sample input:
3
2 3 1


Sample output:
3 1 2

Submission status: Accepted

Solution code:
from operator import itemgetter
n = int(input())
A = sorted([(int(i),int(a)) for i,a in zip(range(1,n+1),input().split())],key=itemgetter(1))
for ans in A:
    print(ans[0],end=' ')
print()

Submission status: Accepted

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

for i in range(N):
    result[list[i]-1] = i+1

L = [str(a) for a in result]
L = ' '.join(L)
print(L)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
As = list(map(int, input().split()))

dic = {}
for i in range(N):
  dic[As[i]] = i+1
  
ans = []
for i in range(1,N+1):
  ans.append(dic[i])
print(*ans)

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
N = int(input())
A_list = list(map(int, input().split()))

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

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

Submission status: Accepted

Solution code:
from operator import itemgetter
n = int(input())

A = []
i = 1
for a in input().split(' '):
    A.append((i,int(a)))
    i += 1

A = sorted(A, key=itemgetter(1))
print(' '.join([str(a[0]) for a in A]))

Submission status: Accepted

Solution code:
def solve():
  N = int(input())
  A = sorted([(i, int(v)) for i, v in enumerate(input().split())])
  sortedList = [-1] * N
  for i, a in A:
    sortedList[a - 1] = str(i + 1)
  return ' '.join(sortedList)

print(solve())

Submission status: Accepted

Solution code:
N = int(input())
nums = list(map(lambda n: int(n), input().split()))

index_nums = {index: num for (index, num) in enumerate(nums, 1)}

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

for index, num in sorted_index_nums:
    print(index)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
As = list(map(int, input().split(" ")))
arr = [[] for i in range(N)]

for i,A in enumerate(As):
    arr[A-1] = i+1
print(" ".join(list(map(str, arr))))

Submission status: Accepted

Solution code:
n = int(input())
nums = [int(s) for s in input().split()]

box = []

for i,j in enumerate(nums):
  box.append([i + 1,j])
  
answer = []
for i in sorted(box, key=lambda x: x[1]):
	answer.append(str(i[0]))

print(" ".join(answer))

Submission status: Accepted

Solution code:
n=int(input())

r=list(map(int,input().split()))
dic={}

for index,value in enumerate(r):
  dic[value]=index+1
  
#print(dic)
s=""
for v in range(n):
  s+=" "+str(dic[v+1])
  
if s[:1]==" ":
  s=s[1:]
print(s)

Submission status: Accepted

Solution code:
def main():
  n = int(raw_input())
  numbers = [(i+1, int(x)) for i, x in enumerate(raw_input().split())]
  result = list(sorted(numbers, key=lambda x: x[1]))
  answer = [str(x[0]) for x in result]
  print(' '.join(answer))


main()

Submission status: Accepted

Solution code:
N = int(input())
l = list(map(int, input().split()))
a = {i+1:n for i, n in enumerate(l)}
a = sorted(a.items(), key=lambda x:x[1])
a = [n for n, i in a]
print(' '.join(map(str, a)))

Submission status: Accepted

Solution code:
n = int(input())
l = list(map(int, input().split()))
ll = []
ans = []
for i in range(len(l)):
    ll.append([i + 1, l[i]])
ll = sorted(ll, key=lambda x: x[1])
for i in range(len(l)):
    ans.append(str(ll[i][0]))
print(' '.join(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
A = list(map(int, input().split()))
d = {}
for i in range(1,N+1):
    d.update({i:A[i-1]})


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

Submission status: Accepted

Solution code:
N=int(input())
A=list(map(int,(input().split())))
Lis=[]
big=10**6
for i in range(len(A)):
	Lis.append(A[i]*big+i+1)
Lis.sort()
ans=""
for i in Lis:
	ans+=str((i%big))+" "
print(ans)

Submission status: Accepted

Solution code:
n = int(input())
l = list(map(int, input().split()))
ll = []

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

ll = sorted(ll, key=lambda x: (x[0]))
lll = []
for i in ll:
		lll.append(i[1])

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

Submission status: Accepted

Solution code:
n = int(input())
a = list(map(int, input().split()))
t = []
for i, x in enumerate(a):
    t.append((x, i + 1))
t.sort()
for _, i in t:
    print(i, end = ' ')
print()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
# abc142/abc142_c
import sys

s2nn = lambda s: [int(c) for c in s.split(' ')]
ss2nn = lambda ss: [int(s) for s in list(ss)]
ss2nnn = lambda ss: [s2nn(s) for s in list(ss)]
i2s = lambda: sys.stdin.readline().rstrip()
i2n = lambda: int(i2s())
i2nn = lambda: s2nn(i2s())
ii2ss = lambda n: [i2s() for _ in range(n)]
ii2nn = lambda n: ss2nn(ii2ss(n))
ii2nnn = lambda n: ss2nnn(ii2ss(n))

def main():
    N = i2n()
    A = [None] * N
    for i, v in enumerate(i2nn()):
        A[i] = (i, v)
    A2 = sorted(A, key= lambda x:x[1])
    print(*[a[0]+1 for a in A2])
    return

main()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n=int(input())
X=list(map(int, input().split()))
A=[]
B=[]

for i in range(n):
  A.append([X[i], i+1])
  
A.sort()
for j in range(n):
  B.append(A[j][1])

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
ali = list(map(int, input().split()))
kumi = []
for ind, a in enumerate(ali, start=1):
    kumi.append((ind, a))
sorted_kumi = sorted(kumi, key=lambda x:x[1])
for ind, a in sorted_kumi:
    print(ind, end=' ')

Submission status: Accepted

Solution code:
n = int(input())
l = [int(i) for i in input().split()]

l2 = [str(k[0]) for k in  sorted([[i+1,j] for i,j in enumerate(l)],key = lambda x :x[1])]

print(' '.join(l2))

Submission status: Accepted

Solution code:
N = int(input())
A = [int(x) for x in input().split()]
AA = [(x, i) for i, x in enumerate(A)]
AA = sorted(AA, key=lambda x: x[0])
AA_print = [i+1 for x, i in AA]
print(*AA_print)

Submission status: Accepted

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

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

str = ' '.join(ans)
print(str, end='')

Submission status: Accepted

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

out_put = [0]*N
for index,value in enumerate(A):
    out_put[value - 1] = index + 1

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

Submission status: Accepted

Solution code:
def main():
    from heapq import heappush, heappop
    from collections import defaultdict
    N, *A = map(int, open(0).read().split())
    l = []
    d = defaultdict(int)
    for i, a in enumerate(A):
        d[a] = i+1
    print(d[1], end='')
    for i in range(2, len(A)+1):
        print(' ' + str(d[i]), end='')
if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-
n = int(input())
a = list(map(int, input().split()))
s = []
for i in range(n):
    s.append((a[i], i+1))
s.sort()
ns = []
for si in s:
    ns.append(si[1])
print(" ".join(map(str, ns)))

Submission status: Accepted

Solution code:
from operator import itemgetter

n=int(input())
a=[int(x) for x in input().split()]
a_cm=[0]*n
a_i=[0]*n
for i in range(n):
    a_cm[i]=[i+1,a[i]]

a_cm.sort(key=itemgetter(1))
for i in range(n):
    a_i[i]=a_cm[i][0]

string=" ".join(map(str,a_i))
print(string)

Submission status: Accepted

Solution code:
n = int(input())
s = list(map(int, input().split()))
l = [(i, v) for i, v in enumerate(s)]
l.sort(key = lambda x: x[1])
a = ''
for i in l:
  a += str(i[0] + 1) + ' '
print(a[:-1])

Submission status: Accepted

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

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

print(" ".join(str(x[0]) for x in xs))

Submission status: Accepted

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

V = []
for i, v in enumerate(A):
    V.append((v, i))

V.sort()

s = ""
for v in V:
    if len(s) > 0:
        s += " "
    s += str(v[1] + 1)

print(s)

Submission status: Accepted

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

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

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

Submission status: Accepted

Solution code:
import numpy as np

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

for i, n in enumerate(A):
  dict_[i] = n
  
dict_sorted = sorted(dict_.items(), key=lambda x:x[1])

for d in dict_sorted:
  print(d[0] + 1, end=" ")

Submission status: Accepted

Solution code:
n = int(input())
a = [int(i) for i in input().split()]
s = []
for i in range(n):
  tmp = [a[i],i+1]
  s.append(tmp)

s.sort()

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

Submission status: Accepted

Solution code:
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, sep=' ')

Submission status: Accepted

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

ind = np.argsort(h)
ind = ind +1
print(' '.join(map(str,ind)))

Submission status: Accepted

Solution code:
from operator import itemgetter

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

l = [i for i, _ in sorted(enumerate(a, 1), key=itemgetter(1))]
print(*l)

Submission status: Accepted

Solution code:
import numpy as np
N = int(input())
A = list(map(int,input().split()))
B = list(range(1,N+1))
AB = np.array((A,B))
ABsort = AB[:,np.argsort(AB[0,:])]

output = ""
for i in range(N-1):
    output += "{} ".format(ABsort[1,i])
output += str(ABsort[1,-1])
print(output)

Submission status: Accepted

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

res = [0] * n

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

print(' '.join(res))

Submission status: Accepted

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

ans = [0 for x in range(n)]

for i in a:
    ans[a[i-1]-1] = i

print(*ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
n = int(input())
a_lst = [int(elem) for elem in input().split()]
nums = [(num + 1) for num in range(n)]

tmp = zip(a_lst, nums)
tmp = sorted(tmp)
a_lst, nums = zip(*tmp)

res = list(list(map(str, nums)))
print(' '.join(res))

Submission status: Accepted

Solution code:
n = int(input())
aa = list(map(int,input().split()))

dic = {}
for i, ai in enumerate(aa):
  dic[ai] = i+1
  
ans=[]
for i in range(1,n+1):
  ans.append(str(dic[i]))  
  
print(' '.join(ans))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import numpy as np

N = int(input())
A_list = np.array([int(A) for A in input().split(' ')])

# print(N)
# print(A_list)

A_sorted_index = np.argsort(A_list) + 1
A_sorted_index = A_sorted_index.astype(str)
A_sorted_index_str = ' '.join(A_sorted_index)

print(A_sorted_index_str)

Submission status: Accepted

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

AI = [[A[i], i+1] for i in range(N)]
AI = sorted(AI)
ans = [ai[1] for ai in AI]

print(*ans)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = map(int, input().split())
j = list(map(int, input().split()))
print(" ".join(map(str, sorted(range(1, len(j)+1), key=lambda k: j[k-1]))))

Submission status: Accepted

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

lis=[0]*n

for i in range(1,n+1):
    caca=int(a[i-1])
    lis[caca-1]=i

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

Submission status: Accepted

Solution code:
N = int(input())
A = [int(x) for x in input().split()]
B = [0]*N
for k in range(N):
    B[k] = [k+1]*2
    B[k][0] = A[k]
B = sorted(B)
ans = [0]*N
for i in range(N):
    ans[i] = B[i][1]
print(*ans)
#print(B)

Submission status: Accepted

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

ans = [0 for _ in range(N)]
for i, a in enumerate(A):
    ans[i] = [i+1, a]

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

ans2 = [x[0] for x in ans]
print(*ans2)

Submission status: Accepted

Solution code:
input()
a = sorted(enumerate(map(int, input().split()), start=1), key=lambda x: x[1])
print(*[i for i, _ in a])

Submission status: Accepted

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

Alist.sort()

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

Submission status: Accepted

Solution code:
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, sep=' ')

Submission status: Accepted

Solution code:
n = int(input())

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

z = zip(a,b)
sorted_z = sorted(z)

new_a = []
new_b = []

for a_dash,b_dash in sorted_z:
	new_a.append(a_dash)
	new_b.append(b_dash)

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

debug = True
# debug = False

def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    N = II()
    a_list = LI()

    from operator import itemgetter

    import numpy as np
    A = np.array(a_list)
    arga = np.argsort(A)
    ind = np.array(list(range(N)))

    print(' '.join([str(a+1) for a in ind[arga]]))

solve()

Submission status: Accepted

Solution code:
N = int(input())
a = list(map(int, input().split()))
anslst = [0] * N

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

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

Submission status: Accepted

Solution code:
n = int(input())
counts = list(map(int, input().split()))

order = [0] * n
for i, count in enumerate(counts):
  order[count-1] = i+1
  
print(' '.join(map(str, order)))

Submission status: Accepted

Solution code:
from sys import stdin
import numpy as np


# noinspection PyShadowingBuiltinsInspection

def main():
    n = int(input())
    students = [int(x) for x in input().split()]
    ret = [0] * n
    for i in range(n):
        ret[students[i] - 1] = i + 1
    print(" ".join([str(x) for x in ret]))
    return


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
def c_go_to_school():
    N = int(input())
    A = [[int(a), k] for k, a in enumerate(input().split(), 1)]
    A.sort()
    return ' '.join([str(b) for a, b in A])

print(c_go_to_school())

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())

A = {k:v for v, k in enumerate(list(map(int, input().split())), 1)}

for k in range(1, len(A) + 1):
    print(A[k], end = " ")

Submission status: Accepted

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

Submission status: Accepted

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

for jun in junbannlist:
    print(jun,end=' ')

Submission status: Accepted

Solution code:
N = int(input())
Al = list(map(int,input().split()))
sd = {}
for i,A in enumerate(Al):
    sd[str(i+1)] = A

ans_l = []
for key,value in sorted(sd.items(),key=lambda x:x[1]):
    ans_l.append(key)

print(" ".join(ans_l))

Submission status: Accepted

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

r=[0]*n

for i, val in enumerate(a):
    r[val-1] = i+1

print(" ".join([str(n) for n in r]))

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
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])

Submission status: Accepted

Solution code:
# -*- coding: utf-8 -*-

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

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

# output
for i in range(N):
    print(ans[i], end=' ')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
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=" ")

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#C
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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#coding: utf-8
n = int(input())
student = list(map(int,input().split()))
toukou = [0] * n

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

Submission status: Accepted

Solution code:
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)])

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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:]))

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
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= " ")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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 = ' ')

Submission status: Accepted

Solution code:
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=" ")

Submission status: Accepted

Solution code:
N = int(input())
A = list(map(int,input().split()))
#print(A)
dic = {}
for id,num in enumerate(A):
  dic[num] = id + 1
#print(dic)
for i in range(1,N+1):
  print(dic[i],end=" ")

Submission status: Accepted

Solution code:
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 = ' ')

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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("")

Submission status: Accepted

Solution code:
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])

Submission status: Accepted

Solution code:
# coding: utf-8

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)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N=int(input())
la=list(map(int,input().split()))
#la=enumerate(map(int,input().split()))
#print(la[0])
da={}
for i in range(N):
    da[la[i]]=i
la.sort()
for i in range(N):
    print(da[la[i]]+1,end=" ")
print()

Submission status: Accepted

Solution code:
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])

Submission status: Accepted

Solution code:
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=' ')

Submission status: Accepted

Solution code:
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=" ")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:

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)

Submission status: Accepted

Solution code:
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=' ')

Submission status: Accepted

Solution code:
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=" ")

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
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=' ')

Submission status: Accepted

Solution code:
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()

Submission status: Accepted

Solution code:
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 = " ")

Submission status: Accepted

Solution code:
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)])

Submission status: Accepted

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