संतुलित बाइनरी सर्च ट्री ओ (लॉग एन) लुकअप (या इसी तरह के संचालन) की गारंटी देने के लिए आवश्यक हैं । एक गतिशील वातावरण में जहाँ बहुत सी कुंजियाँ बेतरतीब ढंग से डाली जाती हैं और / या हटाई जाती हैं, पेड़ लिंक किए गए सूचियों को पतित कर सकते हैं जो कि लुक के लिए भयानक हैं। इस प्रकार विभिन्न प्रकार के स्व-संतुलन वाले द्विआधारी वृक्ष हैं जो इस प्रभाव का प्रतिकार करते हैं (जैसे कि एवीएल पेड़ या चटकते पेड़ )। ये पेड़ विभिन्न प्रकार के घुमावों पर आधारित होते हैं जो पेड़ को फिर से संतुलित करते हैं।

रोटेशन

इस चुनौती में हम केवल एकल दाएं-रोटेशन को देखेंगे, ऐसा रोटेशन (बाएं-रोटेशन सममित होगा) इस तरह दिखता है:

    5            3
   / \          / \
  3   6   =>   1   5
 / \              / \
1   4            4   6

यदि पत्तियों में से कोई भी 1, 4या 6दाएं या बाएं उप-पेड़ एक रोटेशन था, तो बस उन्हें वहां रखा जाएगा। यदि यह एक बड़े पेड़ का उप-योग है, तो हम नोड पर "इसे काट देंगे" और उस नोड के 5लिए घुमाए गए पेड़ (अब नोड 3) को "पुनः संलग्न" करेंगे।

चुनौती

एक बाइनरी सर्च ट्री ¹ को देखते हुए और ऊपर बताए अनुसार उस नोड पर ट्री को राइट-रोटेट करें। उपरोक्त उदाहरण में दी गई कुंजी होगी 5।

नियम और आई / ओ

आप कुंजी के लिए किसी भी प्रकार का उपयोग कर सकते हैं जब तक कि आपकी पसंद की कुंजी और परीक्षण मामलों के बीच कोई आपत्ति न हो
आप बाइनरी पेड़ों के लिए किसी भी प्रतिनिधित्व का चयन कर सकते हैं जब तक कि कोई अस्पष्टता न हो (जैसे [3,[]]कि अस्पष्ट है जब तक कि अन्यथा निर्दिष्ट न हो) और यह आपकी पसंद की भाषा के लिए स्वाभाविक है
चूंकि इनपुट हमेशा एक द्विआधारी खोज ट्री होगा, कोई डुप्लिकेट कुंजी नहीं है
आप मान सकते हैं कि कुंजी पेड़ में निहित है
आप मान सकते हैं कि कुंजी वाले नोड में एक बाएं बच्चा है
आप प्रदान की गई कुंजी के तहत एक सही सबट्री नहीं मान सकते हैं
आप यह नहीं मान सकते हैं कि पेड़ रोटेशन से पहले असंतुलित है
आप यह नहीं मान सकते हैं कि पेड़ रोटेशन के बाद संतुलित है
आप किसी भी डिफ़ॉल्ट I / O विधि का उपयोग कर सकते हैं
आपका सबमिशन एक ऐसा फंक्शन हो सकता है जो पेड़ या पूर्ण कार्यक्रम को हल करता है

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

ये उदाहरण एक पेड़ का प्रतिनिधित्व करते हैं

अगर यह एक पत्ती है: []
यदि यह कुंजी वाला पेड़ है xऔर दोनों उपप्रकार पत्तियां हैं:[x]
यदि यह कुंजी वाला पेड़ है xऔर इसे घटाया गया है left right:[x,left,right]

पहला उदाहरण खंड घुमावों में प्रदान किया गया एक है । यदि किसी कारण से आपको उनमें से एक चित्रमय प्रतिनिधित्व की आवश्यकता है, तो यहां ² आप जाएं।

