डेटा लिंक किए गए डेटा को अलग करें

12

एक दोगुनी लिंक की गई सूची एक डेटा संरचना है जिसमें प्रत्येक नोड के पास सूची में और उसके आगे valueदोनों के साथ "लिंक" है । उदाहरण के लिए, मान 12, 99 और 37 के साथ निम्नलिखित नोड्स पर विचार करें:previousnodes

यहां, मान 12 के साथ नोड्स और 99 उनके संबंधित nextनोड्स को इंगित करते हैं , मान 99 और 37 के साथ । 37 मान वाले नोड का कोई nextसूचक नहीं है क्योंकि यह सूची में अंतिम नोड है। इसी तरह, मान 99 और 37 वालेprevious नोड्स उनके संबंधित नोड्स, 12 और 99 को इंगित करते हैं , लेकिन 12 का कोई previousसंकेतक नहीं है क्योंकि यह सूची में पहला नोड है।

स्थापित करना

व्यवहार में, एक नोड के "लिंक" को मेमोरी में पिछले और अगले नोड के स्थानों के संकेत के रूप में लागू किया जाता है। हमारे उद्देश्यों के लिए, "मेमोरी" नोड की एक सरणी होगी और नोड का स्थान सरणी में इसका सूचकांक होगा। एक नोड को फॉर्म के 3-टपल के रूप में माना जा सकता है ( prev value next )। उपरोक्त उदाहरण, तब ऐसा लग सकता है:

लेकिन यह इस तरह लग सकता है:

किसी भी नोड से शुरू होकर, आप previousनोड्स को प्राप्त करने के लिए nextलिंक ( लाल तीर के मूल के रूप में दिखाया गया है) का पालन कर सकते हैं जो इसे पूर्ववर्ती करते हैं और लिंक (हरा तीर) बाद में सभी नोड्स के मान प्राप्त करने के लिए नोड्स का पता लगाने के लिए: [12, 99, 37]।

ऊपर दिए गए पहले आरेख को एक सरणी में दर्शाया जा सकता है [[null, 12, 1], [0, 99, 2], [1, 37, null]]। दूसरा, तब होगा [[2, 99, 1], [0, 37, null], [null, 12, 0]]।

चुनौती

एक प्रोग्राम लिखें जो इनपुट के रूप में नोड्स की एक सरणी और एक नोड और रिटर्न के सूचकांक के रूप में लेता है, सूची क्रम में, नोड्स के मूल्यों को समान रूप से लिंक की गई सूची में।

एक उलझन

"मेमोरी" में हमेशा सिर्फ एक सूची के नोड्स नहीं होंगे। इसमें कई सूचियाँ हो सकती हैं:

उपरोक्त सरणी में आपकी सुविधा के लिए तीन दोहरे लिंक किए गए रंग, कोडित हैं:

  1. अनुक्रमित पर नोड्स 7, 10, 1, 4, 3, 12(केवल दिखा nextअव्यवस्था कम करने के लिए लिंक, विस्तार करने के लिए क्लिक करें):

    इस सरणी और इनमें से किसी भी अनुक्रमणिका को देखते हुए, आपके प्रोग्राम को क्रम में, मानों पर लौटना चाहिए [0, 1, 1, 2, 3, 5, 8]।

  2. सूचकांक पर नोड 9:

    सूचकांक को देखते हुए 9, आपका कार्यक्रम वापस आ जाना चाहिए [99]।

  3. अनुक्रमित पर नोड्स 11, 8, 0, 6, 2:

    इनमें से किसी एक सूचकांक को देखते हुए इसे वापस लौटना चाहिए [2, 3, 5, 7, 11]।

नियम

इनपुट

