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:
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(200000)
input = sys.stdin.readline
def ii(): return int(input())
def mi(): return map(int, input().rstrip().split())
def lmi(): return list(map(int, input().rstrip().split()))
def fi(): return float(input())
def mfi(): return map(float, input().rstrip().split())
def lmfi(): return list(map(float, input().rstrip().split()))
def li(): return list(input().rstrip())
def debug(*args, sep=" ", end="\n"): print("debug:", *args, file=sys.stderr, sep=sep, end=end) if not __debug__ else None
def exit(*arg): print(*arg); sys.exit()
# template


def main():
    N = ii()
    A = lmi()
    aa = [(A[i], i + 1)for i in range(N)]
    aa.sort()
    ans = [aa[i][1]for i in range(N)]
    print(*ans)
    return


if __name__ == '__main__':
    main()

Submission status: Accepted

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

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

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

ans = []
for i in range(len(L)) :
    ans.append(L[i][0])
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]=i+1

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

Submission status: Accepted

Solution code:
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

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 I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()

def main():
  n=I()
  l=LI()

  l2=[]
  for i,x in enumerate(l):
    l2.append([i+1,x])

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

  ans=[]
  for x in l2:
    ans.append(x[0])

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

# main()
print(main())

Submission status: Accepted

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

B = [None]*N
for i, a in enumerate(A):
    B[a-1] = i+1

print(' '.join([str(b) for b in B]))

Submission status: Accepted

Solution code:

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

B = [[A[i], i+1] for i in range(n)]
B.sort()
ANS = []
for i in range(n):
    ANS.append(str(B[i][1]))
# print(ANS)
print(" ".join(ANS))

Submission status: Accepted

Solution code:
import sys
from collections import defaultdict, deque
from heapq import *
sys.setrecursionlimit(200000)
input = sys.stdin.readline

# H, K, = map(int, input().split())
N = int(input())
L = [int(v) for v in input().split()]
# L = [[int(v) for v in input().split()] for _ in range(N)]
# L = [int(input()) for _ in range(N)]
# L = [list(input().strip())  for _ in range(N)]
# S = input().strip()

for i in range(N):
    L[i] = (L[i], i)

L.sort()
print(*[v[1] + 1 for v in L])

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

N=int(input())
A=list(map(int,input().split()))
B=[(a,i) for i,a in enumerate(A)]
B.sort()
ANS=[B[i][1]+1 for i in range(N)]
print(*ANS)

Submission status: Accepted

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

Submission status: Accepted

Solution code:
N = int(input())
A_arr = [int(x) for x in input().split()]
B_arr = list(range(N))

B_arr.sort(key=lambda x:A_arr[x])
for i in B_arr:
    print(i+1, end=" ")
print()

Submission status: Accepted

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

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

for tu in items:
    print(tu[1], end=" ")

Submission status: Accepted

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

Submission status: Accepted

Solution code:
def slove():
    import sys
    input = sys.stdin.readline
    n = int(input().rstrip('\n'))
    a = list(map(int, input().rstrip('\n').split()))
    for i in range(n):
        a[i] = [a[i], i + 1]
    a.sort()
    ans = []
    for v in a:
        b, c = v
        ans.append(c)
    print(*ans)


if __name__ == '__main__':
    slove()

Submission status: Accepted

Solution code:
import sys
input = sys.stdin.readline

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

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

Submission status: Accepted

Solution code:
N = input()
A = map(int, raw_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:
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)


if __name__ == "__main__":
    main()

Submission status: Accepted

Solution code:
from collections import deque
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

def isprime(n):
  for i in range(2,int(n**0.5)+1):
    if n%i == 0:
      return False
  return True


def solve():
  n = int(input())
  a = list(int(i) for i in input().split())
  query = []
  for i in range(n):
    query.append((a[i],i+1))
  query.sort()

  ans = []
  for i in range(n):
    t,b = query[i]
    ans.append(b)
  print(*ans)
solve()

Submission status: Accepted

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

ret = [0] * N
for i, a in enumerate(A) :
    ret[a-1] = i + 1
    
print(*ret)

Submission status: Accepted

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

ans = [-1] * 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()))

res = [-1 for _ in range(N)]

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

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#import pysnooper
#import numpy
#import os,re,sys,operator
#from collections import Counter,deque
#from operator import itemgetter
#from itertools import accumulate,combinations,groupby,combinations_with_replacement,permutations
from sys import stdin,setrecursionlimit
#from copy import deepcopy
#import heapq
#import math
#import string

setrecursionlimit(10**6)
input=stdin.readline

n=int(input().rstrip())
a=sorted([(int(j),int(i)) for i,j in enumerate(input().split(),1)])
ans=[]
for i in a:
    ans.append(i[1])
