개요

정수 목록이 주어지면 각 정수가 정렬 될 때 끝나는 색인을 반환하십시오.

예를 들어 목록이 [0,8,-1,5,8]이면을 반환해야합니다 [1,3,0,2,4]. 두 8s가 서로에 대해 순서를 유지 한다는 점에 유의하십시오 (정렬).

다른 방법으로 넣으십시오. 목록의 각 요소에 대해 다음과 같은 목록의 요소 수를 리턴하십시오. 선택한 요소보다 작음 OR (요소와 같고 선택한 요소 앞에 나타남)

인덱스는 0 (1 아님)으로 시작해야합니다. 편집 : 큰 푸시 백이 주어지면 1 기반 인덱스를 허용합니다.

테스트 사례 :

0                -> 0
23               -> 0
2,3              -> 0,1
3,2              -> 1,0
2,2              -> 0,1
8,10,4,-1,-1,8   -> 3,5,2,0,1,4
0,1,2,3,4,5,6,7  -> 0,1,2,3,4,5,6,7
7,6,5,4,3,2,1,0  -> 7,6,5,4,3,2,1,0
4,4,0,1,1,2,0,1  -> 6,7,0,2,3,5,1,4
1,1,1,1,1,1,1,1  -> 0,1,2,3,4,5,6,7
1,1,1,1,1,1,1,0  -> 1,2,3,4,5,6,7,0

APL, 2 바이트

⍋⍋

"그레이드 업"내장, 두 번 적용. 인덱싱이 0에서 시작하는 경우 작동합니다. APL의 모든 특징에 대한 기본값은 아닙니다. 여기 사용해보십시오!

왜 이것이 작동합니까?

⍋x안정적으로 정렬되는 인덱스 목록을x 반환합니다 . 예를 들면 다음과 같습니다.

    x ← 4 4 0 1 1 2 0 1
    ⍋x
2 6 3 4 7 5 0 1

당신이 요소를 가지고가는 경우에 있기 때문에 2, 다음 6, 다음 3... 당신은 안정적으로 정렬 된 목록을 얻을 :

    x[⍋x]
0 0 1 1 1 2 4 4

그러나이 질문에 답하는 색인 ​​목록은 미묘하게 다릅니다. 먼저 가장 작은 요소의 색인을 원하고 그 다음으로 작은 항목을 원합니다. 다시 원래 순서대로 유지하십시오.

그러나을 살펴보면 ⍋x이 목록을 쉽게 얻을 수 있다는 것을 알 수 있습니다. in 의 위치 는 정렬 후 가장 작은 요소가 끝나는 위치 를 알려주고 in 의 위치 는 두 번째로 작은 요소가 끝나는 위치 를 알려줍니다 등0⍋x1⍋x

그러나 우리 ⍋x는 숫자 [0, 1… n-1]을 정확히 포함하고 있다는 것을 알고 있습니다 . 우리는 등급을하면 다시 , 우리는 단지의 인덱스거야 0에서 ⍋x의 다음 인덱스 1에 ⍋x우리가 관심을하는지 정확하게, 등.

대답은 ⍋⍋x입니다.

젤리, 2 바이트

ỤỤ

두 번 등급을 매기십시오. 1- 색인. 온라인으로 사용해보십시오!

자바 스크립트 ES6, 87 82 79 74 70 바이트

(a,b={})=>a.map(l=>[...a].sort((a,b)=>a-b).indexOf(l)+(b[l]=b[l]+1|0))

물건을 사용하는 것을 좋아하지 않지만 속력을 추적하는 가장 짧은 방법 인 것 같습니다.

설명

