नमस्कार कार्यकर्ताओं! मैं घोषणात्मक दृष्टिकोण की व्याख्या करके लंबे समय तक आपका ध्यान नहीं रखूंगा, मैं तार्किक प्रोग्रामिंग भाषा का उपयोग करके एक और समस्या को हल करने का प्रस्ताव करने की कोशिश करूंगा, समस्याओं के समाधान और उनके समाधान पर एक घोषणात्मक नज़र के लिए एक विकल्प के रूप में।

टास्क 391. परफेक्ट आयत

N अक्ष-संरेखित आयतों को देखते हुए, जहाँ N> 0, निर्धारित करें कि क्या वे सभी मिलकर एक आयताकार क्षेत्र का एक सटीक आवरण बनाते हैं।
प्रत्येक आयत को नीचे-बाएँ बिंदु और शीर्ष-दाएँ बिंदु के रूप में दर्शाया जाता है। उदाहरण के लिए, एक इकाई वर्ग को [1,1,2,2] के रूप में दर्शाया गया है। (नीचे-बाएँ बिंदु का समन्वय है (1, 1) और शीर्ष-दाएँ बिंदु है (2, 2))।

उदाहरण 1: आयताकार = [
[1,1,3,3]
[3,1,4,2]
[3,2,4,4]
[1,3,2,4]
[2,3,3,4]]
सच लौटा दो। सभी 5 आयताकार मिलकर एक आयताकार क्षेत्र का एक सटीक आवरण बनाते हैं।
...
उदाहरण 3: आयत =
[[1,1,3,3]
[3,1,4,2]
[1,3,2,4]
[3,2,4,4]]
झूठे लौटे। क्योंकि शीर्ष केंद्र में अंतराल है।

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

प्रारंभिक डेटा को एक सूची द्वारा दर्शाया गया है, मैं आपको संक्षेप में याद दिलाता हूं, सूची [हेड | टेल] है, जहां टेल एक सूची है, सूची भी खाली है [] ।

हम 1 तैयार करते हैं

सभी आयतों के कुल क्षेत्रफल की गणना करना आवश्यक है, उन सभी का वर्णन करने वाले आयत का अधिकतम आकार ज्ञात करें और इन दोनों रकमों की तुलना करें, यदि इसका मतलब है कि सभी आयत समान रूप से क्षेत्र को कवर करते हैं। उसी समय, जांचें कि आयतें प्रतिच्छेद नहीं करती हैं, हम प्रत्येक नई आयत को सूची में जोड़ देंगे, शर्त से, यह पिछले सभी को ओवरलैप और प्रतिच्छेद नहीं करना चाहिए।

ऐसा करने के लिए, मैं पूंछ पुनरावृत्ति (वंश पर उर्फ ​​पुनरावृत्ति) का उपयोग करता हूं, एक चक्र का प्रतिनिधित्व करने के लिए सबसे "अनिवार्य" तरीका है। इस तरह के एक "चक्र" में, हम तुरंत क्षेत्रों की कुल राशि और विवरण के आयत, हाइक के न्यूनतम बाएं और अधिकतम दाएं कोणों को प्राप्त करते हैं, आंकड़ों की एक सामान्य सूची जमा करते हुए, जांचते हैं कि कोई चौराहे नहीं हैं।

इस तरह:

findsum([], Sres,Sres,LConerRes,LConerRes,RConerRes,RConerRes,_). findsum([[Lx,Ly,Rx,Ry]|T], Scur,Sres,LConerCur,LConerRes,RConerCur,RConerRes,RectList):- mincon(Lx:Ly,LConerCur,LConerCur2), maxcon(Rx:Ry,RConerCur,RConerCur2), Scur2 is Scur+(Rx-Lx)*(Ry-Ly), not(chekin([Lx,Ly,Rx,Ry],RectList)), findsum(T, Scur2,Sres,LConerCur2,LConerRes,RConerCur2,RConerRes,[[Lx,Ly,Rx,Ry]|RectList]). 

