Supponiamo di avere un array di lunghezza con puntatori che indicano una posizione nell'array: il processo di " salto del puntatore " imposterà ogni puntatore sulla posizione a cui punta il puntatore.$\texttt{ps}$$n$

Ai fini di questa sfida un puntatore è l'indice (a base zero) di un elemento dell'array, ciò implica che ogni elemento dell'array sarà maggiore o uguale a e minore di . Usando questa notazione il processo può essere formulato come segue:$0$$n$

for i = 0..(n-1) {
  ps[i] = ps[ps[i]]
}

Ciò significa (per questa sfida) che i puntatori vengono aggiornati sul posto in ordine sequenziale (cioè prima gli indici inferiori).

Esempio

Analizziamo un esempio, :$\texttt{ps = [2,1,4,1,3,2]}$

$$\texttt{i = 0}: \text{the element at position }\texttt{ps[0] = 2}\text{ points to }\texttt{4} \\ \to \texttt{ps = [4,1,4,1,3,2]} \\ \texttt{i = 1}: \text{the element at position }\texttt{ps[1] = 1}\text{ points to }\texttt{1} \\ \to \texttt{ps = [4,1,4,1,3,2]} \\ \texttt{i = 2}: \text{the element at position }\texttt{ps[2] = 4}\text{ points to }\texttt{3} \\ \to \texttt{ps = [4,1,3,1,3,2]} \\ \texttt{i = 3}: \text{the element at position }\texttt{ps[3] = 1}\text{ points to }\texttt{1} \\ \to \texttt{ps = [4,1,3,1,3,2]} \\ \texttt{i = 4}: \text{the element at position }\texttt{ps[4] = 3}\text{ points to }\texttt{1} \\ \to \texttt{ps = [4,1,3,1,1,2]} \\ \texttt{i = 5}: \text{the element at position }\texttt{ps[5] = 2}\text{ points to }\texttt{3} \\ \to \texttt{ps = [4,1,3,1,1,3]}$$

Quindi dopo una ripetizione di " puntatore che salta " otteniamo l'array .$\texttt{[4,1,3,1,1,3]}$

Sfida

Dato un array con indici in uscita, l'array ottenuto ripetendo il puntatore sopra descritto saltando fino a quando l'array non cambia più.

Regole

Il tuo programma / funzione prenderà e restituirà / emetterà lo stesso tipo, un elenco / vettore / matrice ecc. Quale

• è garantito per essere non vuoto e
• è garantito che contenga solo voci .$0 \leq p < n$

Varianti: puoi scegliere

• per utilizzare l'indicizzazione basata su 1 o
• utilizzare puntatori effettivi,

tuttavia dovresti menzionarlo nella tua richiesta.

Casi test

[0] → [0]
[1,0] → [0,0]
[1,2,3,4,0] → [2,2,2,2,2]
[0,1,1,1,0,3] → [0,1,1,1,0,1]
[4,1,3,0,3,2] → [3,1,3,3,3,3]
[5,1,2,0,4,5,6] → [5,1,2,5,4,5,6]
[9,9,9,2,5,4,4,5,8,1,0,0] → [1,1,1,1,4,4,4,4,8,1,1,1]

JavaScript, 36 byte

Modifica l'array di input originale.

a=>a.map(_=>a.map((x,y)=>a[y]=a[x]))

Provalo online

Haskell, 56 byte