आपका कार्यक्रम इनपुट के रूप में प्राप्त होगा:

  1. (नोड्स की एक सूची (ऊपर वर्णित के रूप में 3-ट्यूपल्स), जहां 1 𝒏 ≤, 1,000, किसी भी सुविधाजनक प्रारूप में, उदाहरण के लिए सरणियों का एक सरणी, लंबाई 3 of के साथ पूर्णांकों का "फ्लैट" सरणी, आदि।

    3-tuples 'तत्व किसी भी क्रम में हो सकता है: ( prev value next ), ( next prev value ), आदि प्रत्येक नोड के लिए, prevऔर nextहो जाएगा null(या किसी अन्य सुविधाजनक मूल्य, जैसे -1), एक दोगुना लिंक्ड सूची में पहला या अंतिम नोड, या का एक मान्य सूचकांक का संकेत सूची, या तो 0- या 1-आधारित के रूप में सुविधाजनक है। valueएक हस्ताक्षरित 32-बिट पूर्णांक या आपकी भाषा का समर्थन करने वाला सबसे बड़ा पूर्णांक, जो भी छोटा हो, होगा।

  2. सूची में नोड का सूचकांक The (1)। संकेतित नोड एक दोहरी लिंक की गई सूची में पहला नोड हो सकता है, अंतिम नोड, एक मध्य नोड या केवल नोड हो सकता है।

इनपुट सूची (1) में पैथोलॉजिकल डेटा हो सकता है (उदाहरण के लिए कई अन्य नोड्स आदि द्वारा इंगित किए गए चक्र, नोड्स), लेकिन इनपुट इंडेक्स (2) हमेशा एक नोड को इंगित करेगा जिसमें से एकल, अच्छी तरह से निर्मित आउटपुट हो सकता है निष्कर्ष निकाला।

उत्पादन

आपके कार्यक्रम को दोहरी लिंक की गई सूची के नोड्स के मूल्यों को आउटपुट करना चाहिए, जिसमें सूचकांक at सूची क्रम में एक सदस्य है। आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकता है, लेकिन इसके डेटा में केवल नोड values शामिल होना चाहिए ।

जीतना

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब। मानक खामियां लागू होती हैं।

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

नीचे, प्रत्येक परीक्षण मामला फॉर्म का है:

X)
prev value next, prev value next, ...
index
value value value ...

... जहां Xपरीक्षण मामले की पहचान करने के लिए एक पत्र है, दूसरी पंक्ति इनपुट सूची है, तीसरी पंक्ति 0-आधारित इनपुट इंडेक्स है, और चौथी पंक्ति आउटपुट है।

A) null 12 1, 0 99 2, 1 37 null
   1
   12 99 37

B) 2 99 1, 0 37 null, null 12 0
   1
   12 99 37

C) 8 5 6, 10 1 4, 6 11 null, 4 3 12, 1 2 3, 12 8 null, 0 7 2, null 0 10, 11 3 0, null 99 null, 7 1 1, null 2 8, 3 5 5
   4
   0 1 1 2 3 5 8

D) 8 5 6, 10 1 4, 6 11 null, 4 3 12, 1 2 3, 12 8 null, 0 7 2, null 0 10, 11 3 0, null 99 null, 7 1 1, null 2 8, 3 5 5
   0
   2 3 5 7 11

E) 8 5 6, 10 1 4, 6 11 null, 4 3 12, 1 2 3, 12 8 null, 0 7 2, null 0 10, 11 3 0, null 99 null, 7 1 1, null 2 8, 3 5 5
   9
   99

F) 13 80 18, 18 71 null, 5 10 19, 12 1 8, 19 21 null, 31 6 2, 17 5 26, 26 0 30, 3 -1 25, null 1 23, 27 6 17, 14 1 24, 28 -1 3, null 80 0, 20 4 11, 33 6 29, 24 9 33, 10 7 6, 0 67 1, 2 15 4, 32 1 14, null 1 31, 29 3 null, 9 -1 28, 11 5 16, 8 1 null, 6 3 7, null 8 10, 23 1 12, 15 5 22, 7 9 null, 21 3 5, null 3 20, 16 2 15
   18
   80 80 67 71

G) 13 80 18, 18 71 null, 5 10 19, 12 1 8, 19 21 null, 31 6 2, 17 5 26, 26 0 30, 3 -1 25, null 1 23, 27 6 17, 14 1 24, 28 -1 3, null 80 0, 20 4 11, 33 6 29, 24 9 33, 10 7 6, 0 67 1, 2 15 4, 32 1 14, null 1 31, 29 3 null, 9 -1 28, 11 5 16, 8 1 null, 6 3 7, null 8 10, 23 1 12, 15 5 22, 7 9 null, 21 3 5, null 3 20, 16 2 15
   8
   1 -1 1 -1 1 -1 1

