मुझे एक समस्या को पूरा करना है, जिसमें एक कार्य एक सरणी के लगातार जोड़े प्राप्त करना है।

उदाहरण के लिए, यदि सरणी [1, 2, 3] है, तो परिणाम X=1 Y=2 और X=2 Y=3 होना चाहिए

इस क्षण तक मेरा कोड ठीक काम करता है, लेकिन उसके बाद, यह 'नहीं' आउटपुट नहीं करता है। इसके बजाय, यह एक अनंत लूप में चिपक जाता है। कठिन हिस्सा यह है कि मुझे इसे बिना रिकर्सन के करना है

मेरा कोड अब तक निम्नलिखित है:

part_of(X, Y, List):-
    length(X, 1),
    append(_, X, Part),
    length(Y, 1),
    append(Part, Y, Part2),
    append(Part2, _, List).

मैं तर्क प्रोग्रामिंग से परिचित नहीं हूँ। मेरे दिमाग में जो कुछ भी चलता है, उसका संबंध वापसी के मूल्यों से है, जो कि निश्चित रूप से यहां नहीं है।

0
Dimitris Karamanis 25 अप्रैल 2020, 19:25

3 जवाब

सबसे बढ़िया उत्तर

X और Y कुछ List के क्रमागत अवयव हैं, यदि List निम्नलिखित रूप का है: कुछ Prefix सूची, फिर X, फिर Y, फिर कुछ Rest सूची।

यह वही है जो आप व्यक्त करने की कोशिश कर रहे थे, लेकिन आप कुछ विवरणों पर भ्रमित हो गए। सबसे पहले, एक-तत्व सूची युक्त X को [X] के रूप में लिखा जाता है। शायद यही आप length(X, 1) के साथ कहना चाह रहे थे, लेकिन यह लिखित रूप में काम नहीं करेगा।

दूसरा, आप append/3 के अपने उपयोग को लेकर भ्रमित हो गए हैं। जिस तरह से आप इसका उपयोग करने की कोशिश कर रहे हैं, आखिरी तर्क वह पूरी सूची है जिसे आप विघटित करने का प्रयास कर रहे हैं। तो इस परिदृश्य में, तीसरा तर्क हमेशा एक सूची होना चाहिए जो पहले से ही ज्ञात है - या तो क्योंकि इसे तर्क के रूप में पारित किया गया है, या क्योंकि इसकी गणना पहले के लक्ष्य द्वारा की गई थी। आपके कोड में, पहला append/3 लक्ष्य append(_, X, Part) है, जहां _ और Part दोनों अज्ञात हैं। इन परिस्थितियों में समाधान की एक अनंत संख्या है, जो आपके द्वारा देखे जाने वाले गैर-समाप्ति का कारण बनती है:

?- append(_, X, Part).
X = Part ;
Part = [_G2897|X] ;
Part = [_G2897, _G2903|X] ;
Part = [_G2897, _G2903, _G2909|X] ;
Part = [_G2897, _G2903, _G2909, _G2915|X] ;
Part = [_G2897, _G2903, _G2909, _G2915, _G2921|X] .

संक्षेप में, आपके पास सही विचार है, लेकिन चीजों को बांधने का क्रम बिल्कुल सही नहीं है। निम्नलिखित कार्य करता है:

?- List = [1, 2, 3], append(Prefix, Part1, List), append([X], Part2, Part1), append([Y], Rest, Part2).
List = Part1, Part1 = [1, 2, 3],
Prefix = [],
X = 1,
Part2 = [2, 3],
Y = 2,
Rest = [3] ;
List = [1, 2, 3],
Prefix = [1],
Part1 = [2, 3],
X = 2,
Part2 = [3],
Y = 3,
Rest = [] ;
false.

यह पहले ज्ञात सूची List = [1, 2, 3] को उसके भागों में विभाजित करता है, जिनमें से केवल बहुत ही सीमित हैं। यह Part1 को एक सीमित सूची से बांधता है। फिर यह परिमित सूची Part1 को विभाजित करता है, Part2 को एक परिमित सूची में बांधता है, और अंत में इसे विभाजित करता है। यदि प्रारंभिक List एक सीमित सूची है, तो गैर-समाप्ति के लिए कोई जगह नहीं है।

उस सब ने कहा, "कुछ सूची, फिर दो आसन्न तत्व X और Y, फिर कुछ अन्य सूची" व्यक्त करने का एक आसान तरीका है:

?- append(_Prefix, [X, Y | _Rest], [1, 2, 3]).
_Prefix = [],
X = 1,
Y = 2,
_Rest = [3] ;
_Prefix = [1],
X = 2,
Y = 3,
_Rest = [] ;
false.
3
Isabelle Newbie 27 अप्रैल 2020, 23:57

यहां बताया गया है कि मैं यह कैसे करूंगा:

pairs([X,Y|_],X,Y).
pairs([_,Y|T],A,B) :- pairs([Y|T],A,B).

पहला विधेय तब सफल होता है जब उसे सूची की शुरुआत से तत्वों की एक जोड़ी मिल सकती है।

