Підсумок

Враховуючи перелік цілих чисел, поверніть індекс, на якому кожне ціле число закінчилося б при сортуванні.

Наприклад, якщо список був [0,8,-1,5,8], вам слід повернутися [1,3,0,2,4]. Зауважте, що вони 8підтримують порядок відносно один одного (сорт стабільний).

Інший спосіб: для кожного елемента в списку повертайте кількість елементів у списку, які є: Менше, ніж вибраний елемент АБО (рівне елементу AND з'являється перед обраним елементом)

Індекси повинні починатися з 0 (не 1) EDIT: зважаючи на велику віддачу, я дозволю 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
   )

К , 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..]застосовується двічі на вході, тобто з’єднуйте кожен елемент е зі своїм індексом 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]

Анотувати кожен елемент своїм індексом, а потім відобразити кожен елемент на кількість менших елементів, перериваючи на індекс. Немає сортування.

Джулія, 17 байт

~=sortperm;!x=~~x

1-індексований. Оцініть sortpermдва рази ( ). Спробуйте тут.

EDIT: Денніс врятував чотири байти, давши імена операторів-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)))))

Я вічно розчарований відсутністю вбудованого для цього.

Рубі, 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))

Я створюю анонімну функцію, яка оцінює вхідний масив вгору і повторює його двічі на вході. Перший дзвінок поверне оцінку. Другий дзвінок діє на оцінку та повертає ранг.

Брахілог , 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])

Математика, 15 байт

(o=Ordering)@*o

Математика, 135 байт

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

Лист звичайний, 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))))

Застосовуйте перетворення Шварца двічі.

;; 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 створює екземпляр бібліотеки, який обертає масив спеціальними методами. Виберіть карту кожного елемента на новий елемент, взявши алью "v", розбираючи його на рядок, а потім об'єднуючи ndex "i" цього елемента (це вирішує дублікат випадок значення). Це збережено у змінній 'a'. Потім повертаємо результат наступного: Мапа кожного елемента в "a" до індексу цього елемента в відсортованій версії (як цілих чисел) і повертаємо до рідного масиву JS

Зауважте, що негативні повторювані номери видаються у зворотному порядку. Я не впевнений, чи це недійсне це рішення? Технічно 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 149 140 байт

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