오늘 과제는 목록을 가져 와서 정렬 된 각 연속 요소가 나타나는 l위치를 제공 하는 프로그램이나 함수를 작성하는 것 입니다.ll

즉, 가장 작은 값의 색인을 출력 한 다음 두 번째로 작은 값의 색인 등을 출력하십시오.

입력 배열은 양의 정수만 포함하고 하나 이상의 요소를 포함한다고 가정 할 수 있습니다.

테스트 사례 :

Input                  | Output (1-indexed)
[7, 4, 5]              | [2, 3, 1]
[1, 2, 3]              | [1, 2, 3]
[2, 6, 1, 9, 1, 2, 3]  | [3, 5, 1, 6, 7, 2, 4]
[4]                    | [1]

동일한 값을 가진 두 개 이상의 요소가 나타나면 해당 인덱스가 가장 작은 것부터 가장 큰 것까지 나란히 나타납니다.

이것은 code-golf 이며 가장 적은 바이트 수입니다!

젤리 , 1 바이트

Ụ

온라인으로 사용해보십시오!

Dyalog APL, 1 바이트

⍋

Dyalog APL에는이를 위해 내장 된 연산자 기능 (이를 정리해 준 Zacharý에게 감사드립니다)이 있습니다.

예

⍋11 2 4 15
    2 3 1 4  
{⍵[⍋⍵]}11 4 2 15
    2 4 11 15

여기에서는 정렬 된 인덱스로 목록을 색인하여 오름차순으로 목록을 반환합니다.

하스켈 , 43 42 바이트

1색인 :

import Data.List
map snd.sort.(`zip`[1..])

온라인으로 사용해보십시오!

-1 @ ØrjanJohansen에게 바이트 감사합니다!

파이썬 2 , 56 바이트

이 솔루션은 인덱스가 0입니다. 이것은 sorted()원래 목록의 사본 을 생성 한다는 사실을 남용합니다 .

l=input()
for k in sorted(l):a=l.index(k);print a;l[a]=0

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 39 바이트

@powelles 덕분에 -2 바이트

이것은 Array.prototype.sort안정적인 브라우저에서만 작동합니다 .

a=>[...a.keys()].sort((b,c)=>a[b]-a[c])

1 색인 버전 (47 바이트) :

a=>a.map((_,i)=>i+1).sort((b,c)=>a[b-1]-a[c-1])

코드 스 니펫 예제 :

f=
a=>[...a.keys()].sort((b,c)=>a[b]-a[c])
console.log("7,4,5 => "+f([7,4,5]))
console.log("1,2,3 => "+f([1,2,3]))
console.log("2,6,1,9,1,2,3 => "+f([2,6,1,9,1,2,3]))
console.log("4 -> "+f([4]))

파이썬 2 , 48 바이트

lambda x:sorted(range(len(x)),key=x.__getitem__)

온라인으로 사용해보십시오!

펄 6 ,  27  21 바이트

*.pairs.sort(*.value)».key

그것을 테스트

->\x{sort {x[$_]},^x}

그것을 테스트

파이썬 답변에서 영감을 얻음

넓히는:

->    # pointy block lambda
  \x  # declare sigilless parameter
{
  sort
    { x[$_] },  # sort by the value in ｢x｣ at the given position
    ^x          # Range up-to the number of elements in ｢x｣
}

배쉬 + 코어 유틸리티, 20

nl|sort -nk2|cut -f1

온라인으로 사용해보십시오 .

스위프트 4 , 82 바이트

func f(l:[Int]){var l=l;for k in l.sorted(){let a=l.index(of:k)!;print(a);l[a]=0}}

테스트 스위트.

설명

Swift l.sorted()에서 원본 배열의 정렬 된 사본을 만듭니다. 우리는 목록에서 정렬 된 요소를 반복하고 원래 배열에서 각 항목의 인덱스를로 인쇄 let a=l.index(of:k)!;print(a)한 다음 배열 에서 올바른 인덱스를 유지하기 위해 일반 출력에 영향을 미치지 않기 때문에에 할당 l[a]합니다 0.

이것은 파이썬 솔루션의 포트이기 때문에 0 인덱스입니다. 당신이 1 인덱스 싶은 경우에, 교체 print(a)로 print(a+1)또는 온라인으로보십시오! .

R , 5 바이트

이를위한 내장 함수가 있습니다.

order

루비 , 40 바이트

->a{a.zip([*1..a.size]).sort.map &:last}

온라인으로 사용해보십시오!

MATL, 2 bytes

&S

Try it online!

Input and output are implicit.

J, 2 bytes

/:

Try it online!

Zero-based indexing.

Octave, 17 bytes

@(i)[~,y]=sort(i)

