Seu desafio hoje é escrever um programa ou função que faça uma lista le dê as posições nas lquais cada elemento sucessivo da lclassificação aparece.

Em outras palavras, imprima o índice do menor valor, seguido pelo índice do segundo menor valor, etc.

Você pode assumir que a matriz de entrada conterá apenas números inteiros positivos e conterá pelo menos um elemento.

Casos de teste:

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]

Quando dois ou mais elementos com o mesmo valor aparecerem, seus índices deverão aparecer próximos um do outro, do menor para o maior.

Isso é código-golfe , o menor número de bytes vence!

Geléia , 1 byte

Ụ

Experimente online!

Dyalog APL, 1 byte

⍋

O Dyalog APL possui uma função de operador integrada (obrigado Zacharý por esclarecer isso) para fazer isso.

Exemplo

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

Aqui, estou indexando na lista pelos índices classificados para retornar a lista em ordem crescente.

Haskell , 43 42 bytes

1-indexed:

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

Experimente online!

-1 byte graças a @ ØrjanJohansen!

Python 2 , 56 bytes

Esta solução é indexada em 0. Isso abusa do fato de sorted()criar uma cópia da lista original.

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

Experimente online!

Javascript (ES6), 39 bytes

-2 bytes graças a @powelles

Isso funciona apenas em navegadores onde Array.prototype.sorté estável.

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

Versão indexada em 1 (47 bytes):

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

Exemplo de trecho de código:

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 bytes

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

Experimente online!

Perl 6 ,  27  21 bytes

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

Teste-o

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

Teste-o

Inspirado por uma resposta Python

Expandido:

->    # 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｣
}

Bash + coreutils, 20

nl|sort -nk2|cut -f1

Experimente online .

Swift 4 , 82 bytes

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

Suíte de teste.

Explicação

No Swift, l.sorted()cria uma cópia classificada da matriz original. Fazemos um loop pelos elementos classificados na lista e após imprimir o índice de cada item na matriz original com let a=l.index(of:k)!;print(a)e, a fim de manter os índices corretos na matriz, atribuímos l[a]a ela 0, porque isso não afeta nossa saída normal.

Observe que esse índice é 0, pois é uma porta da minha solução Python. Se você deseja que ele seja indexado 1, substitua print(a)por print(a+1)ou Experimente on-line! .

R , 5 bytes

Existe uma função interna para isso.

order

Ruby , 40 bytes

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

Experimente online!

MATL , 2 bytes

&S

Experimente online!

Entrada e saída estão implícitas.

J , 2 bytes

/:

Experimente online!

Indexação baseada em zero.

Oitava , 17 bytes

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

Experimente online!

O Octave é como o MATLAB, mas com atribuição em linha, possibilitando coisas que causam dores de cabeça ao pessoal do Mathworks HQ. Não importa como você chama y, mas você não pode prescindir dessa variável fictícia, até onde eu sei.

MEU , 3 bytes

MY também tem um builtin para isso!

⎕⍋↵

Experimente online!

Quão?

Entrada avaliada, classificação superior e saída com uma nova linha.

Indexado, no entanto, você define o índice com ⌶/ 0x48. (Pode até ser um número inteiro estranho como -1ou 2, o padrão é 1).

Java 8, 128 + 19 = 147 bytes

Baseado na solução do Sr. Xcoder . Baseado em 0. O Lambda recebe a entrada como Integer[]e retorna Integer[]. A contagem de bytes inclui expressão lambda e importação necessária.

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

Experimente Online

Lambda ungolfed

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

Notas

Eu uso em Integer[]vez de int[]permitir o uso de Arrays.asList, que não tem versões primitivas. Integeré preferido paraLong porque os valores são usados ​​como índices de matriz e exigiriam conversão.

Isso acabou sendo mais curto do que o meu melhor estilo processual List solução no , devido ao custo dos nomes de classe e método.

Isso também superou uma solução que tentei que transmitia as entradas, mapeadas para (valor, índice) pares , classificadas em valores e mapeadas para índices, principalmente por causa da bagagem necessária para coletar o fluxo.

Agradecimentos

• -5 bytes graças a Nevay

Lisp comum, 82 bytes

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

Experimente online!

Clojure, 39 bytes

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

CJam , 12 bytes

{ee{1=}$0f=}

Experimente online!

MATLAB / oitava , 29 bytes

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

Experimente online!

JavaScript (ES6), 69 bytes

Indexado a 0. Funciona para listas que contêm até 65.536 elementos.

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

Casos de teste

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 bytes

Indexado a 0. Baseado na resposta Haskell de Bruce Forte aqui e Ruby da GB aqui .

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

Experimente online!

Casca , 10 7 bytes

Esta é uma porta direta da minha resposta Haskell , também 1indexada:

m→O`z,N

Experimente online!

Ungolfed / Explained

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 bytes

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

Experimente online!

Leva um List<Integer> , retorna umaStream<Integer> contendo os resultados.

Obtemos um fluxo com base na lista inicial, classificamos e mapeamos cada número para seu índice na lista. Para acomodar elementos duplicados, definimos o elemento original na lista como 0.

SmileBASIC, 67 bytes

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

Muito simples, basta gerar uma lista de números de 1 a (comprimento da matriz) e classificá-la pela mesma ordem que a entrada.

Python 3 com Numpy , 38 26 bytes

12 bytes salvos graças a Jo King (não é necessário dar um nome à função)

import numpy
numpy.argsort

A saída é baseada em 0.

Experimente online!

05AB1E , 4 bytes

ā<Σè

Experimente online!

Pari / GP , 16 bytes

a->vecsort(a,,1)

Experimente online!

PHP , 54 bytes

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

Experimente online!

Isso é zero-indexado. Simplesmente classifica a matriz e retorna as chaves.

Tcl , 21 bytes

(Indexado a 0)

puts [lsort -indi $L]

Experimente online!