प्रोलॉग में, चर अज्ञात हैं, उन्हें बदला नहीं जा सकता है, वे या तो खाली हैं या उनका मूल्य है, इसके लिए कुछ चरों की आवश्यकता होती है, प्रारंभिक और परिणामी, जब हम सूची के अंत में पहुंच जाते हैं, तो वर्तमान मूल्य परिणाम (नियम की पहली पंक्ति) बन जाएगा। अनिवार्य भाषाओं के विपरीत, के लिए समर्थन प्रोग्राम लाइन को समझने के लिए, आपको उस पूरे रास्ते की कल्पना करने की ज़रूरत है जो इसे ले गया था, और सभी चर का अपना "इतिहास" संचय हो सकता है, वहीं, कार्यक्रम की प्रत्येक पंक्ति वर्तमान नियम के संदर्भ में है, सभी राज्य जो इसे प्रभावित करते हैं वहाँ है प्रवेश नियम।

तो:

 %   mincon(X1:Y1,X2:Y2,X1:Y1):-X1=<X2,Y1=<Y2,!. mincon(_,X2:Y2,X2:Y2). %  maxcon(X1:Y1,X2:Y2,X1:Y1):-X1>=X2,Y1>=Y2,!. maxcon(_,X2:Y2,X2:Y2). 

यहाँ, कोण का प्रतिनिधित्व करने के लिए, फॉर्म एक्स के एक "संरचित शब्द": Y का उपयोग किया जाता है, यह एक संरचना में कई मूल्यों को संयोजित करने का एक अवसर है, इसलिए टपल बोलने के लिए, केवल किसी भी ऑपरेशन में एक फ़नकार हो सकता है। और क्लिपिंग "!" आपको नियम की दूसरी पंक्ति में एक शर्त निर्दिष्ट नहीं करने की अनुमति देता है, यह गणना की दक्षता बढ़ाने का एक तरीका है।

और जैसा कि बाद में पता चला, सबसे महत्वपूर्ण बात आयतों के गैर-चौराहे की जांच करना है, वे सूची में जमा होते हैं:

 %    chekin(X,[R|_]):-cross(X,R),!. chekin(X,[_|T]):-chekin(X,T). %     ,    cross(X,X):-!. cross(X,Y):-cross2(X,Y),!. cross(X,Y):-cross2(Y,X). %,       cross2([X11,Y11,X12,Y12],[X21,Y21,X22,Y22]):-X11<X22,X22=<X12,Y11<Y22,Y22=<Y12,!.%rt cross2([X11,Y11,X12,Y12],[X21,Y21,X22,Y22]):-X11=<X21,X21<X12,Y11<Y22,Y22=<Y12,!.%lt cross2([X11,Y11,X12,Y12],[X21,Y21,X22,Y22]):-X11<X22,X22=<X12,Y11=<Y21,Y21<Y12,!.%rb cross2([X11,Y11,X12,Y12],[X21,Y21,X22,Y22]):-X11=<X21,X21<X12,Y11=<Y21,Y21<Y12. %lb 

आयतों का चौराहा, ये चार विकल्प हैं जो पहले के शीर्ष को दूसरे के अंदर मारते हैं।

और अंतिम बयान:

 isRectangleCover(Rects):- [[Lx,Ly,Rx,Ry]|_]=Rects, findsum(Rects,0,S,Lx:Ly,LconerX:LconerY,Rx:Ry,RconerX:RconerY,[]),!, S=:= (RconerX-LconerX)*(RconerY-LconerY). 