5 [5,[3,[1],[4]],[6]]  ->  [3,[1],[5,[4],[6]]]
5 [5,[3,[1],[4]],[]]  ->  [3,[1],[5,[4],[]]]
5 [5,[3,[],[4]],[6]]  ->  [3,[],[5,[4],[6]]]
5 [5,[3,[1],[]],[]]  ->  [3,[1],[5]]
4 [8,[4,[2,[1],[3]],[6,[5],[7]]],[12,[10,[9],[11]],[14,[13],[15]]]]  ->  [8,[2,[1],[4,[3],[6,[5],[7]]]],[12,[10,[9],[11]],[14,[13],[15]]]]
8 [10,[8,[6,[4,[2,[],[3]],[5]],[7]],[9]],[11]]  ->  [10,[6,[4,[2,[],[3]],[5]],[8,[7],[9]]],[11]]
10 [10,[8,[6,[4,[2,[],[3]],[5]],[7]],[9]],[11]]  ->  [8,[6,[4,[2,[],[3]],[5]],[7]],[10,[9],[11]]]
9 [6,[3,[2],[5]],[9,[8],[12,[11],[15,[14],[]]]]]  ->  [6,[3,[2],[5]],[8,[],[9,[],[12,[11],[15,[14],[]]]]]]
7 [7,[5,[3,[1],[4]],[6]],[8]]  ->  [5,[3,[1],[4]],[7,[6],[8]]]
15 [17,[9,[5,[2,[0],[4]],[8]],[15,[13,[11,[10],[12]],[14]],[16]]],[40,[27,[21,[19,[18],[20]],[24,[22],[25]]],[28]],[44,[42,[41],[]],[51,[47],[59,[55],[61]]]]]]  ->  [17,[9,[5,[2,[0],[4]],[8]],[13,[11,[10],[12]],[15,[14],[16]]]],[40,[27,[21,[19,[18],[20]],[24,[22],[25]]],[28]],[44,[42,[41],[]],[51,[47],[59,[55],[61]]]]]]
21 [17,[9,[5,[2,[0],[4]],[8]],[15,[13,[11,[10],[12]],[14]],[16]]],[40,[27,[21,[19,[18],[20]],[24,[22],[25]]],[28]],[44,[42,[41],[]],[51,[47],[59,[55],[61]]]]]]  ->  [17,[9,[5,[2,[0],[4]],[8]],[15,[13,[11,[10],[12]],[14]],[16]]],[40,[27,[19,[18],[21,[20],[24,[22],[25]]]],[28]],[44,[42,[41],[]],[51,[47],[59,[55],[61]]]]]]

^{1: इसका मतलब है कि किसी भी नोड के लिए बाईं सबट्री की सभी कुंजियाँ उस कुंजी से छोटी होंगी और सही सबट्री की सभी कुंजियाँ इससे अधिक हैं।}

^{2: लिंक-रोट को रोकने के लिए, मैंने उन्हें एक टिप्पणी के रूप में एम्बेड किया}

— ბიმო
स्रोत

8

हास्केल , 93 92 84 83 82 बाइट्स

data B=B[B]Int|L
k!B[l@(B[x,y]a),r]n|k<n=B[k!l,r]n|k>n=B[l,k!r]n|1>0=B[x,B[y,r]k]a

एक बाइट के लिए @BMO, @alephalpha और @Laikoni और आठ बाइट्स के लिए @nimi का शुक्रिया!

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

— Angs
स्रोत

उपयोग करने से data B=B[B]Intकुछ और बाइट्स बचेंगे।

— लैकोनी

@ लिकोनी सिर्फ एक बाइट मुझे लगता है लेकिन मैं इसे ले

— लूंगा

आप पहले दो मामलों को मर्ज करके 2 बाइट्स बचा सकते हैं, k<n=B[k!l,r]nऔर k>n=B[l,k!r]n, एक में: k/=n=B[k!l,k!r]nऔर फिर जोड़कर k!x=xपैटर्न को संपूर्ण बना सकते हैं।

— राडेक

5

विम , 25 बाइट्स

बफर में इनपुट लेता है - अंतरिक्ष अलग कुंजी और पेड़। पेड़ का प्रतिनिधित्व निम्नानुसार होने की उम्मीद है:

पत्ती: []
मुख्य k, बाएं बच्चे <left>और दाएं बच्चे के साथ नोड <right>:[ k <left><right>]

कुंजी के चारों ओर रिक्त स्थान नहीं kजो महत्वपूर्ण हैं, जैसे कि समाधान मनमाने पेड़ों के लिए काम करता है।

"adw/ <C-r>a⏎3dw%l"apr[%xl%i]

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

व्याख्या

"adw                           " delete the key and trailing space, keep in register a
    / <C-r>a⏎                  " move cursor to the key surrounded with spaces
             3dw               " remove key and [ (move left node to top)
                %l             " move cursor to the right subtree
                  "ap          " insert key there
                     r[        " insert a [ (appending subtree to key)
                       %       " move to the end of new left subtree
                        x      " remove ] (fix parentheses)
                         l%    " move to the end of new right subtree
                           i]  " insert ] (fix parentheses)

पूर्वावलोकन

लिन द्वारा इस स्क्रिप्ट के साथ उत्पन्न पहले परीक्षण मामले का पूर्वावलोकन यहां दिया गया है :

— ბიმო
स्रोत

3

वोल्फ्राम भाषा (गणितज्ञ) , 30 बाइट्स

#2/.a_~b_~c_~#~d_:>b[a,c~#~d]&

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

एक पेड़ इस प्रकार है:

अगर यह एक पत्ता है: $(आप इसे किसी भी मूल्य से बदल सकते हैं जो एक कुंजी नहीं है)
यदि यह कुंजी वाला पेड़ है xऔर इसे घटाया गया है left right:x[left,right]

