यात्री, नमस्ते।

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

चलिए, व्यापार पर उतरते हैं, मैंने उससे पहले लिखा था कि आप को खुश करने की कोशिश के बारे में, इसलिए मैं प्रस्तावना का उपयोग करने का एक उदाहरण दिखाना जारी रखूंगा, हालांकि पिछले लेखों से पता चला है कि अजगर में रुचि और यहां तक ​​कि एक साथ कई हजार लोगों के लिए ब्याज का कारण होगा, एक नई बैटरी के बारे में समाचार में दिलचस्पी टेस्ला के लिए, है stotysch विचारों, और पोर्टल razrabotnichestskom तो कुछ नहीं, तो इस व्यवहार के पीछे देखा पर कार्यक्रमों लिखने के लिए टिप्पणियों को पढ़ने पर उल्लेख किया गया था, और शायद उनमें से पांच, इस प्रस्ताव Esch की दूसरी पढ़ने के बाद यह विचार है कि इसे और अधिक पढ़ना चाहिए confuses ...

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

मैं यह कहूंगा कि समय यात्रा मौजूद नहीं है, लेकिन हम एक सप्ताह पहले गए थे, टेप में तीन भागों के बारे में एक दिलचस्प प्रस्तावना थी, यह वहाँ था कि एक यादृच्छिक रूप से सामना की गई नई समस्या को हल करने का विषय छू गया था, मैं इस दिलचस्प साइट को ले लेता हूं और सबसे मुश्किल काम (केवल स्ट्रिंग को एक संख्या में नहीं बदलकर)), मैं इसे प्रोलॉग में करने की कोशिश करूंगा।

ब्याज उठाना बंद करें, शुरू करें ...

टास्क 446 अंकगणितीय-स्लाइस-ii-laterence

संख्याओं के अनुक्रम को अंकगणित कहा जाता है यदि इसमें कम से कम तीन तत्व होते हैं और यदि किसी भी दो लगातार तत्वों के बीच अंतर समान है।
उदाहरण के लिए, ये अंकगणितीय क्रम हैं:
1, 3, 5, 7, 9
7, 7, 7, 7
3, -1, -5, -9
निम्नलिखित अनुक्रम अंकगणित नहीं है।
1, 1, 2, 5, 7

सभी में, दोनों पड़ोसियों के बीच अंतर को संरक्षित किया जाना चाहिए, बस इसे जांचने की आवश्यकता है?
पर पढ़ें:

एक शून्य-अनुक्रमित सरणी A में N संख्या शामिल है। उस सरणी का एक बाद का टुकड़ा पूर्णांक (P0, P1, ..., Pk) का कोई अनुक्रम है, जैसे कि 0 1 P0 <P1 <... <Pk <N।
सरणी A के एक परवर्ती स्लाइस (P0, P1, ..., Pk) को अंकगणित कहा जाता है यदि अनुक्रम A [P0], A [P1], ..., A [Pk-1], A [Pk] अंकगणित है। । विशेष रूप से, इसका मतलब है कि k, 2।
फ़ंक्शन को ए में अंकगणितीय परवर्ती स्लाइस की संख्या वापस करना चाहिए।

वाह शब्द, आपको यह पता लगाने की आवश्यकता है कि आप कितने स्लाइस को पूरा कर सकते हैं, आप उप-सूची के लिए कितने विकल्प पा सकते हैं, ताकि आसन्न वस्तुओं के बीच अंतर न हो।

यह ऐसा है जैसे कि इनपुट सूची के सभी क्रमपरिवर्तन के एक बड़े समूह में सब्लिस्ट हैं।

उदाहरण:
इनपुट: [२, ४, ६, 4, १०]
आउटपुट: 7
स्पष्टीकरण:
सभी अंकगणितीय परवर्ती स्लाइस हैं:
[2,4,6]
[4,6,8]
[6,8,10]
[2,4,6,8]
[4,6,8,10]
[2,4,6,8,10]
[2,6,10]

मुझे पता है कि एक प्रस्तावना में एक सबलिस्ट कैसे व्यक्त करें:

sublists(InputList, SubList):- append(Prefix,Root,InputList), append(SubList,Suffix,Root). 