इनपुट पर, आंकड़ों की एक सूची, हम बाएं और दाएं कोनों के प्रारंभिक मूल्यों के लिए पहला लेते हैं, हम उन सभी के चारों ओर जाते हैं, कुल क्षेत्र की गणना करते हैं, और परिणामी मात्रा की तुलना करते हैं। मैं ध्यान देता हूं कि यदि आयतों का एक चौराहा था, तो "इंकार" राशि की खोज, "गिरावट" लौटाती है, इसका मतलब है कि राशियों की तुलना करने के लिए कुछ भी नहीं है। एक ही बात होती है अगर इनपुट सूची में एक भी आंकड़ा नहीं है, तो विफलता होगी, सत्यापित करने के लिए कुछ भी नहीं है ...

अगला, मैं इस परीक्षण को मौजूदा परीक्षणों पर चलाता हूं, और मैं पहले 40 को उद्धृत करता हूं:

 %unit-tests framework assert_are_equal(Goal, false):-get_time(St),not(Goal),!,get_time(Fin),Per is round(Fin-St),writeln(Goal->ok:Per/sec). assert_are_equal(Goal, true):- get_time(St),Goal, !,get_time(Fin),Per is round(Fin-St),writeln(Goal->ok:Per/sec). assert_are_equal(Goal, Exp):-writeln(Goal->failed:expected-Exp). :-assert_are_equal(isRectangleCover([[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]),true). :-assert_are_equal(isRectangleCover([[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]),false). :-assert_are_equal(isRectangleCover([[1,1,3,3],[3,1,4,2],[1,3,2,4],[3,2,4,4]]),false). :-assert_are_equal(isRectangleCover([[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]),false). :-assert_are_equal(isRectangleCover([[0,0,4,1],[0,0,4,1]]),false). 

 :-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[6,2,8,3],[5,1,6,3],[4,0,5,1],[6,0,7,2],[4,2,5,3],[2,1,4,3],[0,1,2,2],[0,2,2,3],[4,1,5,2],[5,0,6,1]]),true). :-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),true). :-assert_are_equal(isRectangleCover([[0,0,4,1]]),true). :-assert_are_equal(isRectangleCover([[0,0,3,3],[1,1,2,2]]),false). :-assert_are_equal(isRectangleCover([[1,1,2,2],[1,1,2,2],[2,1,3,2]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,1,3,2],[1,0,2,2]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,1,1,2],[0,2,1,3],[0,3,1,4]]),true). :-assert_are_equal(isRectangleCover([[0,0,1,1],[1,0,2,1],[2,0,3,1],[3,0,4,1]]),true). :-assert_are_equal(isRectangleCover([[0,0,2,2],[1,1,3,3],[2,0,3,1],[0,3,3,4]]),false). :-assert_are_equal(isRectangleCover([[0,0,3,1],[0,1,2,3],[1,0,2,1],[2,2,3,3]]),false). :-assert_are_equal(isRectangleCover([[1,1,3,3],[2,2,4,4],[4,1,5,4],[1,3,2,4]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,2,1],[1,0,2,1],[0,2,2,3]]),false). :-assert_are_equal(isRectangleCover([[0,0,2,1],[0,1,2,2],[0,2,1,3],[1,0,2,1]]),false). :-assert_are_equal(isRectangleCover([[1,1,2,2],[0,1,1,2],[1,0,2,1],[0,2,3,3],[2,0,3,3]]),false). :-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[6,2,8,3],[5,1,6,3],[6,0,7,2],[4,2,5,3],[2,1,4,3],[0,1,2,2],[0,2,2,3],[4,1,5,2],[5,0,6,1]]),false). :-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,4],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false). :-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,3],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false). :-assert_are_equal(isRectangleCover([[0,0,5,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,1,1],[0,2,1,3]]),false). :-assert_are_equal(isRectangleCover([[0,0,3,3],[1,1,2,2],[1,1,2,2]]),false). :-assert_are_equal(isRectangleCover([[1,1,4,4],[1,3,4,5],[1,6,4,7]]),false). :-assert_are_equal(isRectangleCover([[0,0,3,1],[0,1,2,3],[2,0,3,1],[2,2,3,3]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,1,1],[1,1,2,2],[1,1,2,2]]),false). :-assert_are_equal(isRectangleCover([[1,1,2,2],[1,1,2,2],[1,1,2,2],[2,1,3,2],[2,2,3,3]]),false). :-assert_are_equal(isRectangleCover([[1,1,2,2],[2,1,3,2],[2,1,3,2],[2,1,3,2],[3,1,4,2]]),false). :-assert_are_equal(isRectangleCover([[0,1,2,3],[0,1,1,2],[2,2,3,3],[1,0,3,1],[2,0,3,1]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,2,1,3],[1,1,2,2],[2,0,3,1],[2,2,3,3],[1,0,2,3],[0,1,3,2]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[0,0,1,1],[2,2,3,3]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[0,1,1,2],[0,2,1,3],[1,0,2,1],[1,0,2,1],[1,2,2,3],[2,0,3,1],[2,1,3,2],[2,2,3,3]]),false). :-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[2,1,4,3],[0,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1]]),false). :-assert_are_equal(isRectangleCover([[0,0,4,1],[7,0,8,2],[5,1,6,3],[6,0,7,2],[4,0,5,1],[4,2,5,3],[2,1,4,3],[-1,2,2,3],[0,1,2,2],[6,2,8,3],[5,0,6,1],[4,1,5,2]]),false). :-assert_are_equal(isRectangleCover([[0,0,1,1],[1,0,2,1],[1,0,3,1],[3,0,4,1]]),false). :-assert_are_equal(isRectangleCover([[1,2,4,4],[1,0,4,1],[0,2,1,3],[0,1,3,2],[3,1,4,2],[0,3,1,4],[0,0,1,1]]),true). 

