14

La tua sfida oggi è quella di scrivere un programma o una funzione che prende un elenco le fornisce le posizioni in lcui lappare ogni elemento successivo di ordinato.

In altre parole, genera l'indice del valore più piccolo, seguito dall'indice del secondo valore più piccolo, ecc.

Si può presumere che l'array di input conterrà solo numeri interi positivi e conterrà almeno un elemento.

Casi test:

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 compaiono due o più elementi con lo stesso valore, i loro indici dovrebbero apparire uno accanto all'altro dal più piccolo al più grande.

Questo è code-golf , vince meno byte!

code-golf array-manipulation

— Pavel
fonte

16

-1 per una sfida banale che può essere risolta con incorporati in linguaggi di golf comuni e per accettare una risposta in meno di 24 ore. Questa non è stata né una sfida equa, né una sfida interessante.

— Cody Gray,

3

Bene, capisco perché ha accettato una risposta entro 24 ore, è impossibile da battere.

— Zacharý,

3

@CodyGray Ho pensato di effettuare il downvoting quando ho visto la risposta di 1-2 byte, ma in realtà non credo sia una brutta sfida per linguaggi di programmazione più standard. Certo, non è una sfida difficile , ma c'è sicuramente qualche possibilità di golf. Certo, è spiacevole vedere built-in a 1 byte, ma non credo sia giusto dare la colpa a questa sfida.

— Dada,

1

L'uso di un carattere incorporato di 1 carattere non è certo pratico. Facile non significa necessariamente risolvibile usando solo builtin.

— JAD

2

La soluzione migliore in questi casi è dimenticare la funzione di accettazione, che non è comunque rilevante qui.

— Mr. Xcoder,

9

Gelatina , 1 byte

Ụ

Provalo online!

— Dennis
fonte

Eh, era troppo ovvio ...

— Erik the Outgolfer,

2

APL meritava questo, +1 anche se per la tua velocità.

— Zacharý,

@ Zacharý Sono sicuro che Jelly ha raccolto questo da J, che a sua volta l'ha ereditato da APL.

— Adám,

11

Dyalog APL, 1 byte

⍋

Dyalog APL ha una funzione di ~~operatore~~ integrata (grazie Zacharý per aver chiarito) per farlo.

Esempio

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

Qui sto indicizzando l'elenco in base agli indici ordinati per restituire l'elenco in ordine crescente.

— James Heslip
fonte

Oh, solo per avvisarti di una terminologia confusa, in APL, i builtin come ⍋sono considerati funzioni, mentre cose come ¨⍨⍣.∘/\⌿⍀⌸⍤sono operatori.

— Zacharý,

9

Haskell , 43 42 byte

1-indexed:

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

Provalo online!

-1 byte grazie a @ ØrjanJohansen!

— ბიმო
fonte

2

Versione Pointfree salva un byte: map snd.sort.(`zip`[1..]).

— Ørjan Johansen,

9

Python 2 , 56 byte

Questa soluzione è indicizzata 0. Ciò abusa del fatto che sorted()crea una copia dell'elenco originale.

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

Provalo online!

— Mr. Xcoder
fonte

Perché l'hai dimenticato?

— Erik the Outgolfer,

@EriktheOutgolfer Fixed, Rollback.

— Mr. Xcoder,

9

Javascript (ES6), 39 byte

-2 byte grazie a @powelles

Funziona solo nei browser in cui Array.prototype.sortè stabile.

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

Versione 1 indicizzata (47 byte):

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

Esempio di frammento di codice:

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

Espandi frammento

— Herman L
fonte

[...a.keys()]invece di a.map((_,i)=>i)ti farà risparmiare un paio di byte.

— Powelles,

7

Python 2 , 48 byte

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

Provalo online!

— Erik l'Outgolfer
fonte

Bello, mi sono superato> _ <. Ho cambiato la mia risposta a Python 3 in modo tale che non mi sento così male

— Mr. Xcoder

4

@ Mr.Xcoder Bene, questo è il suo lavoro ...

— Neil

@ Mr.Xcoder Dai, non dovresti sentirti male per quello! Hai creato un programma completo, ho creato una funzione e il mio approccio è un po 'diverso.

— Erik the Outgolfer,

Non mi sento male, sapevo che questo apparirà (odio personalmente la __<blahblah>__sintassi). Farò un po 'di gelatina, non voglio perdere l'allenamento :)

— Mr. Xcoder,

1