उदाहरण के लिए, पहले परीक्षण मामले में पेड़ द्वारा दर्शाया गया है 5[3[1[$,$],4[$,$]],6[$,$]]।

स्पष्टीकरण:

#2                                the second input
  /.                              replace
    a_~b_~c_~#~d_                 #[b[a,c],d], where # is the first input
                 :>               by
                   b[a,c~#~d]     b[a,#[c,d]]
                             &    define a function

— alephalpha
स्रोत

3

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

(defun r(k a)(cond((not a)a)((=(car a)k)`(,(caadr a),(cadadr a)(,(car a),(car(cddadr a)),(caddr a))))(t`(,(car a),(r k(cadr a)),(r k(caddr a))))))

इसे ऑनलाइन आज़माएं या सभी टेस्टकेस सत्यापित करें!

एक पेड़ को निम्नानुसार दर्शाया गया है:

एक खाली पेड़ का प्रतिनिधित्व किया जाता है nil(या खाली सूची के रूप में आम लिस्प में ())
एक गैर-खाली पेड़ को तीन तत्वों की सूची के रूप में दर्शाया जाता है (node left-subtree right-subtree) (इसलिए एक पत्ती Lका प्रतिनिधित्व किया जाता है (L nil nil))।

— रेंज़ो
स्रोत

2

जावास्क्रिप्ट (Node.js) , 70 बाइट्स

n=>f=a=>n-a[0]?(a[i=n<a[0]?1:2]=f(a[i]),a):(i=a[1],a[1]=i[2],i[2]=a,i)

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। सभी नोड्स में बाएं और दाएं प्रविष्टियां होनी चाहिए, लेकिन वे []उस तरफ कोई उपप्रकार का संकेत दे सकते हैं । एक संक्षिप्त नाम के रूप में परीक्षण सूट l(N)यह दर्शाता है कि Nएक पत्ती है और l(N,L)यह इंगित करने के लिए कि Nएक बाएं सबट्री है Lलेकिन इनपुट और आउटपुट दोनों पर कोई सही सबट्री नहीं है।

— नील
स्रोत

2

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

R=lambda T,k:k in T and T[1][:2]+[[T[0],T[1][2],T[2]]]or T[:1]+[R(i,k)for i in T[1:]]

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

इनपुट प्रारूप:

ट्री: [KEY, LEFT_SUBTREE, RIGHT_SUBTREE]
पत्ता: []

— आउटगोल्फ को एरिक करें
स्रोत

1

जेली , 24 बाइट्स

ñ
Ḣ,1ịṪƊṭ@ṪṭḢð{Ḣ;ç€ɗ¹¡i?

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

चेतावनी: आम तौर पर, शीर्ष रेखा मौजूद नहीं होनी चाहिए, और नीचे की रेखा में ए ß, नहीं होना चाहिए ç। हालाँकि, चतुर श्रृंखला चालें और ßएक साथ अच्छी तरह से नहीं चलते हैंßचर चर। तकनीकी रूप से, मैं अभी भी शीर्ष पंक्ति को छोड़ सकता था, लेकिन तब परिणाम को एक पूर्ण कार्यक्रम होना चाहिए था, अन्यथा इसे किसी भी कार्यक्रम के अंदर अपनी लाइन के रूप में शामिल करने में सक्षम होना चाहिए, जो तब तक संभव नहीं है जब तक आप 'फिर से भाग्यशाली इसका मतलब यह है कि, दुर्भाग्य से, आउटपुट का अस्पष्ट प्रतिनिधित्व होता, क्योंकि, जब आप एक पूर्ण कार्यक्रम प्रस्तुत करते हैं, तो वास्तव में आउटपुट की गणना क्या हो जाती है, और क्या कार्यक्रम बंद होने से पहले तकनीकी रूप से परिणाम नहीं है। इसलिए, पुनरावृत्ति और उचित स्ट्रिंग प्रतिनिधित्व दोनों के साथ कोई गड़बड़ नहीं करने के लिए, मैंने 2-लाइन फ़ंक्शन सबमिट करने का निर्णय लिया है, जहां शीर्ष पंक्ति का काम बस नीचे कॉल करना है। परिणाम? 2 कीमती और मूल्यवान बाइट्स का एक बड़ा अपशिष्ट। जेली में (और डेनिस, साथ ही हर दूसरे योगदानकर्ता की) रक्षा,

— आउटगोल्फ को एरिक करें
स्रोत

बाइनरी ट्री रोटेशन

रोटेशन

चुनौती

नियम और आई / ओ

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

हास्केल , 93 92 84 83 82 बाइट्स

विम , 25 बाइट्स

व्याख्या

पूर्वावलोकन

वोल्फ्राम भाषा (गणितज्ञ) , 30 बाइट्स

स्पष्टीकरण:

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

जावास्क्रिप्ट (Node.js) , 70 बाइट्स

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

जेली , 24 बाइट्स