özet

Bir tamsayı listesi göz önüne alındığında, her bir tamsayı sıralandığında sona erecek dizini döndürür.

Örneğin, liste ise [0,8,-1,5,8], geri dönmelisiniz [1,3,0,2,4]. İkisinin 8sırasını birbirlerine göre sıraladığını unutmayın (sıralama kararlıdır).

Başka bir yol belirtin: Listedeki her öğe için listedeki öğelerin sayısını döndürün: Seçili öğeden daha küçük VEYA (öğeye eşit VE seçilen öğeden önce görünür)

Endeksler 0 ile başlamalıdır (1 değil) EDIT: büyük itme durumunda, 1 tabanlı göstergelere izin vereceğim.

Test durumları:

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 bayt

⍋⍋

“Grade up” yerleşik, iki kez uygulanır. Endeksleme 0'dan başlarsa işe yarar, bu APL'nin tüm lezzetleri için varsayılan değildir. Burada dene!

Bu neden işe yarıyor?

⍋xKararlı bir şekilde sıralanacak endekslerin listesinix döndürür . Örneğin:

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

çünkü eğer eleman alırsanız 2, o 6zaman 3… kararlı bir şekilde sıralanmış bir liste alırsınız:

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

Ancak bu soruyu cevaplayan endeks listesi oldukça farklı: önce en küçük elemanın endeksini istiyoruz, sonra ikinci sırayı en küçük vb.

Biz bakarsak ⍋x: olsa da, biz kolayca bize bu listeyi verebilir bakınız pozisyon a 0in ⍋xen küçük elemanı sıraladıktan sonra sona ereceğini nerede bulunduğunu ifade ve pozisyon a 1in ⍋xikinci en küçük eleman sona ereceğini nerede bulunduğunu ifade , vb.

Fakat biliyoruz ki ⍋xtam olarak sayıları içeriyor [0, 1… n contains 1] . Biz dereceli bunu ise yine , sadece dizinini alırsınız 0içinde ⍋x, daha sonra endeksi 1de ⍋xbiz ilgilendiğiniz şeydir, vb.

Yani cevap ⍋⍋x.

Jöle, 2 bayt

ỤỤ

İki kez notlandır. 1 endeksli. Çevrimiçi deneyin!

JavaScript ES6, 87 82 79 74 70 bayt

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

Bir nesneyi kullanmaktan hoşlanmıyorum, ancak yinelemeleri izlemenin en kısa yolu gibi görünüyor

açıklama

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

<<

<İki kez ( ) not verin . JohnE, K'da bulunan açık ifadelere işaret ederek üç bayt kurtardı! Süper havalı. Denemek.

Haskell, 50 48 bayt

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

Kullanım örneği: m.m $ [4,4,0,1,1,2,0,1]-> [6,7,0,2,3,5,1,4].

Bu oluyor map snd.sort.zip x [0..]girişine iki kez uygulanan, yani 's indeksi i (her eleman e eşleştirmek (e,i)tür ilk unsurları kaldırmak). Bir kez tekrarlayın.

@Lynn m=map snd.sort.(`zip`[0..])aynı byte sayısına sahip oldu.

Python 2, 67 60 bayt

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

7 baytlık golf oynamak için @xnor'a teşekkürler!

İdeone üzerinde test et .

PowerShell v2 +, 63 bayt

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

Girdiyi alır $n, her elementin üzerinde bir döngüden geçen boruları |%{...}. Her yineleme, biz sort $nve IndexOfşu anki elementimizi alırız $_. Bu, geçerli öğeden kaç öğenin daha küçük olduğunu sayar. Biz o bir dilim eklemek $nşimdiki elemana eşit unsurların her döngü iterasyon genişletir $_ve almak .Countbunun. Daha sonra çıkartırız, -1böylece şu anki elementimizi saymazız ve bu numara boru hattında kalır. Sonunda çıktı örtüktür.

Örnekler

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 bayt

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

Çevrimiçi deneyin!

açıklama

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

/:^:2

Dereceli ( /:) iki kez ( ^:2). 0 endeksli.

Yazın Denemek için f =: /:^:2ve sonra f 4 4 0 1 1 2 0 1içine tryj.tk .

MATL, 10 9 4 bayt

@Luis sayesinde 4 Bayt kaydedildi

&S&S

Bu çözüm 1 tabanlı endeksleme kullanıyor

Çevrimiçi Deneyin

05AB1E, 12 bayt

