概要

整数のリストが与えられると、各整数がソートされたときに終わるインデックスを返します。

たとえば、リストがの場合、[0,8,-1,5,8]を返す必要があります[1,3,0,2,4]。2つ8のsは互いに相対的な順序を維持していることに注意してください（ソートは安定しています）。

別の言い方をすると、リスト内の各要素について、リスト内の要素の数を返します。選択した要素よりも小さい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 バイト

⍋⍋

「グレードアップ」ビルトイン、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、element 、then 、3…を取得すると、安定してソートされたリストが得られるからです。

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

しかし、この質問に答えるインデックスリストは微妙に異なります。最初に最小の要素のインデックスが必要で、次に2番目に小さい要素などが必要です。再び、元の順序を維持します。

私たちが見れば⍋x：しかし、我々はそれが簡単に私たちにこのリストを与えることができます参照位置の0中では⍋x最小の要素をソートした後に終わるだろうどこを教えてくれる、と位置の1中では⍋x二番目に小さい要素が終わるだろうどこを教えてくれるなど

ただし⍋x、数字[0、1…n-1]が正確に含まれていることがわかっています。私たちは学年それをした場合、再び、私たちはただの指標取得します0で⍋xの、インデックス1中に⍋x、私たちが興味を持っているものを正確である、など、。

答えは⍋⍋xです。

ゼリー、2 バイト

ỤỤ

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

オブジェクトを使用するのは好きではありませんが、それはduを追跡する最短の方法のようです

説明

(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バイト

<<

グレードアップ（<）2回。JohnEはKに存在する暗黙の表現を指摘することで3バイトを節約しました！超かっこいい。やってみて。

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..]つまりはそれのインデックスi（と各要素eのペア、入力に2回適用(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)

7バイトのゴルフをしてくれた@xnorに感謝します！

Ideoneでテストします。

PowerShell v2 +、63バイト

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

入力を受け取り$n、すべての要素をループ処理します|%{...}。反復ごとに、現在のelement 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回（^:2）。0インデックス。

試してみるには、「tryj.tk」f =: /:^:2と入力しf 4 4 0 1 1 2 0 1てください。

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は2バイトを保存しました。

Haskell、40バイト

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

各要素にインデックスを付けてから、各要素をより小さな要素の数にマッピングし、インデックスでタイブレークします。ソートなし。

ジュリア、17バイト

~=sortperm;!x=~~x

1インデックス付き。グレードアップ（sortperm）2回。ここで試してみてください。

編集：デニスは、スタッフにy名を付けて4バイト節約しました！ジュリアは奇妙です。

JavaScript（ES6）、52バイト

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

g並べ替えられた配列のすべての要素が元の配列の元になるインデックスの配列を返すgrade関数として定義します。残念ながら、私たちが望むのは、すべての要素が行くインデックスです。幸いなことに、これはグレードから元のインデックスのリストへのマッピングであり、それ自体がグレードをソートした結果であると見なすことができるため、グレードのグレードを取得して目的の結果を得ることができます。

Pyth、10 9バイト

ジャクベのおかげで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}}

Clojure、83バイト

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

入力配列を評価し、入力で2回繰り返す匿名関数を作成します。最初の呼び出しで成績が返されます。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]

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

シュワルツ変換を 2回適用します。

;; 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」の各アイテムを、ソート済みバージョンのaのそのアイテムのインデックスに（整数として）マップし、ネイティブJS配列にキャストバックします。

負の重複番号は逆の順序で印刷されるように見えることに注意してください。それがこのソリューションを無効にするかどうかわかりませんか？技術的には8,10,4、-1、-1,8はOPによると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ベースの出力を生成します。0から始まる出力を取得する-v0には、2番目の後に追加しnlます。（+4バイト）

使用しているコマンド：

• nl 入力の各行に行番号を追加します。
• sort -n -k 2 列2で数値順にソートします。
• cut -f 1 最初のタブ区切り列を取得し、残りを破棄します。

さらに、安定したソートを要求する-sためsortにオプションを渡すことができますが、ここでは必要ありません。2つのアイテムが同一の場合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;}

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の並べ替え組み込み関数のほとんどは、並べ替えられたインデックスを含むオプションの2番目の配列を返します。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