Ваша задача сегодня состоит в том, чтобы написать программу или функцию, которая берет список lи определяет позиции, в lкоторых lпоявляется каждый последующий отсортированный элемент .

Другими словами, выведите индекс наименьшего значения, затем индекс второго наименьшего значения и т. Д.

Можно предположить, что входной массив будет содержать только положительные целые числа и будет содержать хотя бы один элемент.

Тестовые случаи:

Input                  | Output (1-indexed)
[7, 4, 5]              | [2, 3, 1]
[1, 2, 3]              | [1, 2, 3]
[2, 6, 1, 9, 1, 2, 3]  | [3, 5, 1, 6, 7, 2, 4]
[4]                    | [1]

Когда появляются два или более элемента с одинаковым значением, их индексы должны появляться рядом друг с другом от наименьшего к наибольшему.

Это код-гольф , побеждает меньше байтов!

Желе , 1 байт

Ụ

Попробуйте онлайн!

Дьялог АПЛ, 1 байт

⍋

Dyalog APL имеет встроенную функцию оператора (спасибо Zacharý за прояснение этого), чтобы сделать это.

пример

⍋11 2 4 15
    2 3 1 4  
{⍵[⍋⍵]}11 4 2 15
    2 4 11 15

Здесь я индексирую в списке отсортированные индексы, чтобы вернуть список в порядке возрастания.

Haskell , 43 42 байта

1-indexed:

import Data.List
map snd.sort.(`zip`[1..])

Попробуйте онлайн!

-1 байт благодаря @ ÖrjanJohansen!

Python 2 , 56 байт

Это решение 0-проиндексировано. Это злоупотребляет тем, что sorted()создает копию исходного списка.

l=input()
for k in sorted(l):a=l.index(k);print a;l[a]=0

Попробуйте онлайн!

Javascript (ES6), 39 байт

-2 байта благодаря @powelles

Это работает только в браузерах, где Array.prototype.sortстабильно.

a=>[...a.keys()].sort((b,c)=>a[b]-a[c])

1-индексированная версия (47 байт):

a=>a.map((_,i)=>i+1).sort((b,c)=>a[b-1]-a[c-1])

Пример кода:

f=
a=>[...a.keys()].sort((b,c)=>a[b]-a[c])
console.log("7,4,5 => "+f([7,4,5]))
console.log("1,2,3 => "+f([1,2,3]))
console.log("2,6,1,9,1,2,3 => "+f([2,6,1,9,1,2,3]))
console.log("4 -> "+f([4]))

Python 2 , 48 байт

lambda x:sorted(range(len(x)),key=x.__getitem__)

Попробуйте онлайн!

Perl 6 ,  27  21 байт

*.pairs.sort(*.value)».key

Проверь это

->\x{sort {x[$_]},^x}

Проверь это

Вдохновленный ответом Python

Expanded:

->    # pointy block lambda
  \x  # declare sigilless parameter
{
  sort
    { x[$_] },  # sort by the value in ｢x｣ at the given position
    ^x          # Range up-to the number of elements in ｢x｣
}

Баш + кореутилс, 20

nl|sort -nk2|cut -f1

Попробуйте онлайн .

Swift 4 , 82 байта

func f(l:[Int]){var l=l;for k in l.sorted(){let a=l.index(of:k)!;print(a);l[a]=0}}

Тестирование.

объяснение

В Swift l.sorted()создает отсортированную копию исходного массива. Мы перебрать отсортированные элементы в списке и после печати индекса каждого элемента в исходном массиве с let a=l.index(of:k)!;print(a), а затем, чтобы сохранить правильные индексы в массиве, мы относим l[a]к 0, потому что это не влияет на наш нормальный выход.

Обратите внимание, что это 0-индексированный, так как это порт моего решения Python. Если вы хотите, чтобы это было 1-проиндексировано, замените print(a)с print(a+1)или попробовать его в Интернете! ,

R , 5 байт

Для этого есть встроенная функция.

order

Рубин , 40 байт

->a{a.zip([*1..a.size]).sort.map &:last}

Попробуйте онлайн!

MATL , 2 байта

&S

Попробуйте онлайн!

Ввод и вывод неявные.

J , 2 байта

/:

Попробуйте онлайн!

Индексирование на основе нуля.

Октава , 17 байт

@(i)[~,y]=sort(i)

Попробуйте онлайн!

Octave похож на MATLAB, но со встроенным назначением, что делает возможными вещи, которые доставляют людям головную боль в Mathworks HQ. Неважно, что вы называете y, но вы не можете обойтись без этой фиктивной переменной, насколько я знаю.

МОИ , 3 байта

МОЯ также имеет встроенный для этого!

⎕⍋↵

Попробуйте онлайн!

Как?

Оцененный ввод, оценка вверх, затем вывод с новой строкой.

