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
    
    n = int(input())
    arr = list(map(int, input().split()))
    
    ans = [i for i in range(n)]
    ans.sort(key = lambda x : arr[x])
    
    ans = [i + 1 for i in ans]
    print(*ans)
    
    return 0

main()

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

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

Solution (Python):
import sys
from heapq import heappop, heappush
from operator import itemgetter
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
MOD = 10**9 + 7
INF = float('inf')

def sol():
    N = int(input())
    A = [(n, i + 1) for i, n in enumerate(map(int, input().split())) ]

    A.sort()
    ans = []
    for _, i in A:
        ans.append(i)
    print(*ans)

sol()

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
m = {}
for i, x in enumerate(a):
    m[x] = i + 1
for i in range(1, n + 1):
    if i > 1:
        print(' ', end='')
    print(m[i], end='')
print()

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

Solution (Python):
n = int(input())
ls = list(map(int,input().split()))
che = [[0,0] for i in range(len(ls))]
for i in range(len(ls)):
    che[i] = [ls[i],i+1]
che.sort(key=lambda x:x[0])
for i,v in che:
    print(v,end = ' ')
print()

Solution (Python):

import sys


def solve(N: int, A: "List[int]"):
    x = sorted([[i,A[i]] for i in range(N)], key=lambda x:x[1])
    ans = [i+1 for i,j in x]
    print(' '.join(map(str,ans)))

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

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

Solution (Python):
import bisect
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7

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

A = np.array(A, dtype=int)
a = A.argsort() + 1

print(*a)

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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007


def A():
    n = I()
    print((n-(n>>1))/n)
    return


def B():
    n,k = LI()
    h = LI()
    ans = 0
    for i in h:
        if i >= k:
            ans += 1
    print(ans)
    return


def C():
    n = I()
    a = LI()
    b = [(a[i],i+1) for i in range(n)]
    b.sort()
    ans = [b[i][1] for i in range(n)]
    print(*ans)
    return


def D():

    return


def E():

    return


def F():

    return


if __name__ == "__main__":
    C()

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

L = [[0] * 2 for i in range(N)]

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

L.sort()

t = str(L[0][1])
for i in range(1, N):
  t += " " + str(L[i][1])

print(t)

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):
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)

from math import factorial
import heapq, bisect
import math
import itertools


import queue
from collections import deque



def main():
    num = int(input())
    data = list(map(int, input().split()))
    aaa = [0 for i in range(num)]

    for i in range(num):
        aaa[i] = [data[i], i + 1]

    aaa.sort()

    for i in range(num):
        print(aaa[i][1],end='')
        if i == num - 1:
            print()
        else:
            print(' ',end='')





if __name__ == '__main__':
    main()