2FvyN‚}){€¦˜

Açıklaması

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

Çevrimiçi deneyin

Python 2,67 bayt

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

xnor iki byte kaydetti.

Haskell, 40 bayt

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

Her öğeyi dizini ile birlikte notlandırın, daha sonra her öğeyi daha küçük öğelerin sayımıyla eşleştirin, dizinde tetiği çizin. Sıralama yok.

Julia, 17 bayt

~=sortperm;!x=~~x

1 endeksli. sortpermİki kez ( ) not verin . Burada dene.

EDIT: Dennis malzeme-operatör isimleri vererek dört bayt kurtardı ! Julia çok garip.

JavaScript (ES6), 52 bayt

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

gSıralanan dizideki tüm öğelerin orijinal dizide geldiği bir dizin dizisi döndüren grade işlevi olarak tanımlar . Ne yazık ki istediğimiz şey, tüm öğelerin gideceği endeksler. Neyse ki bu, sınıftan tekrar sınıflamanın bir sonucu olarak düşünülebilecek orijinal indeks listesine dönüş, böylece istenen sonucu elde etmek için notun derecesini almamızı sağlar.

Pyth, 10 9 bayt

Jakube sayesinde 1 bayt.

xLo@QNUQU

Test odası.

Daha kısa bir yol olmalı ...

Raket, 117 bayt

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

Sonsuza dek bunun için bir yerleşik olmadığından hayal kırıklığına uğradım.

Ruby, 54 53 bayt

Çevrimiçi deneyin

-1 bayt, @ Downgoat'ın her seferinde kopyaları saymak yerine, değerleri saklamak için bir karma kullanma yaklaşımına yükseltme.

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

Clojure, 83 bayt

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

Giriş dizisini dizeleyen ve girişte iki kez yineleyen anonim bir işlev yaratıyorum. İlk arama notu geri getirecek. İkinci çağrı, sınıfta çalışır ve rütbeyi döndürür.

Brachylog , 27 bayt

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

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

açıklama

Bu, aşağıdaki ilişkinin basit bir uygulamasıdır: girişin bir elemanına karşılık gelen çıktının her bir tamsayısı, girişin içindeki o elemanın indeksidir.

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 bayt

(o=Ordering)@*o

Mathematica, 135 bayt

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

Ortak Lisp, 117 bayt

(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 dönüşümü iki kez uygulayı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)

Ölçek

(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 (harici kütüphaneyi kullanarak) (105 bayt)

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

Lib bağlantısı: https://github.com/mvegh1/Enumerable Kod açıklaması: Tamsayıların listesini kabul eden adsız bir yöntem oluşturun. _.'Dan, bir diziyi özel yöntemlerle saran bir kitaplık örneği oluşturur. Her bir öğeyi yeni bir öğeye eşler, "v" alue değerini alarak, bir dizgeye ayrıştırıp ardından o öğenin "i" ndexini birleştirir (bu, yinelenen değer halini çözer). Bu, 'a' değişkeninde saklanır. Daha sonra, aşağıdaki sonucu döndürürüz: 'a' içindeki her öğeyi (tam sayı olarak) sıralanmış sürümündeki o öğenin dizinine eşleyin ve yerel bir JS dizisine geri dönün

Negatif yinelenen numaraların ters sırada yazdırıldığını unutmayın. Bunun bu çözümü geçersiz kıldığından emin değilim? Teknik olarak 8,10,4, -1, -1,8, OP'ye göre 3,5,2,0,1,4 olmalıdır, ancak kodum, inandığım 3,5,2,1,0,4 yazdırıyor hala teknik olarak geçerli mi?

GNU Core Utils, 39 33 bayt

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

1 tabanlı çıktı üretir. 0 tabanlı çıktı elde etmek için -v0saniyeden sonra ekleyin nl. (+4 bayt)

Kullandığımız komutlar:

• nl girişin her satırına satır numaraları ekler.
• sort -n -k 2 sayısal olarak sütun 2'ye göre sıralar.
• cut -f 1 geri kalanını atarak ilk Sekmeyle ayrılmış sütunu alır.

Ek olarak, istikrarlı bir sıralama istemek için -sseçenek geçirilebilir sort, ancak burada buna ihtiyacımız yok. İki öğe aynıysa, sortbu durumda monoton olarak artan çıktı olan diğer sütunlara düşerek sırasını belirler nl. Böylece sıralama, girdi sayesinde belirtmek zorunda kalmadan kararlı olacaktır.

Java 149 140 bayt

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

9 byte tıraş için @Kevin Cruissjen'e teşekkürler.

PHP, 88 bayt

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

komut satırı argümanları üzerinde çalışır; 0 dizinli, alt çizgi ile ayrılmış liste yazdırır. İle koş -nr.

Yıkmak

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 bayt

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

MATLAB'ın sıralama yerleşik yapılarının çoğu, sıralanmış dizinleri içeren isteğe bağlı ikinci bir dizi döndürür. j=Endeksleri baskı yerine geri gönderilmesi, daha kabul edilebilir olup olmadığını çıkarılabilir.

CJam , 19 bayt

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

Çevrimiçi deneyin!

Açıklama:

_ 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