print(*ans)

Submission status: Accepted

Solution code:
def resolve():
    n = int(input())
    a = list(map(int, input().split()))
    h = []
    for i, ai in enumerate(a):
        h.append([i, ai])
    h.sort(key=lambda x: x[1])
    ans = " ".join([str(i + 1) for i, _ in h])
    print(ans)


if __name__ == "__main__":
    resolve()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!/usr/bin/env python3
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


# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, A)

if __name__ == '__main__':
    main()

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

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

Submission status: Accepted

Solution code:
#!usr/bin/env python3
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

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

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

#C
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

#D
def D():

    return

#E
def E():

    return

#F
def F():

    return

#Solve
if __name__ == "__main__":
    C()

Submission status: Accepted

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

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] = i+1
print(*ans)

Submission status: Accepted

Solution code:
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
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()

Submission status: Runtime Error

Solution code:
N=int(input())
A=map(int, input().split())
B=[0]*N
C=''

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

for i in range(N):
    C+=str(B[i])+' '

print(C[0:-1])

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np

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

print(ans)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n = int(input())
line = list(map(int, input()))
ans = [0 for i in range(n)]
for i in range(n):
  ans[line[i-1]] = i+1
print(' '.join(ans))

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

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

lists = [0]*N

for i in range(N):
  lists[i] = A.index(i+1)+1
  
for i in lists:
  print(i, end=' ')

Submission status: Runtime Error

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

a=sorted(a3)
for ia in a:
  print(c.index(ia)+1, end='')

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int,input().split()))
t=[0]*N
for idx,i in enumerate(N):
    t[i-1]=idx+1
    
    print(t[i],end=' ')

Submission status: Runtime Error

Solution code:
N = int(input())
A = list(map(int,input().split()))
B = [0]*(N)
for i in range(N):
    B[A[i]] = A[i]
print(B)

Submission status: Runtime Error

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

lst = []*n
for i in range(1,n+1):
  lst[al[i-1]-1] = i
print(*lst)

Submission status: Runtime Error

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

lst = []*(n+1)
for i in range(1,n+1):
  lst[al[i-1]] = i
print(*lst)

Submission status: Runtime Error

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

Alist = [[idx+1, a] for (idx, a) in enumerate(Alist)]

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

ans = [a for a, _ in Alist]
print(" ".join(ans))

Submission status: Runtime Error

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

# ans=[]
ans=[]*N

# for i in range(1,N+1):
    # a=Ai.index(i)+1
    # ans.append(str(a))
for i in range (N):
    ans[Ai[i]-1]=str(i+1)

print(' '.join(ans))

Submission status: Runtime Error

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

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

print(" ".join(alist))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N = int(input())
A = input().split(' ')
A = [int(A[i]) for i in range(N)]
NN = []
for i in range(1, N+1, 1):
  NN.append(A.index(i) + 1)
A = ' '.join(NN)
print(A)

Submission status: Runtime Error

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

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N = int(input())
A = list(map(int,input().split()))
S = [0] * (10 ** 5)
for i,a in enumerate(A):
    S[a] = i + 1
    # print(A[i] + 1)
    # print(a)

for n in range(1,N + 1):
    if n == N + 1 or n == N:
        print(S[n])
    else:
        print(S[n],end=" ")

Submission status: Runtime Error

Solution code:
N = int(input())
A = list(map(int,input().split()))
S = [0] * (10 ** 5)
for i,a in enumerate(A):
    S[a] = i + 1
    # print(A[i] + 1)
    # print(a)

for n in range(N + 1):
    if n != 0:
        print(S[n],end=" ")

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int,input().split()))
ans = 1
X = []
for i in range(N):
  if A[i] == ans:
    ans += 1
    X.append(i+1)
L=' '.join(X)
print(X)

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int,input().split()))
ans = 1
X = []
for i in range(N):
  if A[i] == ans:
    ans += 1
    uno.append(i+1)
L=' '.join(X)
print(X)

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int,input().split()))
ans = 1
uno = []
for i in range(N):
  if A[i] == ans:
    ans += 1
    uno.append(i+1)
L=" ".join(uno)
print(L)

Submission status: Runtime Error

Solution code:
N = int(input())
a = list(input().split())

s = [a.index(i)+1 for str(i) in range(1, N+1)]

result = " ".join(s)
print(result)

Submission status: Runtime Error

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

s = [a.index(i)+1 for i in range(1, N+1)]

result = " ".join(map(str, s))
print(result)

Submission status: Runtime Error