H) 13 80 18, 18 71 null, 5 10 19, 12 1 8, 19 21 null, 31 6 2, 17 5 26, 26 0 30, 3 -1 25, null 1 23, 27 6 17, 14 1 24, 28 -1 3, null 80 0, 20 4 11, 33 6 29, 24 9 33, 10 7 6, 0 67 1, 2 15 4, 32 1 14, null 1 31, 29 3 null, 9 -1 28, 11 5 16, 8 1 null, 6 3 7, null 8 10, 23 1 12, 15 5 22, 7 9 null, 21 3 5, null 3 20, 16 2 15
   4
   1 3 6 10 15 21

I) 13 80 18, 18 71 null, 5 10 19, 12 1 8, 19 21 null, 31 6 2, 17 5 26, 26 0 30, 3 -1 25, null 1 23, 27 6 17, 14 1 24, 28 -1 3, null 80 0, 20 4 11, 33 6 29, 24 9 33, 10 7 6, 0 67 1, 2 15 4, 32 1 14, null 1 31, 29 3 null, 9 -1 28, 11 5 16, 8 1 null, 6 3 7, null 8 10, 23 1 12, 15 5 22, 7 9 null, 21 3 5, null 3 20, 16 2 15
   14
   3 1 4 1 5 9 2 6 5 3

J) 13 80 18, 18 71 null, 5 10 19, 12 1 8, 19 21 null, 31 6 2, 17 5 26, 26 0 30, 3 -1 25, null 1 23, 27 6 17, 14 1 24, 28 -1 3, null 80 0, 20 4 11, 33 6 29, 24 9 33, 10 7 6, 0 67 1, 2 15 4, 32 1 14, null 1 31, 29 3 null, 9 -1 28, 11 5 16, 8 1 null, 6 3 7, null 8 10, 23 1 12, 15 5 22, 7 9 null, 21 3 5, null 3 20, 16 2 15
   17
   8 6 7 5 3 0 9

K) 4 11 0, null 22 3, null 33 3, 1 44 4, 3 55 null, 7 66 7, 6 77 6
   3
   22 44 55

L) null -123 null
   0
   -123
code-golf  data-structures 
— जॉर्डन
स्रोत
सैंडबॉक्स लिंक: codegolf.meta.stackexchange.com/a/14451/11261
— जॉर्डन
— जॉर्डन
क्या तीन सरणियों के रूप में इनपुट (एक क्रम में सभी पूर्ववर्ती नोड्स, एक मान, और एक उत्तराधिकारी नोड्स) की अनुमति है, या क्या यह ट्यूपल्स की अवधारणा से बहुत दूर है?
— Sanchises
@Sanchises क्षमा करें, मेरे लिए बहुत दूर।
— जॉर्डन
यह सब ठीक है! मैंने ऐसा सोचा था, लेकिन मैं अपने उत्तर पर किसी भी टिप्पणी से आगे होना चाहता था, कह रहा था कि मैं दो बाइट्स अलग-अलग सरणियों को ले सकता हूं।
— Sanchises

जवाबों:

1

05AB1E , 25 बाइट्स

