प्रोलॉग - आप किसी सूची में किसी तत्व को तत्व कैसे जोड़ते हैं?

Question

यदि मेरे पास एक्स = [1, 2, 3, 4] जैसे प्रोलॉग में एक सूची है, तो मैं एक्स = [1, 2, 3, 4, 5 के लिए सूची के अंत में तत्व 5 कैसे जोड़ूं ]?

संलग्न समारोह की जरूरत है दो सूचियों, यानी संलग्न (ए, बी, सी) ए और बी सूची सी

मैं एक अस्थायी सूची वाई = [1, 2 के साथ ऐसा कर सकते हैं करने के लिए श्रेणीबद्ध प्राप्त करने के लिए, 3, 4] और जेड = [5], फिर एक संलग्न (वाई, जेड, एक्स) करें, लेकिन मुझे अस्थायी सूची पसंद नहीं है।

सामान्य अस्वीकरण यहां लागू होते हैं - यह होमवर्क नहीं है और मैं सिर्फ प्रोलॉग सीख रहा हूं।

Answer 1

प्रोलॉग में चर केवल एक बार असाइन किया जा सकता है। जैसे ही एक्स के पास मूल्य होता है [1,2,3,4] इसका कोई अन्य मूल्य कभी नहीं हो सकता है। एक अस्थायी चर और संलग्न/3, जैसा आपने बताया है, ऐसा करने का तरीका है।

ऐसा कहकर, आप एक चाल कर सकते हैं जिसकी शायद अनुशंसा नहीं की जाती है। यदि एक्स = [1,2,3,4, वाई] तो आप वाई = 5 और एक्स कर सकते हैं अब आपके पास इच्छित वैल्यू है। मेरा मानना ​​है कि इस तकनीक को एक अंतर सूची कहा जाता है।

Answer 2

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

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

Answer 3

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

% add_tail(+List,+Element,-List) 
% Add the given element to the end of the list, without using the "append" predicate. 
add_tail([],X,[X]). 
add_tail([H|T],X,[H|L]):-add_tail(T,X,L). 

मैं सलाह है कि आप केवल, append समारोह का उपयोग करेंगे एक अंतर्निहित समारोह यह कुछ भी मैन्युअल रूप से तैयार की तुलना में तेजी रहने की संभावना है के रूप में होगा।

Answer 4

एक घोषणात्मक समाधान एक अंतर सूची का उपयोग करना है (जैसा कि डैनियल ने इसके उत्तर में सुझाव दिया है)। एक अंतर सूची का नाम आमतौर पर दो सूचियों के बीच एक अंतर के रूप में दर्शाया जा रहा है: एक सूची और इसकी पूंछ। उदाहरण के लिए, एक खाली सूची को T-T के रूप में दर्शाया जा सकता है। तत्व 1, 2, और 3 के साथ एक सूची को [1,2,3| T]-T के रूप में दर्शाया जा सकता है (ध्यान दें कि (-)/2 मानक अंतर्निहित इंफिक्स ऑपरेटर है)। इस प्रतिनिधित्व का लाभ यह है कि आप append/3 विधेय के एक भी तथ्य परिभाषा का उपयोग करके निरंतर समय में एक सूची में एक तत्व जोड़ सकते हैं है:

append(L1-T1, T1-T2, L1-T2). 

एक के उपयोग का उदाहरण:

?- append([1,2,3,4| T1]-T1, [5| T2]-T2, Result). 
T1 = [5|T2], 
Result = [1, 2, 3, 4, 5|T2]-T2. 

यदि आवश्यक हो

, "सामान्य" सूची और एक अंतर सूची के बीच कनवर्ट करना मुश्किल नहीं है। मैं इसे आपके लिए एक अभ्यास के रूप में छोड़ देता हूं।

Answer 5

आप Prolog में सूचियों को संशोधित नहीं कर सकते हैं, लेकिन आप एक अनिर्दिष्ट लंबाई के साथ एक सूची बना सकते हैं:

:- initialization(main). 

main :- 
    A = [1,2,3,4|_], 
    nth0(4,A,5), 
    writeln(A). 

:

main :- 
    A = [1,2,3,4|_]. 

उसके बाद, आप एक तत्व SWI-Prolog में nth0/3 का उपयोग कर सम्मिलित कर सकते हैं

इस तत्व को डालने के बाद, A = [1,2,3,4,5|_]।

तुम भी एक समारोह है कि यथा-स्थान एक सूची के अंत में एक आइटम जोड़ देती परिभाषित कर सकते हैं, और उसके बाद इस तरह इसका इस्तेमाल:

:- initialization(main). 

append_to_list(List,Item) :- 
    List = [Start|[To_add|Rest]], 
    nonvar(Start), 
    (var(To_add),To_add=Item;append_to_list([To_add|Rest],Item)). 

main :- 
    A = [1,2,3|_], 
    append_to_list(A,4), 
    append_to_list(A,4), 
    writeln(A). 

इस उदाहरण में, A = [1,2,3,4,4|_] इन दो मदों के बाद जोड़ दिए जाते हैं।

Answer 6

चूंकि प्रोल ने संलग्न किया है जो केवल सूचियों को स्वीकार करता है, हम सूचियों में से किसी एक में हमारे तत्व को सम्मिलित क्यों नहीं करते हैं। यानी

% E = element, L = list, R = result 
% e.g. add_elem_in_list ([1,2,3,4], 5, R). 
add_elem_in_list(L, E, R) :- append(L, [E], R).