Solution code:
import sys
n= int(input())
an = list(map(int, sys.stdin.readline().split()))
ans = [0]*n
for i in range(n):
    ans[an[i]-1] = i+1

print(' '.join(ans))

Submission status: Runtime Error

Solution code:
n=int(input())
a=list(map(int,input().split()))
b=a
k=1
for i,j in enumerate(a,1):
  b[j]=i
print(*b)

Submission status: Runtime Error

Solution code:
from collections import deque

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

ans=[]

A_dict={}

for n in range(N):
    a = A.popleft()
    A_dict[a]=n+1
    
for n in range(N):
    ans.append(A_dict[n+1])

print(*ans, sep=' ')

Submission status: Runtime Error

Solution code:
from collections import deque

N = int(input_[0])
A = list(map(int,input_[1].split()))

ans=[]

A_dict={}

for n in range(N):
    a = A.popleft()
    A_dict[a]=n+1
    
for n in range(N):
    ans.append(A_dict[n+1])

print(*ans, sep=' ')

Submission status: Runtime Error

Solution code:
from collections import deque

N = int(input_[0])
A = list(map(int,input_[1].split()))

ans=[]

A_dict={}

for n in range(N):
    a = A.popleft()
    A_dict[a]=n+1
    
for n in range(N):
    ans.append(A_dict[n+1])

# print(*ans, sep=' ')

Submission status: Runtime Error

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

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

for i in range(B):
    print(i)

Submission status: Runtime Error

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

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

Submission status: Runtime Error

Solution code:
n=int(input())
a=list(map(int,input().split()))
b=[0]*n
c=''
x=0
for i in a:
  x+=1
  b[i-1]=x
for j in b:
  c+=j
  c+=' '
print(c[:-1])

Submission status: Runtime Error

Solution code:
N,K=map(int, input().split())
List=list(map(int,input().split())) 
print(sum(1 for x in List if x>=K))

Submission status: Runtime Error

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

l = []
for i in range(n):
    x = l.index(i + 1) + 1
    l.append(x)
    
print(' ', join(l))

Submission status: Runtime Error

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

l = []
for i in range(n):
    x = index(i + 1) + 1
    l.append(x)
    
print(' ', join(l))

Submission status: Runtime Error

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

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

Ans = []
for j in range(N):
  ans = A_re[j][1]
  Ans.append(ans)
  
print(' '.join(Ans))

Submission status: Runtime Error

Solution code:
N = int(input())
A = list(map, input().split())
li = []
for i, a in enumerate(A):
  li += [[a,i]]

li.sort()
for i in range(N):
  print(li[1])

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int, input().split()))
l = [0] * N
ans = ""
for i in range(N):
  sys.stdout.write(A.index(i+1)+1)
  sys.stdout.write(" ")

Submission status: Runtime Error

Solution code:
import numpy as np
n = int(input())
a = list(map(int, input().split())))
print(np.argsort(a)+1)

Submission status: Runtime Error

Solution code:
n = int(input())
a = list(map(int, input().split()))
b = [i+1 for i in range(n)]
c = list(zip(a, b))
c = sorted(c)
s = " ".join(map(lambda x: x[1], c))
print(s)

Submission status: Runtime Error

Solution code:
n=int(input())
l=list(map(int,input().split()))
list=[]
for i in range(n):
  list.append([i+1,list[i]])
list.sort(key=lambda x:x[1])
ans=[]
for aa in list:
  ans.append(aa[0])
print(*ans)

Submission status: Runtime Error

Solution code:
#print#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code

#なお、任意の整数 M に対して M の −2 進数表現が一意に定まることが証明できます。
#2桁ごとに見るとよかった（もう実験したよ）
def resolve():
    N,=pin()
    A=list(pin())
    B=[(i+1,A[i]) for i in range(N)]
    B.sort(key=lambda x:x[1])
    ans=[]
    for b in B:
        ans.append(B[0])
    print(+a)
resolve()

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int, input().split()))
str = ""
for i in range(N):
  str += str(A.index(i+1)+1) + " "

Submission status: Runtime Error

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

B = [0 for i in range(N)]

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

Submission status: Runtime Error

Solution code:
import numpy as np

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

ans = []
for i in range(n):
  tmpidx = np.argmin(A)
  A[tmpidx] = np.inf
  ans.append(tmpidx+1)

print(*ans)

Submission status: Runtime Error

Solution code:
N,K = map(int,input().split())
A = list(map(int,input().split()))
ans = 0
for a in A:
  if(a >= K):ans+=1
print(ans)

Submission status: Runtime Error

Solution code:
n = int(input())
student = list(map(int,input().split()))
a = [0]*n
 
for i in range(n):
  s = student[i] #生徒が出席した番号をメモ
  a[s-1] = i+1
  