è[¬D0‹#Isè]\[`sˆD0‹#Isè]¯

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

व्याख्या

è[¬D0‹#Isè]\[`sˆD0‹#Isè]¯   # Arguments n, a
è                           # Get element at index n in a
 [¬D0‹#Isè]                 # Find the first element in the list
 [                          # While true, do
  ¬                         #   Head (get index of previous element)
   D0‹#                     #   Break if lower than 0
       Isè                  #   Get the element at that index
          ]                 # End loop
           \                # Delete top element of stack
            [`sˆD0‹#Isè]    # Iterate through list
            [               # While true, do
             `sˆ            #   Add value to global array and keep next index on stack
                D0‹#Isè     #   Same as above
                       ]    # End loop
                        ¯   # Push global array
— kalsowerus
स्रोत
3

हास्केल , 79 65 59 55 बाइट्स

-6 बाइट्स ब्रूट फोर्स का धन्यवाद ।

x#i|let-1!d=[];i!d=i:x!!i!!d!d=[x!!i!!1|i<-last(i!0)!2]

फ़ंक्शन को परिभाषित करता है #जो पूर्णांकों की सूचियों की एक सूची को स्वीकार करता है, जहां nullइसका प्रतिनिधित्व किया जाता है -1, और नोड मानों की सूची देता है।

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

व्याख्या

let-1!d=[];i!d=i:x!!i!!d!d

फ़ंक्शन को परिभाषित करें !जो नोड पर शुरू होने वाले नोड्स के माध्यम से पुनरावृत्त करता है iऔर एक सूची देखी गई सूची अनुक्रमित करता है। यह दूसरा तर्क स्वीकार करता है d(कि निर्दिष्ट करता है जो "टपल" अगले नोड के सूचकांक के रूप में उपयोग की सूचकांक d==2पुनरावृति करने के लिए आगे, d==0पीछे की ओर पुनरावृति करने के लिए)।

(i!0)

दिए गए इंडेक्स से शुरू करने के लिए पीछे की ओर जाएं और इंडेक्स का दौरा किया।

last(i!0)

अंतिम विज़िट किए गए इंडेक्स को लें, जो सूची की शुरुआत है।

last(i!0)!2

सूची की शुरुआत से Iterate।

[x!!i!!1|i<-last(i!0)!2]

प्रत्येक विज़िट किए गए इंडेक्स को नोड के मान से बदलें।

— user28667
स्रोत
आप सकता है लगभग लिखने x!!i!!1के रूप में i!1!!1है, लेकिन इसकी वजह से टूट जाता है -1आउटपुट में। यदि आप प्रतिनिधित्व करने के लिए null(कहते हैं -9) एक और प्रहरी मूल्य चुनते हैं , तो यह काम करेगा, लेकिन यह हमेशा कुछ इनपुट के लिए टूट जाएगा , जो काफी कष्टप्रद है।
— लिन
3

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

l,n=input()
while~n:m=n;n=l[n][0]
while~m:p,v,m=l[m];print v

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

यह बहुत चास ब्राउन का जवाब है, इन गोल्फों को घटा:

  • मैं n पुन: उपयोग करता हूं, एक असाइनमेंट को सहेज रहा हूं
  • मैं मी में अंतिम वैध एन स्टोर करता हूं, जिससे मुझे अनुमति मिलती है
  • लाइन 3 में असाइनमेंट के बाद प्रिंट रखें, जिससे मुझे फाइनल प्रिंट मिले
  • मैं - ~ ​​n के बजाय केवल ~ n का उपयोग करता हूं, क्योंकि नकारात्मक मान सकारात्मक के समान ही सत्य हैं, जिससे मुझे 2 वर्णों की बचत होती है।
— पॉल थॉमसन
स्रोत
2

MATL , 39 बाइट्स

XHx`HwI3$)t]x6Mt`Hwl3$)tbhwt]x4L)Hw2I$)

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

मेरे ऑक्टेव उत्तर का लगभग सीधा पोर्ट है, लेकिन यह संस्करण सबसे पहले अंत में पाता है, और फिर दूसरे रास्ते के बजाय इसे वापस काम करता है, जिसने एक बाइट को बचाया।

XHx           % Store array in H.
`HwI3$)t]     % Work to the end of the array
x6Mt          % Delete the end of array delimiter, and push the array end index twice
`Hwl3$)    t] % Work to the beginning of the array
       tbhw   % Append all indices found.
Hw2I$)        % Index into original array.
— Sanchises
स्रोत
1

PHP, 132 बाइट्स

<?list(,$x,$y)=$argv;parse_str($x);while(($q=$x[$y*3+1])>=0)$y=$q;do{$n[]=$x[$y*3+2];$y=$x[$y*3];}while($x[$y*3]);echo join(' ',$n);

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