@ Mr.Xcoder Codegolf non significa bella sintassi e formattazione. ;)

— Erik the Outgolfer,

5

Perl 6 , 27 21 byte

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

Provalo

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

Provalo

Ispirato da una risposta Python

Allargato:

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

— Brad Gilbert b2gills
fonte

5

Bash + coreutils, 20

nl|sort -nk2|cut -f1

Provalo online .

— Trauma digitale
fonte

4

Swift 4 , 82 byte

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

Test Suite.

Spiegazione

In Swift, l.sorted()crea una copia ordinata dell'Array originale. Passiamo in rassegna gli elementi ordinati nell'elenco e dopo aver stampato l'indice di ogni articolo nell'array originale con let a=l.index(of:k)!;print(a), quindi, per mantenere gli indici corretti nell'array, assegniamo l[a]a 0, perché non influisce sul nostro normale output.

Si noti che questo è indicizzato 0, poiché è una porta della mia soluzione Python. Se vuoi che sia 1-indicizzato, sostituiscilo print(a)con print(a+1)o Provalo online! .

— Mr. Xcoder
fonte

4

R , 5 byte

C'è una funzione integrata per questo.

order

— djhurio
fonte

3

Le regole standard sono di fornire un programma di funzioni. orderè già una funzione, quindi non è necessario gestire l'input utilizzando scan(). Questo sarebbe 5 byte.

— JAD

rank()salverebbe un byte

— gstats il

1

Sono sicuro che ci sia stata una rankrisposta di @JarkoDubbeldam, ma non la vedo più.

— djhurio,

1

Corretto, non segue le specifiche quindi l'ho cancellato.

— JAD

4

Rubino , 40 byte

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

Provalo online!

— GB
fonte

3

MATL , 2 byte

&S

Provalo online!

Input e output sono impliciti.

— Sanchises
fonte

3

J , 2 byte

/:

Provalo online!

Indicizzazione in base zero.

— Tikkanz
fonte

Stava per postare questo ...

— Cyoce

3

Ottava , 17 byte

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

Provalo online!

Octave è come MATLAB ma con un incarico in linea, che rende possibili cose che danno alle persone mal di testa al quartier generale di Mathworks. Non importa come chiami y, ma per quanto ne so non puoi fare a meno di quella variabile fittizia.

— Sanchises
fonte

3

MIO , 3 byte

Anche il MIO ha incorporato questo!

⎕⍋↵

Provalo online!

Come?

Input valutato, valutazione, quindi output con una nuova riga.

Indicizzato comunque hai impostato l'indice, con ⌶/ 0x48. (Può anche essere un numero intero strano come -1o 2, il valore predefinito è 1).

— Zaccaria
fonte

3

Java 8, 128 + 19 = 147 byte

Basato sulla soluzione di Mr. Xcoder . 0-based. Lambda accetta input come an Integer[]e ritorna Integer[]. Il conteggio dei byte include l'espressione lambda e l'importazione richiesta.

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

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

Appunti

Uso Integer[]invece di int[]consentire l'uso di Arrays.asList, che non ha versioni primitive. Integerè preferito Longperché i valori sono usati come indici di array e richiederebbero il casting.

Questo finì per essere più breve del mio migliore stile procedurale List soluzione in causa del costo dei nomi di classe e metodo.

Questo ha anche battuto una soluzione che ho provato che ha trasmesso in streaming gli input, mappato su coppie (valore, indice) , ordinato su valori e mappato su indici, principalmente a causa del bagaglio necessario per raccogliere il flusso.

Ringraziamenti

-5 byte grazie a Nevay

— Jakob
fonte

1

Non è necessario j:

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

(19 + 128 byte).

— Nevay,

2

Lisp comune, 82 byte

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

Provalo online!

— Renzo
fonte

2

Clojure, 39 byte

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

— NikoNyrh
fonte

Tradotto in Perl 6{map *.key,(sort *.value,(0..* Z=> @_))}

— Brad Gilbert b2gills il

2

CJam , 12 byte

{ee{1=}$0f=}

Provalo online!

— Erik l'Outgolfer
fonte

2

MATLAB / Ottava , 29 byte

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

Provalo online!

— Luis Mendo
fonte

Mentre la tua risposta è MATLAB perfetta, in realtà puoi svolgere compiti in linea con funzioni anonime in Octave .

— Sanchises,

Buona! Conoscevo l'incarico in linea, ma non sapevo che avresti potuto produrre direttamente così

— Luis Mendo,

1