और यह अंत नहीं है, "कठिन" खंड से कार्य, 41 परीक्षणों में वे 10,000 आयतों की एक सूची प्रदान करते हैं, पिछले पांच परीक्षणों में मुझे सेकंड में ऐसे समय मिलते हैं:

 test 41:length=10000 goal->ok:212/sec test 42:length=3982 goal->ok:21/sec test 43:length=10222 goal->ok:146/sec test 44:length=10779 goal->ok:41/sec test 45:length=11000 goal->ok:199/sec 

मैं इनपुट मूल्यों को नहीं ला सकता, वे संपादक में फिट नहीं होते, मैं इस तरह से परीक्षण 41 संलग्न करूंगा।

रिकॉर्डिंग 2

पिछले दृष्टिकोण, आंकड़े जमा करने के लिए सूची का उपयोग करते हुए, बहुत अप्रभावी हो जाता है, जो परिवर्तन खुद पता चलता है - जटिलता n ^ 2 के बजाय, n * लॉग (n) बनाते हैं। आप आयतों की सूची के चौराहों की जांच करने के लिए पेड़ का उपयोग कर सकते हैं।

प्रोलॉग के लिए बाइनरी ट्री भी एक संरचित शब्द है, और एक सूची के रूप में इसे पुनरावर्ती रूप से परिभाषित किया गया है, पेड़ खाली है या इसमें एक मान और दो उपप्रकार शामिल हैं ।

मैं इसके लिए एक ट्रिपल फ़ंक्टर का उपयोग करता हूं: t (LeftTree, RootValue, RightTree), और खाली पेड़ होगा []।

बाईं ओर ऑर्डर करने के साथ संख्याओं का एक सरल पेड़ छोटा है और दाईं ओर बड़ा है, इसे इस तरह व्यक्त किया जा सकता है:

 add_to_tree(X,[],t([],X,[])). add_to_tree(X,t(L,Root,R),t(L,Root,NewR)):- X<Root,!,add_to_tree(X,R,NewR). add_to_tree(X,t(L,Root,R),t(NewL,Root,R)):- add_to_tree(X,L,NewL). 