(a,b={})=>          `a` is input
                    `b` stores the occurrences of each number
  a.map(l =>        Loop over the array, `l` is item
  [...a]            Copy `a`
    .sort(...)       Sort in ascending numerical order
    .indexOf(l)      Index of input in that array
  +                 Add the following to account for dupes
   (b[l]=            set and return the item `l` in hashmap `b` to...
     b[l]+1           Increase the counter by one if it exists yet
     |0               default is zero
   )

K , 5 2 바이트

<<

<두 번 등급을 매 깁니다 ( ). JohnE는 K에 존재하는 암묵적인 표현을 지적함으로써 3 바이트를 절약했습니다! 슈퍼 쿨. 사용해보십시오.

하스켈, 50 48 바이트

import Data.List
m x=map snd$sort$zip x[0..]
m.m

사용 예 : m.m $ [4,4,0,1,1,2,0,1]-> [6,7,0,2,3,5,1,4].

이것은있어 map snd.sort.zip x [0..]입력에 두번 도포 즉 그것의 인덱스 I (각 요소, 즉 짝 (e,i)정렬이 첫번째 요소를 제거). 한 번 반복하십시오.

@Lynn은 m=map snd.sort.(`zip`[0..])동일한 바이트 수를 가진 것으로 나타났습니다 .

파이썬 2, 67 60 바이트

def f(x):x=zip(x,range(len(x)));print map(sorted(x).index,x)

7 바이트를 골라 낸 @xnor에게 감사드립니다!

Ideone에서 테스트하십시오 .

PowerShell v2 +, 63 바이트

param($n)$n|%{($n|sort).IndexOf($_)+($n[0..$i++]-eq$_).count-1}

입력을 $n받아 모든 요소에 루프를 통해 파이프를 전달합니다 |%{...}. 반복 할 때마다 현재 요소를 sort $n얻습니다 . 현재 요소보다 작은 항목 수를 계산합니다. 여기에 현재 요소 와 동일한 요소의 모든 루프 반복을 확장 하는 슬라이스를 추가하고 그 요소 를 가져옵니다 . 그런 다음 현재 요소를 계산하지 않도록 빼고 그 수는 파이프 라인에 남습니다. 마지막 출력은 암시 적입니다.IndexOf$_$n$_.Count-1

예

PS C:\Tools\Scripts\golfing> .\ordering-a-list.ps1 @(4,4,0,1,1,2,0,1)
6
7
0
2
3
5
1
4

PS C:\Tools\Scripts\golfing> .\ordering-a-list.ps1 @(8,10,4,-1,-1)
3
4
2
0
1

CJam, 15 바이트

{{eeWf%$1f=}2*}

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

설명

{             }       Delimits an anonymous block.
 {         }2*        Run this block on the argument twice:
  ee                  Enumerate ([A B C] → [[0 A] [1 B] [2 C]])
    Wf%               Reverse each ([[A 0] [B 1] [C 2]])
       $              Sort the pairs lexicographically;
                        i.e. first by value, then by index.
        1f=           Keep the indices.

J, 5 바이트

/:^:2

등급을 매기고 ( /:) 두 번 ( ^:2). 인덱스가 0입니다.

입력, 그것을 밖으로 시도하려면 f =: /:^:2다음 f 4 4 0 1 1 2 0 1에 tryj.tk .

MATL, 10 9 4 바이트

@Luis 덕분에 4 바이트 절약

&S&S

이 솔루션은 1 기반 인덱싱을 사용합니다.

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

05AB1E, 12 바이트

2FvyN‚}){€¦˜

설명

2F            # 2 times do
  vyN‚})      # create list of [n, index]-pairs
        {€¦   # sort and remove first element leaving the index
           ˜  # deep flatten
              # implicit output

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

파이썬 2, 67 바이트

a=input()
p=[]
for x in a:print sorted(a).index(x)+p.count(x);p+=x,

xnor은 2 바이트를 절약했습니다.

하스켈, 40 바이트

f l|z<-zip l[0..]=[sum[1|y<-z,y<x]|x<-z]

각 요소에 인덱스를 주석으로 추가 한 다음 각 요소를 더 작은 요소 수에 매핑하여 인덱스를 묶습니다. 정렬하지 않습니다.

줄리아, 17 바이트

~=sortperm;!x=~~x

1- 색인. sortperm두 번 등급을 매 깁니다 ( ). 여기에서 시도하십시오.

편집 : Dennis 는 물건에 연산자 이름을 지정하여 4 바이트를 절약했습니다 ! 줄리아는 이상하다.

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

a=>(g=a=>[...a.keys()].sort((n,m)=>a[n]-a[m]))(g(a))

g정렬 된 배열의 모든 요소가 원래 배열에서 온 인덱스 배열을 반환하는 grade 함수로 정의합니다 . 불행하게도 우리가 원하는 것은 모든 요소가 갈 인덱스입니다. 운 좋게도 이것은 등급에서 원래 지수 목록으로 다시 매핑되는 것으로 판명되었으며, 그 자체는 등급을 정렬 한 결과로 간주 될 수 있으므로 원하는 등급을 얻기 위해 등급의 등급을 취할 수 있습니다.

Pyth, 10 9 바이트

Jakube 덕분에 1 바이트.

xLo@QNUQU

테스트 스위트.

더 짧은 방법 이 있어야합니다 ...

라켓, 117 바이트

(λ(x)(build-list(length x)(λ(h)((λ(y)(+(count(λ(z)(< z y))x)(count(λ(z)(eq? z y))(take x h))))(list-ref x h)))))

나는 이것에 대한 내장이 부족하여 영원히 실망합니다.

루비, 54 53 바이트

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

매번 중복을 계산하는 대신 해시를 사용하여 값을 저장하는 @Downgoat의 접근 방식으로 업그레이드에서 -1 바이트.

->a{b={};a.map{|e|a.sort.index(e)+b[e]=(b[e]||-1)+1}}

클로저, 83 바이트

(fn[a](nth(iterate #(->> %(map-indexed(comp vec rseq vector))sort(map second))a)2))

입력 배열의 등급을 매기고 입력에서 두 번 반복하는 익명 함수를 만듭니다. 첫 번째 전화는 성적을 반환합니다. 두 번째 통화는 등급에서 작동하고 순위를 반환합니다.

Brachylog , 27 바이트

lL-M,?og:MjO,L~l.#d:Orz:ma?

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

이것은 다음 관계의 간단한 구현입니다. 입력 요소에 해당하는 출력의 각 정수는 정렬 된 입력에서 해당 요소의 인덱스입니다.

Example input: [3:2]

lL               L is the length of the input (e.g L=2)
  -M,            M = L-1 (e.g. M=1)
?o               Sort the input...
  g:MjO,         ... and create a list O with L copies of the input (e.g. O=[[2:3]:[2:3]])
L~l.             Output is a list of length L (e.g. [I:J])
    #d           All elements of the output must be distinct (e.g. I≠J)
      :Orz       Zip O with the output (e.g. [[[2:3]:I]:[[2:3]:J]])
          :ma?   Apply predicate Member with that zip as input and the input as output
                 (e.g. 3 is the Ith element of [2:3] and 2 is the Jth element of [2:3])

Mathematica, 15 바이트

(o=Ordering)@*o

Mathematica, 135 바이트

Function[{list}, SortBy[MapIndexed[Join[{#1}, #2]&, Sort@MapIndexed[Join[{#1}, #2] &, list]], #[[1, 2]] &][[All, 2]] - 1]

공통 리스프, 117 바이트

(flet((i(Z)(mapcar'cdr(stable-sort(loop for e in Z for x from 0 collect(cons e x))'< :key'car))))(lambda(L)(i(i L))))

Schwartzian 변환을 두 번 적용하십시오 .

;; FIRST TIME

(0 8 -1 5 8)
;; add indexes
((0 . 0) (8 . 1) (-1 . 2) (5 . 3) (8 . 4))
;; sort by first element
((-1 . 2) (0 . 0) (5 . 3) (8 . 1) (8 . 4))
;; extract second elements
(2 0 3 1 4)

;; SECOND TIME

(2 0 3 1 4)
;; indexes
((2 . 0) (0 . 1) (3 . 2) (1 . 3) (4 . 4))
;; sort by first element
((0 . 1) (1 . 3) (2 . 0) (3 . 2) (4 . 4))
;; extract second elements
(1 3 0 2 4)

테스트

(let ((fn (flet((i(Z)(mapcar'cdr(stable-sort(loop for e in Z for x from 0 collect(cons e x))'< :key'car))))(lambda(L)(i(i L))))))
  (every
   (lambda (test expected)
     (equal (funcall fn test) expected))

   '((0) (23) (2 3) (3 2) (2 2) (8 10 4 -1 -1 8) (0 1 2 3 4 5 6 7)
     (7 6 5 4 3 2 1 0) (4 4 0 1 1 2 0 1) (1 1 1 1 1 1 1 1) (1 1 1 1 1 1 1 0))

   '((0) (0) (0 1) (1 0) (0 1) (3 5 2 0 1 4) (0 1 2 3 4 5 6 7) (7 6 5 4 3 2 1 0)
     (6 7 0 2 3 5 1 4) (0 1 2 3 4 5 6 7) (1 2 3 4 5 6 7 0))))
=> T

JavaScript (외부 라이브러리 사용) (105 바이트)

(n)=>{var a=_.From(n).Select((v,i)=>v+""+i);return a.Select(x=>a.OrderBy(y=>(y|0)).IndexOf(x)).ToArray()}

lib에 링크 : https://github.com/mvegh1/Enumerable 코드 설명 : 정수 목록을 허용하는 익명 메소드를 작성하십시오. _.From은 특별한 메소드로 배열을 래핑하는 라이브러리의 인스턴스를 만듭니다. Select는 "v"alue를 가져 와서 문자열로 구문 분석 한 다음 해당 항목의 "i"ndex를 연결하여 각 항목을 새 항목에 맵핑합니다 (이 경우 중복 값의 경우가 해결됨). 변수 'a'에 저장됩니다. 그런 다음 다음 결과를 반환합니다. 'a'의 각 항목을 (정수로) 정렬 된 버전의 해당 항목의 색인에 매핑하고 기본 JS 배열로 캐스트합니다.

음의 중복 숫자는 역순으로 인쇄되는 것으로 보입니다. 이것이이 솔루션을 무효화하는지 확실하지 않습니까? 기술적으로 8,10,4, -1, -1,8은 OP에 따라 3,5,2,0,1,4이어야하지만 내 코드는 3,5,2,1,0,4 인쇄하고 있습니다. 여전히 기술적으로 유효합니까?

GNU 코어 유틸리티, 39 33 바이트

nl|sort -nk2|nl|sort -nk2|cut -f1

1 기반 출력을 생성합니다. 0 기반 출력을 얻으려면 -v0초 후에 추가하십시오 nl. (+4 바이트)

우리가 사용하는 명령 :

• nl 입력의 각 줄에 줄 번호를 추가합니다.
• sort -n -k 2 숫자 2를 기준으로 정렬합니다.
• cut -f 1 탭으로 구분 된 첫 번째 열을 사용하고 나머지는 버립니다.

또한 안정적인 정렬을 요청 -s하기 sort위해 옵션을 전달할 수 있지만 여기서는 필요하지 않습니다. 두 항목이 동일 sort하면 다른 열로 넘어 가서 순서를 결정합니다.이 경우에는의 단조 증가 출력입니다 nl. 따라서 입력으로 인해 정렬을 지정하지 않아도 안정적으로 정렬됩니다.

자바 149140 바이트

public int[] indexArray(int[] index){
  int[] out=new int[index.length];
  for(int i=-1;++i<index.length;){
    for(int j=-1;++i<index.length;){
      if(index[i]==Arrays.sort(index.clone())[j]){
        out[i]=j;
      }
    }
  }
  return out;
}

골프

int[]a(int[]b){int l=b.length;int[]o=new int[l];for(int i=-1;++i<l;)for(int j=-1;++i<l;)if(b[i]==Arrays.sort(b.clone())[j])o[i]=j;return o;}

9 바이트를 면도 한 @Kevin Cruissjen에게 감사합니다.

PHP, 88 바이트

unset($argv[0]);$a=$argv;sort($a);foreach($argv as$e)echo$h[$e]+++array_search($e,$a),_;

명령 행 인수에서 작동합니다. 0으로 색인화되고 밑줄로 구분 된 목록을 인쇄합니다. 로 실행하십시오 -nr.

고장

unset($argv[0]);        // remove file name from arguments
$a=$argv;               // create copy
sort($a);               // sort copy (includes reindexing, starting with 0)
foreach($argv as$e)     // loop $e through original
    echo                    // print:
        $h[$e]++            // number of previous occurences
        +array_search($e,$a)// plus position in copy 
        ,_                  // followed by underscore
    ;

MATLAB, 29 바이트

function j=f(s);[~,j]=sort(s)

MATLAB의 정렬 내장 기능은 대부분 정렬 된 인덱스를 포함하는 선택적 두 번째 배열을 반환합니다. 은 j=인덱스를 인쇄하는 대신 그들에게 반환보다 허용되는 경우 제거 될 수있다.

CJam , 19 바이트

_$:A;{A#_AWt:A;1+}%

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

설명:

_ duplicate array
 $ sort array
  :A store in variable A
    ; discard top item in stack
     {A#_AWt:A;1+} block that finds index of item and removes it from sorted array to prevent duplicates
      % map block onto every item in array