print(*ans)

Submission status: Runtime Error

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

for i in range(n):
  s = student[i] #生徒が出席した番号をメモ
  a[s-1] = i+1
  
print(ans)

Submission status: Runtime Error

Solution code:
from collections import deque
import heapq

N = int(input())
A = list(map(int, input().split()))
B = A.copy()
heapq.heapify(B)
ans = deque()

for i in range(N - 1):
    ans.append(A.index(heapq.heappop(B)) + 1)

print(" ".join(map(str, list(ans) + [A.index(B[0]) + 1])))

Submission status: Runtime Error

Solution code:
N = int(input())
A = list(map(int,input().split()))
i_a = [a,i+1 for i,a in enumerate(A)]
i_a.sort()

ans = []
for i,a in i_a:
  ans.append(a)
  
print(' '.join(map(str,ans)))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n = int(input().split())
A = list(map(int, input().split()))
A_sort = sorted(A, reverse=True)
print(*A)

Submission status: Runtime Error

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

result = []

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

result.sort()
print(result *)

Submission status: Runtime Error

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

print(list_tmp.sorted())

Submission status: Runtime Error

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

for i, name in enumerate(a):
  a_sort[name-1] = i + 1
print(' '.join(a_sort))

Submission status: Runtime Error

Solution code:
n = int(input())
aa = list(map(int, input().split()))
oo = [str(a) for a in np.argsort(aa)+1] 
print(" ".join(oo))

Submission status: Runtime Error

Solution code:
n=int(input())
a=list(map(int,input().split()))
b=list(for _ in range(1,n+1))
ab=list(zip(a,b))
ab.sort()
l=(ab[i][1] for i in range(n))
print(list(l))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
import numpy as np
_ = input()
hoge = np.array(list(map(int, input().split())))

res = ''
for i in np.argsort(hoge):
  res += str(i) + ' '
print(res[:-1]

Submission status: Runtime Error

Solution code:
n = int(input())
a = map(int,input().split())
ans = [0]*n
for i,j in enumerate(a,start=1):
  ans[j] = i
for i in range(n):
  print(ans[i],' ', end='')

Submission status: Runtime Error

Solution code:
N=int(input())
A=list(map(int,input().split()))
b=sorted(A)
c=[0]*N
for i in range(N):
  c[A[i]-1]=b[i]
for i in range(N)
  print(c[i])

Submission status: Runtime Error

Solution code:
def ri(): return int(input())
def rli(): return list(map(int, input().split()))
def rls(): return list(map(str, input().split()))
def pl(a): print(" ".join(list(map(str, a))))
def ma():return map(int,input().split())
def nli(x):return [input for _ in range(x)]
def hukusuu(): 
  listA=[] #appendのために宣言が必要
  while True:
    try:listA.append(list(map(int,input().split())))
    except:break #または、quit(),os.exit()をして止める。
  return listA
from itertools import accumulate as acc 
import operator as op
import copy as cp
import math
from bisect import bisect_left as bisl
from bisect import bisect_right as bisr
def ifif(s):
  if s:print("Yes")
  else:print("No")

n=ri()  
a=rli()
b=[0]*n
for k in range(len(a))
  b(a[k])=k

print(" ".join(b))

Submission status: Runtime Error

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

answer = [0] * len(A)
for i, Ai, in enumerate(A):
    answer[Ai - 1] = str(i + 1)
answer = ' '.join(answer)

print(answer)

Submission status: Runtime Error

Solution code:
n = int(input())
a = [int(i) for i in input().split()]
out = [] * n
for i in range(n):
    out[i] = (str(a.index(n-i)+1))
print(' '.join(out[::-1]))

Submission status: Runtime Error

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

ans = []
for i in range(N):
	 arrival_order= i+1
	 student_num = A.index(arrival_order)+1
	 ans.append(str(student_num))
	 A.pop(arrival_order)

print(" ".join(ans))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
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(' '.joint(rank.values()))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n=int(input())
A=list(map(int,input.split())
h=[]
for i in range(1,n+1)
       h.append(A.index(i)+1)
print(*h)

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
N = int(input())
A = list(map(int,input().split()))
for i in range(1,N+1):
    B.append(A.index(i)+1)
print(' '.join(map(str,B)))

Submission status: Runtime Error

Solution code:
N = int(input())
A = list(map(int,input().split()))
for i in range(1,N+1):
    B.append(A.index(i)+1)
print(' '.join(map(int,B)))

Submission status: Runtime Error

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

Submission status: Runtime Error

Solution code:
n = int(input())
a = list(map(int,input().split()))
b = [[0,0]*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)