Tóm lược

Đưa ra một danh sách các số nguyên, trả về chỉ mục mỗi số nguyên sẽ kết thúc khi được sắp xếp.

Ví dụ, nếu danh sách là [0,8,-1,5,8], bạn nên trả lại [1,3,0,2,4]. Lưu ý rằng hai 8s duy trì trật tự của chúng so với nhau (sắp xếp ổn định).

Đặt một cách khác: Đối với mỗi phần tử trong danh sách, hãy trả về số phần tử trong danh sách: Nhỏ hơn phần tử đã chọn HOẶC (bằng phần tử AND xuất hiện trước phần tử đã chọn)

Các chỉ mục phải bắt đầu bằng 0 (không phải 1) EDIT: với mức đẩy lùi lớn, tôi sẽ cho phép các chỉ báo dựa trên 1.

Các trường hợp thử nghiệm:

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 byte

⍋⍋

Các cấp độ nâng cấp trên nền tảng tích hợp, được áp dụng hai lần. Hoạt động nếu lập chỉ mục bắt đầu từ 0, không phải là mặc định cho tất cả các hương vị của APL. Hãy thử nó ở đây!

Tại sao điều này làm việc?

⍋xtrả về một danh sách các chỉ số sẽ sắp xếp ổn địnhx . Ví dụ:

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

bởi vì nếu bạn lấy phần tử 2, thì 6, 3bạn sẽ có được một danh sách được sắp xếp ổn định:

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

Nhưng danh sách chỉ mục trả lời câu hỏi này khác biệt một cách tinh tế: đầu tiên chúng tôi muốn chỉ mục của phần tử nhỏ nhất, sau đó nhỏ nhất thứ hai, v.v. - một lần nữa, giữ nguyên thứ tự ban đầu.

Nếu chúng ta nhìn vào ⍋x, tuy nhiên, chúng ta thấy nó có thể cung cấp cho chúng tôi danh sách này một cách dễ dàng: các vị trí của một 0trong ⍋xcho chúng ta biết nơi phần tử nhỏ nhất sẽ kết thúc sau khi phân loại, và vị trí của một 1trong ⍋xcho chúng ta biết nơi phần tử nhỏ nhất thứ hai sẽ kết thúc v.v.

Nhưng chúng tôi biết ⍋xcó chứa chính xác các số [0, 1 Giành n − 1] . Nếu chúng ta cấp nó một lần nữa , chúng tôi sẽ chỉ nhận được những chỉ số 0trong ⍋x, sau đó chỉ số của 1trong ⍋x, vv, mà chính xác là những gì chúng tôi đang quan tâm.

Vì vậy, câu trả lời là ⍋⍋x.

Thạch, 2 byte

ỤỤ

Lên lớp hai lần. 1 chỉ mục. Hãy thử trực tuyến!

JavaScript ES6, 87 82 79 74 70 byte

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

Không thích sử dụng một đối tượng nhưng dường như đó là cách ngắn nhất để theo dõi các bản sao

Giải trình

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

<<

Lên lớp ( <) hai lần. JohnE đã lưu ba byte bằng cách chỉ ra các biểu thức ngầm tồn tại trong K! Siêu mát. Hãy thử nó.

Haskell, 50 48 byte

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

Ví dụ sử dụng: m.m $ [4,4,0,1,1,2,0,1]-> [6,7,0,2,3,5,1,4].

Nó map snd.sort.zip x [0..]được áp dụng hai lần cho đầu vào, tức là ghép từng phần tử e với chỉ số i ( (e,i)), sắp xếp nó loại bỏ các phần tử đầu tiên. Lặp lại một lần.

@Lynn đã đưa ra m=map snd.sort.(`zip`[0..])cái có cùng số byte.

Python 2, 67 60 byte

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

Cảm ơn @xnor vì đã chơi golf 7 byte!

Kiểm tra nó trên Ideone .

PowerShell v2 +, 63 byte

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

Đưa đầu vào $n, đường ống qua một vòng lặp trên mọi phần tử |%{...}. Mỗi lần lặp, chúng tôi sort $nvà nhận được IndexOfphần tử hiện tại của chúng tôi $_. Điều này đếm có bao nhiêu mục nhỏ hơn phần tử hiện tại. Chúng tôi thêm vào đó một lát $n, mở rộng mọi vòng lặp của các phần tử bằng với phần tử hiện tại $_và lấy phần tử .Countđó. Sau đó, chúng tôi trừ đi -1để chúng tôi không tính yếu tố hiện tại của chúng tôi và con số đó được để lại trên đường ống dẫn. Đầu ra ở cuối là ẩn.

Ví dụ

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 byte

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

Hãy thử trực tuyến!

Giải trình

{             }       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 byte

/:^:2

Xếp loại ( /:) hai lần ( ^:2). Chỉ số 0.

Để thử nó ra, gõ f =: /:^:2và sau đó f 4 4 0 1 1 2 0 1vào tryj.tk .

MATL, 10 9 4 byte

4 byte được lưu nhờ @Luis

&S&S

Giải pháp này sử dụng lập chỉ mục dựa trên 1

Dùng thử trực tuyến

05AB1E, 12 byte

