Angenommen , wir haben eine Reihe $\texttt{ps}$ der Länge $n$ mit Zeigern zeigt auf einer Stelle im Array: Der Prozess der „ Zeiger Springen “ wird alle Zeiger auf die Position des Zeigers gesetzt verweist er auf Punkte.

Für die Zwecke dieser Abfrage ist ein Zeiger der (auf Null basierende) Index eines Elements des Arrays. Dies impliziert, dass jedes Element im Array größer oder gleich $0$ und kleiner als $n$ . Unter Verwendung dieser Notation kann der Prozess wie folgt formuliert werden:

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

Dies bedeutet (für diese Herausforderung), dass die Zeiger in sequentieller Reihenfolge an Ort und Stelle aktualisiert werden (dh zuerst niedrigere Indizes).

Beispiel

Lassen Sie uns ein Beispiel $\texttt{ps = [2,1,4,1,3,2]}$ , 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]}$$

Nach einer Iteration des " Zeigerspringens " erhalten wir das Array $\texttt{[4,1,3,1,1,3]}$ .

Herausforderung

Bei einem Array mit Indizes wird das Array ausgegeben, das durch Iterieren des oben beschriebenen Zeigersprungs erhalten wird, bis sich das Array nicht mehr ändert.

Regeln

Ihr Programm / Ihre Funktion wird denselben Typ, eine Liste / einen Vektor / ein Array usw. annehmen und zurückgeben / ausgeben, die / das

• ist garantiert nicht leer und
• enthält garantiert nur Einträge $0 \leq p < n$ .

Varianten: Sie können wählen

• 1-basierte Indizierung verwenden oder
• Verwenden Sie aktuelle Zeiger,

Sie sollten dies jedoch in Ihrem Beitrag erwähnen.

Testfälle

[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 Bytes

Ändert das ursprüngliche Eingabearray.

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

Probieren Sie es online aus

Haskell, 56 Bytes

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

Haskell- und In-Place-Updates stimmen nicht überein.

Probieren Sie es online!

Python 2 , 53 Bytes

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

Probieren Sie es online!

-6 dank HyperNeutrino .

Ändert ldas Ergebnis an Ort und Stelle.

C ++ 14 (gcc) , 61 Bytes

Wie unbenanntes generisches Lambda. Benötigt sequentielle Container wie std::vector.

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

Probieren Sie es online!

Schnell , 68 53 Bytes

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

Probieren Sie es online!

-15 dank BMO

JavaScript (ES6), 41 Byte

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

Probieren Sie es online!

05AB1E (Legacy) , 8 Byte

ΔDvDyèNǝ

Probieren Sie es online!

Erläuterung

Δ          # 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 Bytes

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

Probieren Sie es online!

Japt, 15, 13 7 Bytes

Ändert das ursprüngliche Eingabearray.

££hYXgU

Probieren Sie es aus (zusätzliche Bytes werden benötigt, um die geänderte Eingabe in die Konsole zu schreiben)

££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 Bytes

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

Ändert das Eingabearray, anstatt ein neues zurückzugeben, um Bytes zu sparen.

$length^2$

Probieren Sie es online aus.

Erläuterung:

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 Bytes

®
£hYUgX
eV ?U:ß

Probieren Sie alle Testfälle aus

Das fühlt sich an, als sollte es kürzer sein, aber leider UmgUfunktioniert mein erster Gedanke nicht, weil jeder gauf das Original zugreift, Uanstatt es bei jedem Schritt zu ändern. Die Aufbewahrung verschiedener Komponenten kostet ebenfalls eine Handvoll Bytes.

Erläuterung:

           #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 Bytes

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

Probieren Sie es online!

Verwendet Zeiger.

50 45 Bytes mit ganzen Zahlen:

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

Probieren Sie es online!

Ruby , 37 34 Bytes

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

Probieren Sie es online!

Gibt zurück, indem das Eingangsarray direkt geändert wird.

Rot , 63 Bytes

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

Probieren Sie es online!

Ändert das Array an Ort und Stelle

R , 60 58 Bytes

-2 Bytes Dank an @digEmAll für das Lesen der Regeln.

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

Probieren Sie es online!

1-indiziert.

n ist die Länge des Eingabearrays.

rep(1:n,n) repliziert 1:n n mal (zB n=3 => 1,2,3,1,2,3,1,2,3)

Durchlaufen Sie die Array- nZeiten. Der stationäre Zustand wird dann sicher erreicht sein, und zwar bis zum Ende des n-1. Males, denke ich. Der Beweis bleibt dem Leser überlassen.

Common Lisp, 59 58 Bytes

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

Probieren Sie es online!

Sauber , 80 Bytes

import StdEnv

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

Probieren Sie es online!

Clojure , 136 Bytes

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

Probieren Sie es online!

Perl 5, 35 34 26 Bytes

unter Verwendung der Tatsache, dass die Konvergenz höchstens für die Größenanzahl der Iterationen erreicht wird

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

26 Bytes

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

34 Bytes

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

35 Bytes

Clojure , 88 Bytes

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

Probieren Sie es online!

Kohle , 16 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Leider arbeiten alle üblichen Mapping-Funktionen nur mit einer Kopie des Arrays, was dazu führt, dass sie die Elemente nur permutieren und nicht springen, sodass der Code alles manuell erledigen muss. Erläuterung:

Ｆθ

Wiederholen Sie die innere Schleife einmal für jedes Element. Dies stellt nur sicher, dass sich das Ergebnis stabilisiert.

ＦＬθ

Schleife über die Array-Indizes.

§≔θκ§θ§θκ

Rufen Sie das Array-Element am aktuellen Index ab, indizieren Sie es im Array und ersetzen Sie das aktuelle Element durch diesen Wert.

Ｉθ

Wandeln Sie die Elemente in Strings um und drucken Sie sie implizit in einer eigenen Zeile.

F #, 74 73 Bytes

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

Nichts Besonderes. Verwendet die Modulidee aus anderen Antworten.

K, 27 Bytes

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

• {..}/ Wendet Lambda {..} auf Arg an (bis zur Konvergenz)

• inneres äußeres Lambda:

  • {..}/[x;y]Wendet Lambda iterativ auf x (bei jeder Iteration aktualisiert) und ein Element von y an (y ist eine Liste von Werten und verwendet bei jeder Iteration ein Element). In diesem Fall ist arg y !#x(bis count x, also die Indizes des Arrays).

  • @[x;y;:;x x y] Array x ändern (bei Index y x [x [y]] zuweisen)

APL (Dyalog Unicode) , 26 Byte ^SBCS

Benötigt ⎕IO←0

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

Probieren Sie es online!