foldr(\_->([]#))=<<id
x#a@(b:c)=(x++[(x++a)!!b])#c
x#_=x

Haskell e gli aggiornamenti sul posto sono una brutta partita.

Provalo online!

Python 2 , 53 byte

def f(l):L=len(l);i=0;exec'l[i]=l[l[i]];i=-~i%L;'*L*L

Provalo online!

-6 grazie a HyperNeutrino .

Modifica lil risultato sul posto.

C ++ 14 (gcc) , 61 byte

Come lambda generico senza nome. Richiede contenitori sequenziali come std::vector.

[](auto&c){auto d=c;do{d=c;for(auto&x:c)x=c[x];}while(d!=c);}

Provalo online!

Rapido , 68 53 byte

{a in for _ in a{var i=0;a.forEach{a[i]=a[$0];i+=1}}}

Provalo online!

-15 grazie a BMO

JavaScript (ES6), 41 byte

f=a=>a+''==a.map((x,i)=>a[i]=a[x])?a:f(a)

Provalo online!

05AB1E (legacy) , 8 byte

ΔDvDyèNǝ

Provalo online!

Spiegazione

Δ          # apply until the top of the stack stops changing
 D         # duplicate current list
  v        # for each (element y, index N) in the list
   Dyè     # get the element at index y
      Nǝ   # and insert it at index N

05AB1E , 14 byte

[D©vDyèNǝ}D®Q#

Provalo online!

Japt, 15 13 7 byte

Modifica l'array di input originale.

££hYXgU

Provalo (byte aggiuntivi devono scrivere l'input modificato sulla console)

££hYXgU
£           :Map
 £          :  Map each X at index Y
  hY        :    Replace the element at index Y
    XgU     :    With the element at index X

Java 8, 105 54 byte

a->{for(int l=a.length,i=0;i<l*l;)a[i%l]=a[a[i++%l]];}

Modifica l'input-array invece di restituirne uno nuovo per salvare i byte.

$length^2$

Provalo online.

Spiegazione:

a->{                // Method with integer-array parameter and no return-type
  int l=a.length,   //  Length of the input-array
  i=0;i<l*l;)       //  Loop `i` in the range [0, length squared):
    a[i%l]=         //   Set the (`i` modulo-length)'th item in the array to:
      a[            //    The `p`'th value of the input-array,
        a[i++%l]];} //    where `p` is the (`i` modulo-length)'th value of the array

Japt , 17 byte

®
£hYUgX
eV ?U:ß

Prova tutti i casi di test

Sembra che dovrebbe essere più breve, ma sfortunatamente il mio pensiero iniziale UmgUnon funziona perché ognuno gaccede all'originale Upiuttosto che modificarlo ad ogni passaggio. Anche la conservazione di diversi componenti ha un costo adeguato per una manciata di byte.

Spiegazione:

           #Blank line preserves input in U long enough for the next line

®          #Copy U into V to preserve its original value

£hY        #Modify U in-place by replacing each element X with...
   UgX     #The value from the current U at the index X

eV ?U      #If the modified U is identical to the copy V, output it
     :ß    #Otherwise start again with the modified U as the new input

C (clang) , 32 bit, 49 44 byte

i;f(**p,n){for(i=0;i<n*n;)p[i++%n]=*p[i%n];}

Provalo online!

Usa puntatori.

50 45 byte con numeri interi:

i;f(*p,n){for(i=0;i<n*n;)p[i++%n]=p[p[i%n]];}

Provalo online!

Rubino , 37 34 byte

->a{a.size.times{a.map!{|x|a[x]}}}

Provalo online!

Restituisce modificando l'array di input sul posto.

Rosso , 63 byte

func[b][loop(l: length? b)* l[repeat i l[b/:i: b/(1 + b/:i)]]b]

Provalo online!

Modifica l'array in atto

R , 60 58 byte

-2 byte grazie a @digEmAll per la lettura delle regole.

function(x,n=sum(x|1)){for(i in rep(1:n,n))x[i]=x[x[i]];x}

Provalo online!

1-indicizzati.

n è la lunghezza dell'array di input.

rep(1:n,n)replica i 1:n ntempi (ad es. n=3 => 1,2,3,1,2,3,1,2,3)

Passa attraverso i ntempi dell'array . Lo stato stazionario sarà sicuramente raggiunto da allora, in effetti entro la fine della n-1a volta, credo. La prova è lasciata al lettore.

Lisp comune, 59 58 byte

(lambda(a)(dolist(j a)(map-into a(lambda(x)(elt a x))a))a)

Provalo online!

Pulito , 80 byte

import StdEnv

limit o iterate\b=foldl(\l i=updateAt i(l!!(l!!i))l)b(indexList b)

Provalo online!

Clojure , 136 byte

(defn j[a](let[f(fn[a](loop[i 0 a a](if(= i(count a))a(recur(inc i)(assoc a i(a(a i)))))))](loop[p nil a a](if(= p a)a(recur a(f a))))))

Provalo online!

Perl 5, 35 34 26 byte

utilizzando il fatto che la convergenza è al massimo per il numero di dimensioni delle iterazioni

$_=$F[$_]for@F x@F;$_="@F"

26 byte

$_=$F[$_]for@F;/@F/ or$_="@F",redo

34 byte

$_=$F[$_]for@F;$_="@F",redo if!/@F/

35 byte

Clojure , 88 byte

#(reduce(fn[x i](assoc x i(get x(get x i))))%(flatten(repeat(count %)(range(count %)))))

Provalo online!

Carbone , 16 byte

ＦθＦＬθ§≔θκ§θ§θκＩθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Purtroppo tutte le consuete funzioni di mappatura funzionano solo su una copia dell'array con il risultato che permutano gli elementi invece di saltarli, quindi il codice deve fare tutto manualmente. Spiegazione:

Ｆθ

Ripeti il ​​ciclo interno una volta per ogni elemento. Questo garantisce solo che il risultato si stabilizzi.

ＦＬθ

Passa sopra gli indici dell'array.

§≔θκ§θ§θκ

Ottieni l'elemento dell'array nell'indice corrente, usalo per indicizzarlo nell'array e sostituisci l'elemento corrente con quel valore.

Ｉθ

Trasmetti gli elementi in stringa e stampa implicitamente ciascuno sulla propria riga.

F #, 74 73 byte

fun(c:'a[])->let l=c.Length in(for i in 0..l*l do c.[i%l]<-c.[c.[i%l]]);c

Niente di speciale. Utilizza l'idea del modulo vista in altre risposte.

K, 27 byte

{{@[x;y;:;x x y]}/[x;!#x]}/

• {..}/ applica lambda {..} su arg (fino alla convergenza)

• all'interno della lambda esterna:

  • {..}/[x;y]applica lambda in modo iterativo su x (aggiornato ad ogni iterazione) e un elemento di y (y è un elenco di valori e utilizza un elemento ad ogni iterazione). In questo caso arg y è !#x(fino al conteggio x, ovvero gli indici dell'array)

  • @[x;y;:;x x y] modifica array x (all'indice y assegna x [x [y]])

APL (Dyalog Unicode) , 26 byte ^SBCS

Richiede ⎕IO←0

{m⊣{m[⍵]←m[m[⍵]]}¨⍳≢m←⍵}⍣≡

Provalo online!