इनपुट एक क्वेरी स्ट्रिंग के रूप में लिया जाता है x[]=-1&x[]=1&x[]=1...के क्रम में, (एक फ्लैट सरणी में सभी नोड्स) next, prev, तो valueनोड्स समाप्त करने के लिए प्रयोग किया जाता है के साथ -1 प्रत्येक नोड के लिए।

— Jo।
स्रोत
1

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

a,n=input()
u=a[n][0]
while-~u:u,v,w=a[u]
while-~w:print v;u,v,w=a[w]
print v

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

संपादित करें: 4 बाइट्स के लिए श्री Xcoder को Thx ...

लिंक किए गए सूची खंड के आरंभ / अंत का प्रतिनिधित्व करने के लिए tuples की सूची [u, v, w] है जहां u और w -1 हैं।

— चास ब्राउन
स्रोत
77 बाइट्स इसे ऑनलाइन आज़माएं! । बूलियन्स int के उपवर्ग हैं इसलिए केवल 0Falsy है, और इसलिए u>=0इसे गोल्फ किया जा सकता है u+1और इसे व्हाट्सएप -~uको हटाने के लिए और छोटा किया जा सकता है ।
— श्री एक्सकोडर
@श्री। Xcoder - हाँ, बिलकुल सही!
— चास ब्राउन
1

ऑक्टेव , 81 78 76 बाइट्स

function o=f(a,n)while q=a(n,1)o=a(n=q,2);end
while n=a(n,3)o=[o a(n,2)];end

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

बल्कि सीधा संस्करण है। व्याख्या पाठक के लिए एक अभ्यास के रूप में छोड़ दी जाती है। बहुत अधिक मजेदार संस्करण नीचे प्रस्तुत किया गया है:

ऑक्टेव , 142 99 92 बाइट्स

@(a,n)[(p=@(b,c,z){q=a(z,2),@()[b(b,c,a(z,c)),q]}{2-~a(z,c)}())(p,1,n),p(p,3,n)(end-1:-1:1)]

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

यो, मैंने सुना है कि आप गुमनाम कार्यों को पसंद करते हैं ...

एक nx3कॉलम लेता है , जिसमें पहला कॉलम पूर्ववर्ती, दूसरा कॉलम वैल्यू, और तीसरा वैल्यू उत्तराधिकारी नोड्स होता है। सभी नोड इंडेक्स 1-आधारित हैं, जो ऑक्टेव में डिफ़ॉल्ट है।

% Create an anonymous function, taking an array a and first node n
@(a,n)
% Returns an array containing the predecessor and sucessor nodes
      [                                                                     ,                     ]
% Defines an recursive anonymous function (by supplying itself to the local namespace)
% which looks at the first column (c=1) or last column (c=3) of the input array to get the next nodes
       (p=@(p,c,z)                                                   )(p,1,n)
% Create a cell array, either containing the end node,
                    {q=a(z,2),                       
% ...or an array with all next  next nodes and the current node
% (note the use of an anonymous function taking no parameters to defer array access, in case of the last node)                
                              @()[p(p,c,a(z,c)),q]}
% depending whether the next node number is nonzero (followed by () to execute the deferred array access)
                                                    {2-~a(z,c)}()
% Do the same with c=3, reverse (function p builds the array right-to-left) and drop the current node to prevent a duplicate.                                                                             
                                                                             p(p,3,n)(end-1:-1:1)
— Sanchises
स्रोत
1

कोटलिन , 85 बाइट्स

{g,S->generateSequence(generateSequence(S){g[it][0]}.last()){g[it][2]}.map{g[it][1]}}

सजा हुआ

{g,S->
    generateSequence(generateSequence(S){g[it][0]}.last()){ g[it][2]}.map { g[it][1] }
}

परीक्षा