2FvyN‚}){€¦˜

Giải thích

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

Dùng thử trực tuyến

Python 2, 67 byte

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

xnor lưu hai byte.

Haskell, 40 byte

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

Chú thích từng phần tử với chỉ mục của nó, sau đó ánh xạ từng phần tử với số phần tử nhỏ hơn, kết hợp trên chỉ mục. Không phân loại.

Julia, 17 byte

~=sortperm;!x=~~x

1 chỉ mục. Lên lớp ( sortperm) hai lần. Hãy thử nó ở đây.

EDIT: Dennis đã lưu bốn byte bằng cách đặt tên toán tử-y! Julia thật kỳ lạ.

JavaScript (ES6), 52 byte

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

Xác định glà hàm lớp, trả về một mảng các chỉ mục mà tất cả các phần tử trong mảng được sắp xếp sẽ đến từ trong mảng ban đầu. Thật không may, những gì chúng ta muốn là các chỉ số mà tất cả các yếu tố sẽ đi đến. May mắn thay, điều này hóa ra là ánh xạ từ lớp trở lại danh sách các chỉ số ban đầu, chính nó có thể được coi là kết quả của việc sắp xếp điểm, do đó cho phép chúng tôi lấy điểm của lớp để đạt được kết quả mong muốn.

Bình thường, 10 9 byte

1 byte nhờ Jakube.

xLo@QNUQU

Bộ thử nghiệm.

Có phải là một cách ngắn ...

Vợt, 117 byte

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

Tôi thất vọng vĩnh viễn vì thiếu một nội dung cho việc này.

Ruby, 54 53 byte

Dùng thử trực tuyến

-1 byte từ việc nâng cấp lên phương pháp sử dụng hàm băm của @ Downgoat để lưu trữ giá trị thay vì đếm các lần trùng lặp mỗi lần.

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

Clojure, 83 byte

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

Tôi tạo một hàm ẩn danh xếp hạng mảng đầu vào lên và lặp lại hai lần trên đầu vào. Cuộc gọi đầu tiên sẽ trả lại điểm. Cuộc gọi thứ hai hoạt động trên lớp và trả về thứ hạng.

Brachylog , 27 byte

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

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Đây là một triển khai đơn giản của mối quan hệ sau: mỗi số nguyên của đầu ra tương ứng với một phần tử của đầu vào là chỉ mục của phần tử đó trong đầu vào được sắp xếp.

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

Toán học, 15 byte

(o=Ordering)@*o

Toán học, 135 byte

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

Lisp thông thường, 117 byte

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

Áp dụng một biến đổi Schwartzian hai lần.

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

Kiểm tra

(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 (sử dụng thư viện bên ngoài) (105 byte)

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

Liên kết đến lib: https://github.com/mvegh1/Enumerable Giải thích mã: Tạo phương thức ẩn danh chấp nhận danh sách các số nguyên. _Từ việc tạo một thể hiện của thư viện bao bọc một mảng bằng các phương thức đặc biệt. Chọn ánh xạ từng mục vào một mục mới, bằng cách lấy "v" alue, phân tích nó thành một chuỗi, sau đó ghép nối "i" ndex của mục đó (điều này giải quyết trường hợp giá trị trùng lặp). Đó là lưu trữ trong biến 'a'. Sau đó, chúng tôi trả kết quả của các mục sau: Ánh xạ từng mục trong 'a' vào chỉ mục của mục đó trong phiên bản đã sắp xếp của một (dưới dạng số nguyên) và chuyển trở lại một mảng JS gốc

Lưu ý rằng các số trùng lặp âm dường như in theo thứ tự ngược lại. Tôi không chắc chắn nếu điều đó làm mất hiệu lực giải pháp này? Về mặt kỹ thuật 8,10,4, -1, -1,8 phải là 3,5,2,0,1,4 theo OP nhưng mã của tôi đang in 3,5,2,1,0,4 mà tôi tin là vẫn còn hiệu lực về mặt kỹ thuật?

Sử dụng GNU Core, 39 33 byte

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

Sản xuất đầu ra dựa trên 1. Thêm -v0sau lần thứ hai nlđể có đầu ra dựa trên 0. (+4 byte)

Các lệnh chúng tôi đang sử dụng:

• nl thêm số dòng cho mỗi dòng của đầu vào.
• sort -n -k 2 sắp xếp theo cột 2 bằng số.
• cut -f 1 lấy cột được phân định bằng Tab đầu tiên, loại bỏ phần còn lại.

Ngoài ra, -stùy chọn có thể được chuyển qua để sortyêu cầu một loại ổn định, nhưng chúng tôi không cần nó ở đây. Nếu hai mục giống hệt nhau, sortsẽ xác định thứ tự của chúng bằng cách rơi trở lại các cột khác, trong trường hợp này là sản lượng tăng đơn điệu từ đó nl. Vì vậy, sắp xếp sẽ ổn định mà không cần chỉ định nó, nhờ vào đầu vào.

Java 149 140 byte

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;
}

Chơi gôn

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;}

Cảm ơn @Kevin Cruissjen đã cạo 9 byte.

PHP, 88 byte

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

hoạt động trên các đối số dòng lệnh; in danh sách 0 được lập chỉ mục, gạch dưới. Chạy với -nr.

phá vỡ

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 byte

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

Hầu hết các phần tử sắp xếp của MATLAB sẽ trả về một mảng thứ hai tùy chọn có chứa các chỉ mục được sắp xếp. Cácj= thể được gỡ bỏ nếu in các chỉ số được chấp nhận, thay vì trả lại chúng.

Camam , 19 byte

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

Hãy thử trực tuyến!

Giải trình:

_ 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