摘要

给定一个整数列表，返回每个整数在排序时以其结尾的索引。

例如，如果列表为[0,8,-1,5,8]，则应返回[1,3,0,2,4]。请注意，两个8保持彼此相对的顺序（排序是稳定的）。

换句话说，对于列表中的每个元素，返回列表中的元素数量：小于所选元素OR（等于元素AND出现在所选元素之前）

索引必须以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

因为如果采用element 2，then 6，then 3…，则会得到一个稳定排序的列表：

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

但是，回答这个问题的索引列表有细微的不同：首先，我们想要最小元素的索引，然后是第二最小元素，依此类推-再次，保持原始顺序。

如果我们看一下⍋x，虽然，我们看到它可以很容易地给我们这个列表：在位置一的0在⍋x告诉我们，其中最小的元素将排序后结束，并且位置一的1在⍋x告诉我们，其中第二最小元素竟又等

但是我们知道⍋x确切包含数字[0，1…n-1]。如果我们再次对其评分，我们只会得到0in 的索引⍋x，然后是1in 的索引⍋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字节

@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

在线尝试

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]

使用索引为其注释，然后将每个元素映射到较小元素的数量，并在索引上进行平局。没有排序。

朱莉娅，17个字节

~=sortperm;!x=~~x

1个索引。升级（sortperm）两次。在这里尝试。

编辑：丹尼斯通过给东西操作员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

测试套件。

有必须是一个较短的方式...

球拍，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)))))

对此我缺乏内置的功能，我永远感到失望。

Ruby，54 53字节

在线尝试

从-1字节升级到@Downgoat的方法是使用哈希存储值，而不是每次都计算重复项。

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

Clojure，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]

普通Lisp，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”别名，将其解析为字符串，然后将该项目的“ i” ndex连接起来（这解决了重复值的情况）。多数民众赞成在存储在变量“一”。然后，我们返回以下结果：将'a'中的每个项目映射到a的排序版本中（以整数形式）的该项目的索引，然后转换回本机JS数组

请注意，负重复数字似乎以相反的顺序打印。我不确定是否会使该解决方案无效？从技术上来说，根据OP，8,10,4，-1，-1,8应该是3,5,2,0,1,4，但我的代码是打印3,5,2,1,0,4，我相信是在技​​术上仍然有效？

GNU Core Utils，39 33字节

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

产生基于1的输出。-v0在第二秒之后添加nl以获取从0开始的输出。（+4个字节）

我们正在使用的命令：

• nl 将行号添加到输入的每一行。
• sort -n -k 2 按第2列按数字排序。
• cut -f 1 用第一行制表符分隔的列，其余的丢弃。

另外，-s可以将选项传递给以sort请求稳定排序，但是我们在这里不需要它。如果两个项目相同，sort将通过回退到其他列来确定其顺序，在这种情况下，这是从中单调增加的输出nl。因此，借助于输入，排序将是稳定的，而无需指定它。

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

感谢@Kevin Cruissjen整理了9个字节。

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