typealias Node=Triple<Int?,Int?,Int?>
data class Test(val input: List<Node>, val start:Int, val result: List<Int>)
val TEST = listOf<Test>(
Test(
listOf(Node(null, 12, 1), Node(0, 99, 2), Node(1, 37, null)),
1,
listOf(12, 99, 37)
),
Test(listOf(
Node(2, 99, 1), Node(0, 37, null), Node(null, 12, 0)),
1,
listOf(12, 99, 37)
),
Test(
listOf(Node(8, 5, 6), Node(10, 1, 4), Node(6, 11, null), Node(4, 3, 12), Node(1, 2, 3), Node(12, 8, null), Node(0, 7, 2), Node(null, 0, 10), Node(11, 3, 0), Node(null, 99, null), Node(7, 1, 1), Node(null, 2, 8), Node(3, 5, 5)),
4,
listOf(0, 1, 1, 2, 3, 5, 8)
),
Test(
listOf(Node(8, 5, 6), Node(10, 1, 4), Node(6, 11, null), Node(4, 3, 12), Node(1, 2, 3), Node(12, 8, null), Node(0, 7, 2), Node(null, 0, 10), Node(11, 3, 0), Node(null, 99, null), Node(7, 1, 1), Node(null, 2, 8), Node(3, 5, 5)),
0,
listOf(2, 3, 5, 7, 11)
),
Test(
listOf(Node(8, 5, 6), Node(10, 1, 4), Node(6, 11, null), Node(4, 3, 12), Node(1, 2, 3), Node(12, 8, null), Node(0, 7, 2), Node(null, 0, 10), Node(11, 3, 0), Node(null, 99, null), Node(7, 1, 1), Node(null, 2, 8), Node(3, 5, 5)),
9,
listOf(99)
),
Test(
listOf(Node(13, 80, 18), Node(18, 71, null), Node(5, 10, 19), Node(12, 1, 8), Node(19, 21, null), Node(31, 6, 2), Node(17, 5, 26), Node(26, 0, 30), Node(3, -1, 25), Node(null, 1, 23), Node(27, 6, 17), Node(14, 1, 24), Node(28, -1, 3), Node(null, 80, 0), Node(20, 4, 11), Node(33, 6, 29), Node(24, 9, 33), Node(10, 7, 6), Node(0, 67, 1), Node(2, 15, 4), Node(32, 1, 14), Node(null, 1, 31), Node(29, 3, null), Node(9, -1, 28), Node(11, 5, 16), Node(8, 1, null), Node(6, 3, 7), Node(null, 8, 10), Node(23, 1, 12), Node(15, 5, 22), Node(7, 9, null), Node(21, 3, 5), Node(null, 3, 20), Node(16, 2, 15)),
18,
listOf(80, 80, 67, 71)
),
Test(
listOf(Node(13, 80, 18), Node(18, 71, null), Node(5, 10, 19), Node(12, 1, 8), Node(19, 21, null), Node(31, 6, 2), Node(17, 5, 26), Node(26, 0, 30), Node(3, -1, 25), Node(null, 1, 23), Node(27, 6, 17), Node(14, 1, 24), Node(28, -1, 3), Node(null, 80, 0), Node(20, 4, 11), Node(33, 6, 29), Node(24, 9, 33), Node(10, 7, 6), Node(0, 67, 1), Node(2, 15, 4), Node(32, 1, 14), Node(null, 1, 31), Node(29, 3, null), Node(9, -1, 28), Node(11, 5, 16), Node(8, 1, null), Node(6, 3, 7), Node(null, 8, 10), Node(23, 1, 12), Node(15, 5, 22), Node(7, 9, null), Node(21, 3, 5), Node(null, 3, 20), Node(16, 2, 15)),
8,
listOf(1, -1, 1, -1, 1, -1, 1)
),
Test(
listOf(Node(13, 80, 18), Node(18, 71, null), Node(5, 10, 19), Node(12, 1, 8), Node(19, 21, null), Node(31, 6, 2), Node(17, 5, 26), Node(26, 0, 30), Node(3, -1, 25), Node(null, 1, 23), Node(27, 6, 17), Node(14, 1, 24), Node(28, -1, 3), Node(null, 80, 0), Node(20, 4, 11), Node(33, 6, 29), Node(24, 9, 33), Node(10, 7, 6), Node(0, 67, 1), Node(2, 15, 4), Node(32, 1, 14), Node(null, 1, 31), Node(29, 3, null), Node(9, -1, 28), Node(11, 5, 16), Node(8, 1, null), Node(6, 3, 7), Node(null, 8, 10), Node(23, 1, 12), Node(15, 5, 22), Node(7, 9, null), Node(21, 3, 5), Node(null, 3, 20), Node(16, 2, 15)),
4,
listOf(1, 3, 6, 10, 15, 21)
),
Test(
listOf(Node(13, 80, 18), Node(18, 71, null), Node(5, 10, 19), Node(12, 1, 8), Node(19, 21, null), Node(31, 6, 2), Node(17, 5, 26), Node(26, 0, 30), Node(3, -1, 25), Node(null, 1, 23), Node(27, 6, 17), Node(14, 1, 24), Node(28, -1, 3), Node(null, 80, 0), Node(20, 4, 11), Node(33, 6, 29), Node(24, 9, 33), Node(10, 7, 6), Node(0, 67, 1), Node(2, 15, 4), Node(32, 1, 14), Node(null, 1, 31), Node(29, 3, null), Node(9, -1, 28), Node(11, 5, 16), Node(8, 1, null), Node(6, 3, 7), Node(null, 8, 10), Node(23, 1, 12), Node(15, 5, 22), Node(7, 9, null), Node(21, 3, 5), Node(null, 3, 20), Node(16, 2, 15)),
14,
listOf(3, 1, 4, 1, 5, 9, 2, 6, 5, 3)
),
Test(
listOf(Node(13, 80, 18), Node(18, 71, null), Node(5, 10, 19), Node(12, 1, 8), Node(19, 21, null), Node(31, 6, 2), Node(17, 5, 26), Node(26, 0, 30), Node(3, -1, 25), Node(null, 1, 23), Node(27, 6, 17), Node(14, 1, 24), Node(28, -1, 3), Node(null, 80, 0), Node(20, 4, 11), Node(33, 6, 29), Node(24, 9, 33), Node(10, 7, 6), Node(0, 67, 1), Node(2, 15, 4), Node(32, 1, 14), Node(null, 1, 31), Node(29, 3, null), Node(9, -1, 28), Node(11, 5, 16), Node(8, 1, null), Node(6, 3, 7), Node(null, 8, 10), Node(23, 1, 12), Node(15, 5, 22), Node(7, 9, null), Node(21, 3, 5), Node(null, 3, 20), Node(16, 2, 15)),
17,
listOf(8, 6, 7, 5, 3, 0, 9)
),
Test(
listOf(Node(4, 11, 0), Node(null, 22, 3), Node(null, 33, 3), Node(1, 44, 4), Node(3, 55, null), Node(7, 66, 7), Node(6, 77, 6)),
3,
listOf(22, 44, 55)
),
Test(
listOf(Node(null, -123, null)),
0,
listOf(-123)
)
)