दूसरा विधेय तब सफल होता है जब वह सूची से पहले तत्व को हटा सकता है और बाद की जोड़ी प्राप्त करने के लिए pairs/2 को दोबारा कॉल कर सकता है।

मेरे रन का आउटपुट यहां दिया गया है:

?- pairs([a,b,c],X,Y).
X = a,
Y = b ;
X = b,
Y = c ;
false.
0
Enigmativity 27 अप्रैल 2020, 08:38
सही लगता है, लेकिन जैसा कि मैंने उल्लेख किया है, मैं रिकर्सन का उपयोग नहीं करना चाहता, क्योंकि मुझे इसे दो अलग-अलग तरीकों से हल करना है और मैंने पहले से ही रिकर्सन के साथ किया है। हालांकि प्रतिक्रिया के लिए धन्यवाद।
 – 
Dimitris Karamanis
27 अप्रैल 2020, 15:21
1
- प्रोलॉग के लिए रिकर्सन का उपयोग नहीं करना विदेशी है। यह स्टीयरिंग व्हील का उपयोग किए बिना कार चलाने जैसा है।
 – 
Enigmativity
27 अप्रैल 2020, 15:42
इसका कारण हमें फ़ाइंडऑल जैसे एकत्रित कार्यों के बारे में सीखने के लिए मजबूर करना है।
 – 
Dimitris Karamanis
27 अप्रैल 2020, 15:44
- findall पुनरावर्तन की आवश्यकता को नकारता नहीं है। लक्ष्य को पूरा करने के लिए आप जिस भी तकनीक का उपयोग कर रहे हैं, उसका उपयोग करके यह कई समाधान ढूंढता है। length/2 और append/3 दोनों ही रिकर्सन का उपयोग करते हैं। मुझे नहीं पता कि आप इसके बिना जो मांग रहे हैं उसे कैसे कर सकते हैं। क्या आप कृपया हमें बता सकते हैं कि इस असाइनमेंट की आवश्यकताएं क्या हैं?
 – 
Enigmativity
28 अप्रैल 2020, 05:20

यहाँ मेरा बहुत ही सरल उपाय है।

show_elements([X|[]],  _, _).
show_elements([X, Y|Q], A, B):- A is X, B is Y; show_elements([Y|Q], A,B).

यहाँ आउटपुट की एक तस्वीर है, मुझे नहीं पता कि मैंने कार्य को सही ढंग से समझा है या नहीं।

Program output

जैसा कि आप देख सकते हैं, मैंने समस्या को हल करने के लिए रिकर्सन का उपयोग किया। सुनिश्चित करें कि आप रिकर्सन को सही ढंग से समझते हैं। प्रोलॉग में इसका बहुत उपयोग किया जाता है।

एकीकरण की अवधारणा की भी जाँच करें। प्रोलॉग में प्रोग्राम लिखना शुरू करना आवश्यक है।

ऑनलाइन बहुत सारी सामग्री है, और आप इस बहुत उपयोगी मार्गदर्शिका को देख सकते हैं: लीन प्रोलॉग अभी!

-1
Peter Mortensen 26 अप्रैल 2020, 19:45
1
हालांकि मुझे रिकर्सन के बिना ऐसा करने की ज़रूरत है। आउटपुट ठीक वही है जो मुझे चाहिए लेकिन समाधान वह नहीं है जिसे मैं खोजने की कोशिश कर रहा हूं। मुझे वास्तव में उन दोनों की जरूरत है, लेकिन मैंने वही किया जो आपने लिखा था। वैसे भी धन्यवाद, मैं ट्यूटोरियल में भी देख लूंगा, मुझे इसके बारे में पता नहीं था।
 – 
Dimitris Karamanis
26 अप्रैल 2020, 02:55
ओह्ह ठीक है, यह बहुत अच्छा होगा यदि आप असाइनमेंट विवरण पोस्ट कर सकें
 – 
xeitor
26 अप्रैल 2020, 04:19
मैंने आपके कोड को SWI में चलाने की कोशिश की और ERROR: Arithmetic: a/0' is not a function` मिला।
 – 
Enigmativity
27 अप्रैल 2020, 08:36
असाइनमेंट का बहुत सी चीजों से लेना-देना है, इस प्रकार यह अनावश्यक है। केवल एक चीज जो मुझे गलत लगती है, वह वह कार्य है जिसका मैंने वर्णन किया है जो आपके जैसा ही काम करता है, लेकिन बिना रिकर्सन के। यह ग्रीक में भी है और मुझे आधे पृष्ठ का अनुवाद करना होगा, साथ ही मैं इसे एक धोखा मानूंगा यदि मैंने पूरा असाइनमेंट दिया और मैं एक उत्तर की तलाश में था।
 – 
Dimitris Karamanis
27 अप्रैल 2020, 15:18
1
- यह is के कारण है। इसे = में बदलें और यह ठीक काम करता है।
 – 
Enigmativity
28 अप्रैल 2020, 05:16