Индексируется однако вы устанавливаете индекс, с помощью ⌶/ 0x48. (Может даже быть странным целым числом, например -1или 2, по умолчанию это 1).

Java 8, 128 + 19 = 147 байт

На основании г - Xcoder в растворе . 0 на основе. Лямбда принимает входные данные Integer[]и возвращает Integer[]. Число байтов включает в себя лямбда-выражение и требуемый импорт.

import java.util.*;

l->{Integer o[]=l.clone(),s[]=l.clone(),i=0;for(Arrays.sort(s);i<l.length;)l[o[i]=Arrays.asList(l).indexOf(s[i++])]=0;return o;}

Попробуйте онлайн

Неуправляемая лямбда

l -> {
    Integer
        o[] = l.clone(),
        s[] = l.clone(),
        i = 0
    ;
    for (Arrays.sort(s); i < l.length; )
        l[o[i] = Arrays.asList(l).indexOf(s[i++])] = 0;
    return o;
}

Примечания

Я использую Integer[]вместо того, int[]чтобы разрешить использование Arrays.asList, которое не имеет примитивных версий. Integerпредпочтительнее, Longпотому что значения используются в качестве индексов массива и требуют преобразования.

Это оказалось короче моего лучшего решения в процедурном стиле Listиз-за стоимости имен классов и методов.

Это также превзошло решение, которое я пробовал, чтобы поток входных данных отображался на (значение, индекс) парами , отсортированные по значениям и сопоставленные с индексами, в основном из-за багажа, необходимого для сбора потока.

Подтверждения

• -5 байт благодаря Nevay

Common Lisp, 82 байта

(lambda(l)(loop as i in(sort(copy-seq l)'<)do(setf(elt l(print(position i l)))0)))

Попробуйте онлайн!

Clojure, 39 байт

#(map key(sort-by val(zipmap(range)%)))

CJam , 12 байт

{ee{1=}$0f=}

Попробуйте онлайн!

MATLAB / Octave , 29 байт

[~,y]=sort(input(''));disp(y)

Попробуйте онлайн!

JavaScript (ES6), 69 байт

0 индексированные. Работает для списков, содержащих до 65 536 элементов.

a=>[...a=a.map((n,i)=>n<<16|i)].sort((a,b)=>a-b).map(n=>a.indexOf(n))

Контрольные примеры

let f =

a=>[...a=a.map((n,i)=>n<<16|i)].sort((a,b)=>a-b).map(n=>a.indexOf(n))

console.log(JSON.stringify(f([7, 4, 5])))
console.log(JSON.stringify(f([1, 2, 3])))
console.log(JSON.stringify(f([2, 6, 1, 9, 1, 2, 3])))
console.log(JSON.stringify(f([4])))

Python 3 , 52 байта

0 индексированные. Основываясь на ответе Хаскелла Брюса Форте здесь и ответе Руби ГБ здесь .

lambda l:list(zip(*sorted(zip(l,range(len(l))))))[1]

Попробуйте онлайн!

Шелуха , 10 7 байт

Это прямой порт моего ответа на Haskell , также 1-индексированный:

m→O`z,N

Попробуйте онлайн!

Ungolfed / Разъяснения

Code        Description               Example
         -- implicit input            [2,6,1]
      N  -- natural numbers           [1,2,3,..]
   `z,   -- zip, but keep input left  [(2,1),(6,2),(1,3)]
  O      -- sort                      [(1,3),(2,1),(6,2)]
m→       -- keep only indices         [3,1,2]

Java (OpenJDK 8) , 72 байта

l->l.stream().sorted().map(i->{int j=l.indexOf(i);l.set(j,0);return j;})

Попробуйте онлайн!

Принимает List<Integer>, возвращаетStream<Integer> содержащий результаты.

Мы получаем поток на основе исходного списка, сортируем его, а затем сопоставляем каждое число с его индексом в списке. Для размещения дублирующих элементов мы устанавливаем исходный элемент в списке на 0.

SmileBASIC, 67 байт

DEF I(A)DIM B[0]FOR I=1TO LEN(A)PUSH B,I
NEXT
SORT A,B
RETURN B
END

Все очень просто: генерировать список чисел от 1 до (длина массива) и сортировать его в том же порядке, что и входные данные.

Python 3 с Numpy , 38 26 байт

12 байтов, сохраненных благодаря Джо Кингу (не нужно давать имя функции)

import numpy
numpy.argsort

Выход основан на 0.

Попробуйте онлайн!

05AB1E , 4 байта

ā<Σè

Попробуйте онлайн!

Пари / ГП , 16 байт

a->vecsort(a,,1)

Попробуйте онлайн!

PHP , 54 байта

<?php function i($a){asort($a);return array_keys($a);}

Попробуйте онлайн!

Это с нулевым индексом. Просто сортирует массив и возвращает ключи.

Tcl , 21 байт

(0-индексированные)

puts [lsort -indi $L]

Попробуйте онлайн!