जांच कैसे करें कि वांछित प्रकार की सूची त्रिकोणीय में जांचना आवश्यक है:

 is_seq(A,B,C]):-AB =:=BC. is_seq(A,B,C|Tail]):-AB =:=BC, is_seq(B,C|Tail]). 

यदि हम सूची के सभी तत्वों के क्रमपरिवर्तन को छोड़ देते हैं, तो यह पता चलता है कि यह पास में खड़े तत्वों का सिर्फ एक सबलिस्ट नहीं है, यह एक ऐसा सबलिस्ट है जो आइटम को छोड़ कर बनाया गया था।

फिर इसे इस तरह लगाएं:

 seq(_,[]). seq([H|T],[H|T1]):-seq(T,T1). seq([_|T],T1):-seq(T,T1). 

ऐसा नियम सूची से सभी संभावित उपविदों को लौटा देगा, लेकिन यह एक तत्व से शुरू हो सकता है, या इसे छोड़ सकता है, अगले से, किसी भी मात्रा को अंत में त्याग दिया जा सकता है।

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

इस समस्या के लिए प्रस्तावित परीक्षणों की समीक्षा करने के बाद, यह पता चला कि इनपुट पर डुप्लिकेट मान हो सकते हैं, ऐसी सूची के लिए [0,1,2,2,2] 4 समाधान होने चाहिए। प्रत्येक 2-का को अलग से लिया जा सकता है, और इसे एक अलग टुकड़ा माना जाना चाहिए, इसलिए तीन विकल्प [0,1,2] और एक [2,2,2] उपयुक्त हैं।

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

मैं तत्वों की एक साधारण संख्या बनाऊंगा, सूची को घटकों की सूची में बदल दें मूल्य / सूचकांक, एक संरचित शब्द, यह वही है जिसे वे कहते हैं। उपरोक्त उदाहरण के लिए, यह [0 / 1,1 / 2,2 / 3,2 / 4,2 / 5] होगा। इस इनपुट द्वारा उत्पन्न क्रम सभी अलग-अलग होंगे।

इसलिए, आप सूची को एक चिह्नित में बदल सकते हैं:

 label([],[],_). label([A|T],[A/N|T1],N):-N1 is N+1, label(T,T1,N1). 

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

इनपुट में एक चिह्नित सूची है, आउटपुट मुख्य मूल्य होगा, इसे एक पूर्णांक के रूप में गणना करें जिनके अंक प्रत्येक तत्व के लिए मूल्य + सूचकांक का योग हैं।

 %is_seq ,  ,  is_seq([A/An,B/Bn,C/Cn],2,N):- AB=:=BC, N is 10000*(A+An)+100*(B+Bn)+(C+Cn). is_seq([A/An,B/Bn,C/Cn|T],K,N):- AB=:=BC, is_seq([B/Bn,C/Cn|T],K1,N1), K is K1+1, N is N1+(A+An)*(100**K). 

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

 get_number(List,N) :- label(List,ListL,1), setof(Len,K^Sub^(seq(ListL,Sub),is_seq(Sub,K,Len)),Result), length(Result,N),!. get_number(_,0). 

बेशक, ऐसे समाधान में प्रदर्शन विशेष रूप से व्यक्त नहीं किया गया था।