Try it online!

Octave is like MATLAB but with inline assignment, making things possible that gives the folks at Mathworks HQ headaches. It doesn't matter what you call y, but you can't do without that dummy variable, as far as I know.

MY, 3 bytes

MY also has a builtin for this!

⎕⍋↵

Try it online!

How?

Evaluated input, grade up, then output with a newline.

Indexed however you set the index, with ⌶/0x48. (Can even be some weird integer like -1 or 2, the default is 1).

Java 8, 128 + 19 = 147 bytes

Based on Mr. Xcoder's solution. 0-based. Lambda takes input as an Integer[] and returns Integer[]. Byte count includes lambda expression and required import.

import java.util.*;

l->{Integer o[]=l.clone(),s[]=l.clone(),i=0;for(Arrays.sort(s);i<l.length;)l[o[i]=Arrays.asList(l).indexOf(s[i++])]=0;return o;}

Try It Online

Ungolfed lambda

l -> {
    Integer
        o[] = l.clone(),
        s[] = l.clone(),
        i = 0
    ;
    for (Arrays.sort(s); i < l.length; )
        l[o[i] = Arrays.asList(l).indexOf(s[i++])] = 0;
    return o;
}

Notes

I use Integer[] instead of int[] to allow use of Arrays.asList, which has no primitive versions. Integer is preferred to Long because values are used as array indices and would require casting.

This ended up being shorter than my best procedural-style List solution because of the cost of class and method names.

This also beat a solution I tried that streamed the inputs, mapped to (value, index) pairs, sorted on values, and mapped to indices, mostly because of the baggage needed to collect the stream.

Acknowledgments

• -5 bytes thanks to Nevay

Common Lisp, 82 bytes

(lambda(l)(loop as i in(sort(copy-seq l)'<)do(setf(elt l(print(position i l)))0)))

Try it online!

Clojure, 39 bytes

#(map key(sort-by val(zipmap(range)%)))

CJam, 12 bytes

{ee{1=}$0f=}

Try it online!

MATLAB / Octave, 29 bytes

[~,y]=sort(input(''));disp(y)

Try it online!

JavaScript (ES6), 69 bytes

0-indexed. Works for lists containing up to 65,536 elements.

a=>[...a=a.map((n,i)=>n<<16|i)].sort((a,b)=>a-b).map(n=>a.indexOf(n))

Test cases

let f =

a=>[...a=a.map((n,i)=>n<<16|i)].sort((a,b)=>a-b).map(n=>a.indexOf(n))

console.log(JSON.stringify(f([7, 4, 5])))
console.log(JSON.stringify(f([1, 2, 3])))
console.log(JSON.stringify(f([2, 6, 1, 9, 1, 2, 3])))
console.log(JSON.stringify(f([4])))

Python 3, 52 bytes

0-indexed. Based on Bruce Forte's Haskell answer here and G B's Ruby answer here.

lambda l:list(zip(*sorted(zip(l,range(len(l))))))[1]

Try it online!

Husk, 10 7 bytes

This is a direct port of my Haskell answer, also 1-indexed:

m→O`z,N

Try it online!

Ungolfed/Explained

Code        Description               Example
         -- implicit input            [2,6,1]
      N  -- natural numbers           [1,2,3,..]
   `z,   -- zip, but keep input left  [(2,1),(6,2),(1,3)]
  O      -- sort                      [(1,3),(2,1),(6,2)]
m→       -- keep only indices         [3,1,2]

Java (OpenJDK 8), 72 bytes

l->l.stream().sorted().map(i->{int j=l.indexOf(i);l.set(j,0);return j;})

Try it online!

Takes a List<Integer>, returns a Stream<Integer> containing the results.

We get a Stream based off the initial list, sort it, then map each number to it's index in the list. In order to accommodate duplicate elements, we set the original element in the list to 0.

SmileBASIC, 67 bytes

DEF I(A)DIM B[0]FOR I=1TO LEN(A)PUSH B,I
NEXT
SORT A,B
RETURN B
END

Very simple, all it does is generate a list of numbers from 1 to (length of array) and sort this by the same order as the input.

Python 3 with Numpy, 38 26 bytes

12 bytes saved thanks to Jo King (no need to give the function a name)

import numpy
numpy.argsort

Output is 0-based.

Try it online!

05AB1E, 4 bytes

ā<Σè

Try it online!

Pari/GP, 16 bytes

a->vecsort(a,,1)

Try it online!

PHP, 54 bytes

<?php function i($a){asort($a);return array_keys($a);}

Try it online!

This is zero-indexed. Simply sorts the array and returns the keys.

Tcl, 21 bytes

(0-indexed)

puts [lsort -indi $L]

Try it online!