var f:(List<List<Int?>>,Int)-> Sequence<Int?> =
{g,S->generateSequence(generateSequence(S){g[it][0]}.last()){g[it][2]}.map{g[it][1]}}

fun main(args: Array<String>) {
    for ((input, start, result) in TEST) {
        val out = f(input.map { it.toList() }, start).toList()
        if (out != result) {
            throw AssertionError("$input $start $result $out")
        }
    }
}

TIO

TryItOnline

— jrtapsell
स्रोत
मैं बस इच्छा उत्पन्न करता था कि
— साक्षरता
0

जावास्क्रिप्ट ईएस 6, 70 63 बाइट्स

(x,i,a)=>(h=_=>i&&h(a(x[i].v),i=x[i].n))(x.map(_=>i=x[i].p||i))

परीक्षण का मामला:

F([undefined,{p:0,v:12,n:2},{p:1,v:99,n:3},{p:2,v:37,n:0}],1,alert)
— l4m2
स्रोत
alertआपके कार्य के मुख्य भाग में होने की आवश्यकता है और आपके बाइट कुल की ओर गिना जाता है।
— झबरा
— l4m2
+10 / -9 एक आम सहमति नहीं है।
— झबरा
मुझे सटीक + और - s दिखाई नहीं देते हैं। इसके अलावा, यह जावास्क्रिप्ट का इरादा आउटपुट तरीका है, और केवल तभी जब आउटपुट में कुछ देरी होती है
— l4m2
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.