आई। ब्रैटको की क्लासिक किताब "प्रोलॉगिंग फॉर आर्टिफिशियल इंटेलिजेंस" में, एवीएल द्वारा संतुलित 2-3 पेड़ों की कई अहसास दिए गए हैं ...

मैं आयतों के आदेश के मुद्दे को निम्नानुसार हल करने का प्रस्ताव करता हूं: यदि आयत दूसरे के दाईं ओर है, तो वे प्रतिच्छेद नहीं करते हैं, और जो बाईं ओर हैं उन्हें चौराहे के लिए चेक किया जाना चाहिए। और दाईं ओर, यह तब होता है जब एक का दायां कोना दूसरे के बाएं कोने से कम होता है:

 righter([X1,_,_,_],[_,_,X2,_]):-X1>X2. 

और एक पेड़ में आंकड़े जमा करने का कार्य, चौराहे के लिए प्लस चेकिंग इस तरह लग सकता है, जब एक नई आयत जड़ के दाईं ओर होती है, तो आपको दाईं ओर जांच करने की आवश्यकता है, अन्यथा बाईं तरफ के चौराहों की जांच करें:

 treechk(X,[],t([],X,[])). treechk([X1,Y1,X2,Y2],t(L,[X1,Y11,X2,Y22],R),t(L,[X1,Yr,X2,Yr2],R)):- (Y1=Y22;Y2=Y11),!,Yr is min(Y1,Y11),Yr2 is max(Y2,Y22). %union treechk(X,t(L,Root,R),t(L,Root,NewR)):- righter(X,Root),!,treechk(X,R,NewR). treechk(X,t(L,Root,R),t(NewL,Root,R)):- not(cross(X,Root)),treechk(X,L,NewL). 

तुरंत दूसरे को ध्यान में रखा गया चाल विशेषता, यदि आयत समान चौड़ाई की है, और एक आम चेहरा है, तो उन्हें एक में जोड़ा जा सकता है और पेड़ में नहीं जोड़ा जा सकता है, लेकिन बस एक नोड में आयत के आकार को बदल दें। टेस्ट 41 इसके लिए जोर दे रहा है, ऐसा डेटा है: [[0, -1,1,0], [0,0,1,1], [0,1,1,2], [0,2,1, 3], [0,3,1,4], [0,4,1,5], [0,5,1,6], [0,6,1,7], [0,7,1] 8], [0,8,1,9], [0,9,1,10], [0,10,1,11], [0,11,1,12], [0,12,1,] 13], [0,13,1,14], ..., [0,9998,1,9999]]।