Ad essere sincero, neanche io. Ho iniziato con qualcosa del genere @(X)([~,y]=sort(X)), e mentre cercavo un modo per ottenere yda questo, mi sono reso conto che in yrealtà era il valore di ritorno dall'assegnazione e un'attenta ispezione ha rivelato che le parentesi non erano nemmeno necessarie. A MATLAB piace tutto esplicito; Octave è felice quando è inequivocabile.

— Sanchises,

2

JavaScript (ES6), 69 byte

0-indicizzati. Funziona per elenchi contenenti fino a 65.536 elementi.

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

Casi test

Mostra snippet di codice

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

Expand snippet

— Arnauld
fonte

Can you change n=>a.indexOf(n) to just a.indexOf?

— Zacharý

@Zacharý Unfortunately not. A method of an instanced object cannot be used as a callback.

— Arnauld

@Zacharý Even worse is that Array#map passes 3 arguments to the callback function, and Array#indexOf expects 2, so it will give undesirable results.

— kamoroso94

2

Python 3, 52 bytes

0-indexed. Based on Bruce Forte's Haskell answer here and G B's Ruby answer here.

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

Try it online!

— Sherlock9
fonte

2

Husk, 10 7 bytes

This is a direct port of my Haskell answer, also 1-indexed:

m→O`z,N

Try it 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]

— ბიმო
fonte

2

Java (OpenJDK 8), 72 bytes

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

Try it online!

Takes a List<Integer>, returns a Stream<Integer> containing the results.

We get a Stream based off the initial list, sort it, then map each number to it's index in the list. In order to accommodate duplicate elements, we set the original element in the list to 0.

— Xanderhall
fonte

2

SmileBASIC, 67 bytes

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

Very simple, all it does is generate a list of numbers from 1 to (length of array) and sort this by the same order as the input.

— 12Me21
fonte

2

Python 3 with Numpy, 38 26 bytes

12 bytes saved thanks to Jo King (no need to give the function a name)

import numpy
numpy.argsort

Output is 0-based.

Try it online!

— Luis Mendo
fonte

The function could just be numpy.argsort without the lambda part

— Jo King

@JoKing Thanks for the suggestion. I wrote it that way because with just numpy.argsort;import numpy I get an error (numpy has not been imported yet), and with import numpy;numpy.argsort I need to move f= to the code part. Do you know that the standard procedure is in these cases? Move the f= and not count it?

— Luis Mendo

Yeah, I guess. Maybe just redefine f=numpy.argsort in the footer

— Jo King

@JoKing Good idea. Done. Thanks!

— Luis Mendo

1

05AB1E, 4 bytes

ā<Σè

Try it online!

— Erik the Outgolfer
fonte

1

Pari/GP, 16 bytes

a->vecsort(a,,1)

Try it online!

— alephalpha
fonte

1

PHP, 54 bytes

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

Try it online!

This is zero-indexed. Simply sorts the array and returns the keys.

— WebSmithery
fonte

1

The <?php tag is unnecessary for a function. 48 bytes.

— Titus

1

Tcl, 21 bytes

(0-indexed)

puts [lsort -indi $L]

Try it online!

— sergiol
fonte

The test cases only have 1 digit numbers; my solution only works well on 1 digit numbers.

— sergiol

Ottieni gli indici di un array dopo l'ordinamento

Gelatina , 1 byte

Dyalog APL, 1 byte

Esempio

Haskell , 43 42 byte

Python 2 , 56 byte

Javascript (ES6), 39 byte

Python 2 , 48 byte

Perl 6 , 27 21 byte

Allargato:

Bash + coreutils, 20

Swift 4 , 82 byte

Spiegazione

R , 5 byte

Rubino , 40 byte

MATL , 2 byte

J , 2 byte

Ottava , 17 byte

MIO , 3 byte

Come?

Java 8, 128 + 19 = 147 byte

Lambda ungolfed

Appunti

Ringraziamenti

Lisp comune, 82 byte

Clojure, 39 byte

CJam , 12 byte

MATLAB / Ottava , 29 byte

JavaScript (ES6), 69 byte

Casi test

Python 3, 52 bytes

Husk, 10 7 bytes

Ungolfed/Explained

Java (OpenJDK 8), 72 bytes

SmileBASIC, 67 bytes

Python 3 with Numpy, 38 26 bytes

05AB1E, 4 bytes

Pari/GP, 16 bytes

PHP, 54 bytes

Tcl, 21 bytes