सूचक कूद रहा है

Question

मान लें कि हमारे पास सरणी में किसी स्थान पर इंगित करने वाले पॉइंटर्स के साथ लम्बाई की एक सरणी है : " पॉइंटर जंपिंग " की प्रक्रिया हर सूचक को उस स्थान पर इंगित करेगी जहां सूचक उस बिंदु को इंगित करता है।$\texttt{ps}$$n$

इस चुनौती के उद्देश्य के लिए एक सूचक सरणी के एक तत्व का (शून्य-आधारित) सूचकांक है, इसका तात्पर्य यह है कि सरणी में प्रत्येक तत्व से अधिक या बराबर और से कम होगा । इस संकेतन का उपयोग करके प्रक्रिया को निम्नानुसार तैयार किया जा सकता है:$0$$n$

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

इसका मतलब है (इस चुनौती के लिए) कि बिंदुओं को क्रमबद्ध क्रम में (यानी निचले सूचकांक पहले) में अपडेट किया गया है।

उदाहरण

आइए एक उदाहरण, माध्यम से काम करते हैं :$\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]}$$

इसलिए " पॉइंटर जंपिंग " के एक पुनरावृत्ति के बाद हमें ऐरे ।$\texttt{[4,1,3,1,1,3]}$

चुनौती

सूचकांकों के साथ एक सरणी को देखते हुए, उपर्युक्त वर्णित सूचक कूदते हुए सरणी प्राप्त करता है जब तक कि सरणी अब नहीं बदलती।

नियम

आपका प्रोग्राम / फंक्शन एक ही प्रकार, एक सूची / वेक्टर / एरे इत्यादि को ले / वापस करेगा

• गैर-रिक्त होने की गारंटी है और
• करने के लिए गारंटी है केवल प्रविष्टियों को $0 \leq p < n$ ।

वेरिएंट: आप चुन सकते हैं

• 1-आधारित अनुक्रमण या उपयोग करने के लिए
• वास्तविक संकेत का उपयोग करें,

हालाँकि आपको अपने प्रस्तुतिकरण में इसका उल्लेख करना चाहिए।

परीक्षण के मामलों

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

Comments

संबंधित: सरणी

— कूदें

क्या हमें nअतिरिक्त इनपुट के रूप में लंबाई लेने की अनुमति है ?

— केविन क्रूज़सेन

@ केविनक्रूजसेन, इस मेटा चर्चा को देखें ।

— झबरा

यह बहुत बुरा है कि प्रविष्टियों को क्रमिक रूप से अद्यतन करने की आवश्यकता है; यदि उन्हें एक साथ अद्यतन किया जा सकता है, तो गणितज्ञ के पास 21-वर्ण समाधान होगा #[[#]]&~FixedPoint~#&।

— ग्रेग मार्टिन

Answer 1

जावास्क्रिप्ट, 36 बाइट्स

मूल इनपुट सरणी को संशोधित करता है।

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

इसे ऑनलाइन आज़माएं

Answer 2

हास्केल, 56 बाइट्स

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

हास्केल और इन-प्लेस अपडेट एक खराब मैच हैं।

इसे ऑनलाइन आज़माएं!

Answer 3

पायथन 2 , 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-6 धन्यवाद HyperNeutrino के लिए ।

lजगह में परिणाम के लिए अलर्ट ।

Answer 4

C ++ 14 (gcc) , 61 बाइट्स

अनाम जेनेरिक लैम्ब्डा के रूप में। जैसे अनुक्रमिक कंटेनर की आवश्यकता होती है std::vector।

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

इसे ऑनलाइन आज़माएं!

Answer 5

स्विफ्ट , 68 53 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-15 बीएमओ को धन्यवाद

Comments

PPCG में आपका स्वागत है! मुझे स्विफ्ट का पता नहीं है, लेकिन कोडगॉल्फ पर। डिफ़ॉल्ट को टाइप किए गए लंबो-फ़ंक्शन को स्वीकार करना है, जो मुझे लगता है कि एक क्लोजर के रूप में गिना जाएगा। तो यह 53 बाइट्स हो सकते हैं (आपको गिनने की जरूरत नहीं है f=)। अपने यहाँ रहने का आनंद लें!

— ბიმო

स्वागत और सलाह के लिए धन्यवाद, जिसका उपयोग मैंने अपने उत्तर को अपडेट करने के लिए किया है।

— सीन

इसे कम करने के mapबजाय उपयोग करने के बारे में कैसे forEach?

— ज्योंग ने

Answer 6

जावास्क्रिप्ट (ईएस 6), 41 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

गाह! मैं इस चुनौती का इंतजार कर रहा था ताकि मैं ठीक उसी समाधान को पोस्ट कर सकूं: \ Nnn अपने निंजा कौशल! : पी

— झबरा

@shaggy 🐱 👤👤 (यह एक निंजा बिल्ली माना जाता है ... लेकिन यह शायद हर जगह समर्थित नहीं है)

— Arnauld

Answer 7

05AB1E (विरासत) , 8 बाइट्स

ΔDvDyèNǝ

इसे ऑनलाइन आज़माएं!

व्याख्या

Δ          # 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 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 8

जाप, 15 13 7 बाइट्स

मूल इनपुट सरणी को संशोधित करता है।

££hYXgU

इसे आज़माएं (अतिरिक्त बाइट्स कंसोल में संशोधित इनपुट लिखने के लिए हैं)

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

Answer 9

जावा 8, 105 54 बाइट्स

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

बाइट्स को बचाने के लिए एक नया वापस करने के बजाय इनपुट-सरणी को संशोधित करता है।

$length^2$

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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

Answer 10

जाप , 17 बाइट्स