हम इन सुधारों को पिछले समाधान के साथ जोड़ते हैं, मैं उन्हें पूरी तरह से देता हूं, कुछ सुधारों के साथ:

 treechk(X,[],t([],X,[])). treechk([X1,Y1,X2,Y2],t(L,[X1,Y11,X2,Y22],R),t(L,[X1,Yr,X2,Yr2],R)):- (Y1=Y22;Y2=Y11),!,Yr is min(Y1,Y11),Yr2 is max(Y2,Y22). %union treechk(X,t(L,Root,R),t(L,Root,NewR)):- righter(X,Root),!,treechk(X,R,NewR). treechk(X,t(L,Root,R),t(NewL,Root,R)):- not(cross(X,Root)),treechk(X,L,NewL). righter([X1,_,_,_],[_,_,X2,_]):-X1>X2. findsum([],Sres,Sres,LConerRes,LConerRes,RConerRes,RConerRes,_). findsum([[Lx,Ly,Rx,Ry]|T],Scur,Sres,LConerCur,LConerRes,RConerCur,RConerRes,RectTree):- coner(Lx:Ly,LConerCur,=<,LConerCur2), coner(Rx:Ry,RConerCur,>=,RConerCur2), Scur2 is Scur+abs(Rx-Lx)*abs(Ry-Ly), treechk([Lx,Ly,Rx,Ry],RectTree,RectTree2),!, findsum(T,Scur2,Sres,LConerCur2,LConerRes,RConerCur2,RConerRes,RectTree2). isRectangleCover(Rects):- [[Lx,Ly,Rx,Ry]|_]=Rects, findsum(Rects,0,S,Lx:Ly,LconerX:LconerY,Rx:Ry,RconerX:RconerY,[]),!, S=:= abs(RconerX-LconerX)*abs(RconerY-LconerY). coner(X1:Y1,X2:Y2,Dir,X1:Y1):-apply(Dir,[X1,X2]),apply(Dir,[Y1,Y2]),!. coner(_,XY,_,XY). cross(X,X):-!. cross(X,Y):-cross2(X,Y),!. cross(X,Y):-cross2(Y,X). cross2([X11,Y11,X12,Y12],[_,_,X22,Y22]):-X11<X22,X22=<X12, Y11<Y22,Y22=<Y12,!. %right-top cross2([X11,Y11,X12,Y12],[X21,_,_,Y22]):-X11=<X21,X21<X12, Y11<Y22,Y22=<Y12,!. %left-top cross2([X11,Y11,X12,Y12],[_,Y21,X22,_]):-X11<X22,X22=<X12, Y11=<Y21,Y21<Y12,!. %right-bottom cross2([X11,Y11,X12,Y12],[X21,Y21,_,_]):-X11=<X21,X21<X12, Y11=<Y21,Y21<Y12. %left-bottom 

यहाँ "भारी" परीक्षणों का क्रम है:

 goal-true->ok:0/sec 41:length=10000 goal-true->ok:0/sec 42:length=3982 goal-true->ok:0/sec 43:length=10222 goal-true->ok:2/sec 44:length=10779 goal-false->ok:1/sec 45:length=11000 goal-true->ok:1/sec 

मैं इस सुधार को पूरा करूंगा, सभी परीक्षण सही तरीके से पास होंगे, समय संतोषजनक है। जो रुचि रखते हैं, मेरा सुझाव है कि आप ऑनलाइन या यहां प्रयास करें ।

कुल मिलाकर

फ़ंक्शनल प्रोग्रामिंग से संबंधित लेख पोर्टल पर एक निरंतर आवृत्ति के साथ पाए जाते हैं। मैं घोषणात्मक दृष्टिकोण के एक अन्य पहलू पर स्पर्श करता हूं - तार्किक प्रोग्रामिंग। आप एक तार्किक विवरण का उपयोग करके कार्यों का प्रतिनिधित्व कर सकते हैं, तथ्य और नियम, परिसर और परिणाम, रिश्ते और पुनरावर्ती रिश्ते हैं। कार्य विवरण को वर्णन करने वाले संबंधों के समूह में बदलना चाहिए। परिणाम समस्या के सरल घटकों में अपघटन का परिणाम है।

एक घोषणात्मक भाषा में एक कार्यक्रम को बयानों के एक सेट के रूप में इस्तेमाल किया जा सकता है जो कि परिणाम का निर्माण करना चाहिए, इसके सफल निर्माण में एक समस्या का समाधान। और अनुकूलन में उदाहरण के लिए शामिल हो सकता है, जिसमें आयतों के चौराहों को नियंत्रित करने के लिए विधि के "सरसरी" विवरण को स्पष्टीकरण की आवश्यकता हो सकती है, अधिक कुशल गणना के लिए एक पेड़ संरचना का निर्माण करना संभव है।

और ... कहीं प्रोलॉग स्रोत कोड की शैलियों से गायब हो गया, आधे साल पहले मैंने इसका इस्तेमाल किया था। मुझे "बहन" एर्लांग को निर्दिष्ट करना था। लेकिन क्या यह "लोकप्रियता" की तरह नहीं है, फोरट्रान और बेसिक इस सूची में नहीं हैं, भाषाओं की रेटिंग क्या है?