यहां परीक्षणों का एक सूची के साथ कार्यक्रम का ऐसा पूरा पाठ है, जो कार्य के साथ साइट से कट्टर मछली है (यह परीक्षण का सिर्फ एक हिस्सा है):

 label([],[],_). label([A|T],[A/N|T1],N):-N1 is N+1, label(T,T1,N1). seq(_,[]). seq([H|T],[H|T1]):-seq(T,T1). seq([_|T],T1):-seq(T,T1). is_seq([A/An,B/Bn,C/Cn],2,N):- AB=:=BC, N is 10000*(A+An)+100*(B+Bn)+(C+Cn). is_seq([A/An,B/Bn,C/Cn|T],K,N):- AB=:=BC, is_seq([B/Bn,C/Cn|T],K1,N1), K is K1+1, N is N1+(A+An)*(100**K). get_number(List,N) :- label(List,ListL,1),setof(Len,K^Sub^(seq(ListL,Sub),is_seq(Sub,K,Len)),Result), length(Result,N),!. get_number(_,0). %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). %all test :-assert_are_equal(get_number([2,4,6,8,10],7),true). :-assert_are_equal(get_number([],0),true). :-assert_are_equal(get_number([1],0),true). :-assert_are_equal(get_number([1,2],0),true). :-assert_are_equal(get_number([1,2,3],1),true). :-assert_are_equal(get_number([1,2,3,4],3),true). :-assert_are_equal(get_number([1,2,3,4,5],7),true). :-assert_are_equal(get_number([1,2,3,4,5,6],12),true). :-assert_are_equal(get_number([1,2,3,4,5,6,7],20),true). :-assert_are_equal(get_number([1,2,3,4,5,6,7,8],29),true). :-assert_are_equal(get_number([1,2,3,4,5,6,7,8,9],41),true). :-assert_are_equal(get_number([1,2,3,4,5,6,7,8,9,10],55),true). :-assert_are_equal(get_number([2,2,3,4],2),true). :-assert_are_equal(get_number([0,1,2,2,2],4),true). :-assert_are_equal(get_number([0,2000000000,-294967296],0),true). :-assert_are_equal(get_number([1,1,1],1),true). :-assert_are_equal(get_number([1,1,1,1],5),true). :-assert_are_equal(get_number([1,1,1,1,1],16),true). :-assert_are_equal(get_number([1,1,1,1,1,1],42),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1],99),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1],219),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1],466),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1],968),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1],1981),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1],4017),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1],8100),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1],16278),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],32647),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],65399),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],130918),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],261972),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],524097),true). :-assert_are_equal(get_number([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],1048365),true). 

निराशाजनक परिणाम के रूप में, यहाँ इस तरह की दक्षता है:

 get_number([2, 4, 6, 8, 10], 7)->ok:0/sec get_number([], 0)->ok:0/sec get_number([1], 0)->ok:0/sec get_number([1, 2], 0)->ok:0/sec get_number([1, 2, 3], 1)->ok:0/sec get_number([1, 2, 3, 4], 3)->ok:0/sec get_number([1, 2, 3, 4, 5], 7)->ok:0/sec get_number([1, 2, 3, 4, 5, 6], 12)->ok:0/sec get_number([1, 2, 3, 4, 5, 6, 7], 20)->ok:0/sec get_number([1, 2, 3, 4, 5, 6, 7, 8], 29)->ok:0/sec get_number([1, 2, 3, 4, 5, 6, 7, 8, 9], 41)->ok:0/sec get_number([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 55)->ok:0/sec get_number([2, 2, 3, 4], 2)->ok:0/sec get_number([0, 1, 2, 2, 2], 4)->ok:0/sec get_number([0, 2000000000, -294967296], 0)->ok:0/sec get_number([1, 1, 1], 1)->ok:0/sec get_number([1, 1, 1, 1], 5)->ok:0/sec get_number([1, 1, 1, 1, 1], 16)->ok:0/sec get_number([1, 1, 1, 1, 1, 1], 42)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1], 99)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1], 219)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1], 466)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 968)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 1981)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 4017)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 8100)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 16278)->ok:0/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 32647)->ok:1/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 65399)->ok:1/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 130918)->ok:3/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 261972)->ok:6/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 524097)->ok:12/sec get_number([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], 1048365)->ok:27/sec 

एक सूची एकत्र करना, यहां तक ​​कि सिर्फ निर्णय कुंजी, बहुत ही बोझिल है, लेकिन यह एक घोषणात्मक निर्णय है, जिसके बिना सभी अद्वितीय समाधानों को गिनना संभव नहीं है।

आउटपुट।

यह है कि प्रोलॉग भाषा में कार्य कैसे तैयार किए जाते हैं, बस समस्या के बयान को कार्यक्रम में स्थानांतरित करना अपर्याप्त दक्षता से भरा हुआ है। या शायद इस समस्या में केवल एक एल्गोरिदम समाधान उपलब्ध है? प्रक्रिया कितनी जटिल है?

फिर से मैं सवाल छोड़ता हूँ ...

सभी समान, उत्तरों की खोज हमारे पेशे में दिलचस्प है, है ना?