®
£hYUgX
eV ?U:ß

सभी परीक्षण मामलों की कोशिश करो

ऐसा लगता है कि यह छोटा होना चाहिए, लेकिन दुर्भाग्य से मेरा प्रारंभिक विचार UmgUकाम नहीं करता है क्योंकि प्रत्येक प्रत्येक चरण पर इसे संशोधित करने के बजाय gमूल तक पहुंचता है U। अलग-अलग घटकों को संरक्षित करने के साथ-साथ मुट्ठी भर बाइट्स भी खर्च होते हैं।

स्पष्टीकरण:

           #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

Answer 11

सी (क्लैंग) , 32-बिट, 49 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पॉइंटर्स का उपयोग करता है।

पूर्णांक के साथ 50 45 बाइट्स :

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

इसे ऑनलाइन आज़माएं!

Answer 12

रूबी , 37 34 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट ऐर-इन को संशोधित करके लौटाता है।

Answer 13

लाल , 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

जगह में सरणी को संशोधित करता है

Answer 14

आर , 60 58 बाइट्स

नियम पढ़ने के लिए @digEmAll को -2 बाइट्स धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

1 अनुक्रमित।

n इनपुट सरणी की लंबाई है।

rep(1:n,n)प्रतिकृति 1:n nबार (जैसे n=3 => 1,2,3,1,2,3,1,2,3)

सरणी nसमय के माध्यम से लूप । स्थिर अवस्था को तब तक निश्चित रूप से स्वीकार कर लिया जाएगा, जब तक मुझे लगता है कि एन-1st समय के अंत तक। इसका प्रमाण पाठक पर छोड़ दिया जाता है।

Comments

मुझे लगता है कि आप इसे हटा सकते हैं +1और बस 1-आधारित इनपुट ले सकते हैं, पोस्ट में कहा गया है: आप 1-आधारित इंडेक्सिंग का उपयोग करने के लिए चुन सकते हैं

— digEmAll

-4 scan()इनपुट के लिए स्विचन द्वारा । मुझे हमेशा ऐसा लगता है कि मेरे scan()समाधान उप-योग हैं, इसलिए एक छोटे तरीके से काम करने के लिए xऔर nसाथ में नज़र रखें : n=length(x<-scan());for(i in rep(1:n,n))x[i]=x[x[i]];x इसे ऑनलाइन आज़माएं!

— आपराधिक रूप से

Answer 15

आम लिस्प, 59 58 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 16

साफ , 80 बाइट्स

import StdEnv

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

इसे ऑनलाइन आज़माएं!

Answer 17

क्लोजर , 136 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

नमस्कार और पीपीसीजी में आपका स्वागत है। क्या आपके लिए यह संभव होगा कि आप ऑनलाइन दुभाषिया को एक लिंक प्रदान करें, ताकि कोई व्यक्ति आपके समाधान को आसानी से सत्यापित कर सके? इसके अलावा, loop [नहीं बन सकता है loop[?

— जोनाथन फ्रेच

सबसे हाल ही में संपादित परीक्षण विफलताओं को ठीक करना चाहिए । असुविधा हर किसी के लिए खेद है।

— ईथन मैक्यू

Answer 18

पर्ल 5, 35 34 26 बाइट्स

इस तथ्य का उपयोग करना कि पुनरावृत्तियों के आकार की संख्या के लिए अभिसरण सबसे अधिक पहुंचता है

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

26 बाइट्स

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

34 बाइट्स

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

35 बाइट्स

Answer 19

क्लोजर , 88 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 20

चारकोल , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। अफसोस की बात है कि सभी सामान्य मैपिंग फ़ंक्शन केवल सरणी की एक प्रति पर काम करते हैं, जिसके परिणामस्वरूप वे तत्वों को कूदने के बजाय केवल अनुमति देते हैं, इसलिए कोड को मैन्युअल रूप से सब कुछ करना पड़ता है। स्पष्टीकरण:

Ｆθ

प्रत्येक तत्व के लिए एक बार आंतरिक लूप दोहराएं। यह सिर्फ यह सुनिश्चित करता है कि परिणाम स्थिर हो।

ＦＬθ

सरणी सूचकांकों पर लूप करें।

§≔θκ§θ§θκ

वर्तमान इंडेक्स पर एरे तत्व को प्राप्त करें, उस एरे को इंडेक्स में प्रयोग करें, और वर्तमान एलीमेंट को उस मान से बदलें।

Ｉθ

तत्वों को स्ट्रिंग और अंतर्निहित रूप से प्रत्येक को अपनी लाइन पर प्रिंट करें।

Answer 21

एफ #, 74 73 बाइट्स

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

कुछ खास नहीं। अन्य उत्तरों में देखे गए मापांक विचार का उपयोग करता है।

Answer 22

के, 27 बाइट्स

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

• {..}/ lambda {..} को arg पर (अभिसरण तक) लागू करता है

• बाहरी मेमने के अंदर:

  • {..}/[x;y]x (प्रत्येक पुनरावृत्ति पर अद्यतित) पर लैम्ब्डा इटेरेटिवली लागू होता है और y (y मानों की सूची है, और प्रत्येक पुनरावृत्ति में किसी आइटम का उपयोग करता है) का एक आइटम होता है। इस मामले में arg y है !#x(til count x, अर्थात, सरणी के अनुक्रमित)

  • @[x;y;:;x x y] संशोधन सरणी x (अनुक्रमणिका y असाइन x [x [y]])

Answer 23

एपीएल (Dyalog यूनिकोड) , 26 बाइट्स ^SBCS

आवश्यक है ⎕IO←0

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

इसे ऑनलाइन आज़माएं!