สรุป

รับรายการจำนวนเต็มคืนค่าดัชนีแต่ละจำนวนเต็มท้ายเมื่อเรียง

ตัวอย่างเช่นถ้ารายการเป็นคุณควรกลับ[0,8,-1,5,8] [1,3,0,2,4]โปรดทราบว่าทั้งสอง8รักษาลำดับของพวกเขาสัมพันธ์กับแต่ละอื่น ๆ (เรียงลำดับมีเสถียรภาพ)

ใส่วิธีอื่น: สำหรับแต่ละองค์ประกอบในรายการให้คืนจำนวนองค์ประกอบในรายการที่มีขนาดเล็กกว่าองค์ประกอบที่เลือกหรือ (เท่ากับองค์ประกอบและปรากฏขึ้นก่อนองค์ประกอบที่เลือก)

ดัชนีจะต้องเริ่มต้นด้วย 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แม้ว่าเราจะเห็นว่ามันสามารถทำให้เรามีรายชื่อนี้ได้อย่างง่ายดาย ได้แก่ตำแหน่งของ0ใน⍋xบอกเราที่องค์ประกอบที่เล็กที่สุดจะจบลงหลังจากการเรียงลำดับและตำแหน่งของ1ใน⍋xบอกเราที่องค์ประกอบที่เล็กที่สุดที่สองจะจบลง ฯลฯ

แต่เรารู้ว่า⍋xมีตัวเลข[0, 1 … n − 1]ทุกประการ ถ้าเราเกรดมันอีกครั้งเราก็จะได้รับดัชนีของ0ใน⍋xนั้นดัชนีของ1ใน⍋xเป็นต้นซึ่งเป็นสิ่งที่เรากำลังอยู่ในความสนใจ

⍋⍋xดังนั้นคำตอบคือ

เยลลี่ 2 ไบต์

ỤỤ

เกรดขึ้นสองครั้ง 1 การจัดทำดัชนี ลองออนไลน์!

JavaScript 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! เด็ดสุด ๆ ลองดู

Haskell, 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..]ใช้กับอินพุตสองครั้งนั่นคือจับคู่แต่ละองค์ประกอบ e กับดัชนีของ i ((e,i) ) เรียงลำดับเอาองค์ประกอบแรกออก ทำซ้ำหนึ่งครั้ง

@Lynn มาพร้อมกับm=map snd.sort.(`zip`[0..])จำนวนไบต์เดียวกัน

Python 2, 67 60 ไบต์

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

ขอบคุณ @xnor สำหรับการเล่นกอล์ฟขนาด 7 ไบต์!

ทดสอบบน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 ไบต์

บันทึก 4 ไบต์ด้วย @Luis

&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

ลองออนไลน์

Python 2, 67 ไบต์

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

xnor บันทึกสองไบต์

Haskell, 40 ไบต์

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

ใส่คำอธิบายประกอบแต่ละองค์ประกอบด้วยดัชนีของมันจากนั้นจับคู่แต่ละองค์ประกอบเข้ากับจำนวนองค์ประกอบที่มีขนาดเล็กลง ไม่มีการเรียงลำดับ

Julia อายุ 17 ไบต์

~=sortperm;!x=~~x

1 การจัดทำดัชนี เกรดขึ้น ( sortperm) สองครั้งลองที่นี่

แก้ไข: Dennis บันทึกสี่ไบต์ด้วยการตั้งชื่อโอเปอเรเตอร์ y จูเลียแปลก ๆ

JavaScript (ES6), 52 ไบต์

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

กำหนดgเป็นฟังก์ชันระดับซึ่งจะส่งกลับอาร์เรย์ของดัชนีที่องค์ประกอบทั้งหมดในอาร์เรย์ที่เรียงลำดับจะมาจากในอาร์เรย์เดิม น่าเสียดายที่สิ่งที่เราต้องการคือดัชนีที่องค์ประกอบทั้งหมดจะไป โชคดีที่สิ่งนี้กลายเป็นการแมปจากคะแนนกลับไปยังรายการดัชนีดั้งเดิมซึ่งสามารถพิจารณาได้ว่าเป็นผลของการเรียงลำดับคะแนนดังนั้นเราจึงสามารถใช้คะแนนเกรดเพื่อให้ได้ผลลัพธ์ตามที่ต้องการ

Pyth, 10 9 ไบต์

1 ไบต์ขอบคุณ Jakube

xLo@QNUQU

ชุดทดสอบ

มีต้องเป็นวิธีที่สั้น ...

Racket, 117 bytes

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

I am eternally disappointed by the lack of a builtin for this.

Ruby, 54 53 bytes

Try it online

-1 byte from upgrading to @Downgoat's approach of using a hash to store values instead of counting the duplicates each time.

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

Clojure, 83 bytes

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

I create an anonymous function that grades the input array up and iterate it twice on the input. The first call will return the grade. The second call operates on the grade and returns the rank.

Brachylog, 27 bytes

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

Try it online! or verify all test cases.

Explanation

This is a straightforward implementation of the following relationship: each integer of the output corresponding to an element of the input is the index of that element in the sorted input.

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 bytes

(o=Ordering)@*o

Mathematica, 135 bytes

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

Common Lisp, 117 bytes

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

Apply a Schwartzian transform twice.

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

Test

(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 (using external library) (105 bytes)

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

Link to lib: https://github.com/mvegh1/Enumerable Explanation of code: Create anonymous method that accepts a list of integers. _.From creates an instance of the library that wraps an array with special methods. Select maps each item to a new item, by taking the "v"alue, parsing it to a string, then concatenating the "i"ndex of that item (this solves duplicate value case). Thats stored in variable 'a'. Then we return the result of the following: Map each item in 'a' to the index of that item in the sorted version of a (as integers), and cast back to a native JS array

Note that negative duplicate numbers seem to print in the reverse order. I'm not sure if that invalidates this solution? Technically 8,10,4,-1,-1,8 should be 3,5,2,0,1,4 according to OP but my code is printing 3,5,2,1,0,4 which I believe is still technically valid?

GNU Core Utils, 39 33 bytes

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

Produces 1-based output. Add -v0 after the second nl to get 0-based output. (+4 bytes)

Commands we are using:

• nl adds line numbers to each line of the input.
• sort -n -k 2 sorts by column 2 numerically.
• cut -f 1 takes the first Tab-delimited column, discarding the rest.

Additionally, the -s option can be passed to sort to request a stable sort, but we don't need it here. If two items are identical, sort will determine their order by falling back to the other columns, which in this case is the monotonically increasing output from nl. So the sort will be stable without needing to specify it, by virtue of the input.

Java 149 140 bytes

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

Golfed

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

Thanks to @Kevin Cruissjen for shaving of 9 bytes.

PHP, 88 bytes

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

operates on command line arguments; prints 0-indexed, underscore-separated list. Run with -nr.

breakdown

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 bytes

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

Most of MATLAB's sorting built-ins will return an optional second array containing the sorted indices. The j= could be removed if printing the indices is acceptable, rather than returning them.

CJam, 19 bytes

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

Try it online!

Explanation:

_ 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