अंकगणित का उपयोग किए बिना (=< , =>, आदि)!

मेरे पास ब्लॉक के कुछ अलग ढेर हैं, उदाहरण के लिए दो ढेर। मुझे यह पता लगाने का एक तरीका चाहिए कि ब्लॉक ए ब्लॉक बी की तुलना में किसी भी ढेर पर अधिक बैठता है या नहीं।

उदाहरण के लिए:

       is_on_top(Block1,Pile,Block2). %relations of blocks in a particular pile

उदाहरण के लिए:

         is_bellow(a,1,b). % a is bellow b in pile number 1
         is_bellow(r,2,e).
         is_bellow(f,2,null). % is at top.
         ....
         and so on.

मैं यह पता लगाने की कोशिश कर रहा हूं कि विधेय कैसे लिखना है:

is_higher(Block1,Block2):-    %block1 is higher than block2 in Any line.




 % to check for the same line if a block is higher than another I'm this

 % is Block1 higher than Block2 in THE SAME pile.

taller(Block1, Block2) :-
    is_bellow(Block2,_,Block1).

taller(Block1, Block2) :-
    is_bellow(Y, I,Block1), 
    taller(Y, Block2).

क्या अंकगणित का उपयोग किए बिना इसे करना संभव है?

मुझे लगता है कि मेरे पास समाप्ति की स्थिति है।

is_higher(Block1,Block2):-
is_bellow(Block1,_,null), is_bellow(Block2,_,X).
X \= null.

is_higher(Block1,Block2):-  % don't know how to continue.
0
Benny Abramovici 23 जुलाई 2020, 17:12

2 जवाब

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

टिप्पणियों से:

मैंने सोचा था कि दोनों ब्लॉकों पर गहरी खुदाई करने की तर्ज पर ब्लॉक एक को नल के साथ जोड़ा जाता है, लेकिन मैं इसके चारों ओर अपना सिर नहीं पा सकता।

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

यदि आप एक पूरा उदाहरण पोस्ट करते तो अच्छा होता। यहां वह है जिसका मैं उपयोग करूँगा:

is_below(a, 1, b).
is_below(b, 1, null).  % topmost on pile

is_below(c, 2, d).
is_below(d, 2, e).
is_below(e, 2, f).
is_below(f, 2, null).  % topmost on pile

मैं इसे निम्नलिखित दुनिया को मॉडल करने के लिए समझता हूं:

             f
             e
  b          d
  a          c
-----------------
pile 1     pile 2

अब बात करते हैं इस दुनिया से जुड़ी अवधारणाओं की। सबसे पहले... एक ब्लॉक भी क्या है? प्रतिनिधित्व निहित है, लेकिन ऐसा प्रतीत होता है कि एक ब्लॉक कुछ ऐसा है जो ढेर पर है। "ढेर पर" होना कुछ हद तक निहित भी है, लेकिन इसका अर्थ है कुछ से नीचे होना - एक अन्य ब्लॉक, या विशेष गैर-ब्लॉक परमाणु null

तो यह एक ब्लॉक है:

% block(X): X is a block
block(X) :-
    is_below(X, _Pile, _BlockOrNull).

प्रोलॉग अब ब्लॉक की गणना कर सकता है:

?- block(X).
X = a ;
X = b ;
X = c ;
X = d ;
X = e ;
X = f.

ध्यान दें कि null शामिल नहीं है, जो अच्छा है क्योंकि यह एक ब्लॉक नहीं है।

अब, is_below चीजों को जटिल बनाता है क्योंकि यह गैर-ब्लॉक (अर्थात्, null) और ढेर की संख्या के बारे में बात करता है, जिसकी हमें हमेशा आवश्यकता नहीं होती है। आइए एक ब्लॉक के सीधे दूसरे ब्लॉक के ऊपर होने की एक सरल धारणा को परिभाषित करें:

% block_on(X, Y): X is a block directly on top of block Y
block_on(X, Y) :-
    is_below(Y, _Pile, X),
    block(X).

ध्यान दें कि हम यह सुनिश्चित करने के लिए block(X) का उपयोग करते हैं कि हम केवल ब्लॉक के बारे में बात करते हैं। आइए परीक्षण करें:

?- block_on(X, Y).
X = b,
Y = a ;
X = d,
Y = c ;
X = e,
Y = d ;
X = f,
Y = e ;
false.

अच्छा। अब, आइए ढेर पर सबसे ऊपर और सबसे नीचे का ब्लॉक होने के लिए धारणाओं को परिभाषित करें:

% top(X): X is a block that is topmost on its pile
top(X) :-
    block(X),
    \+ block_on(_OtherBlock, X).  % no other block is on X

% bottom(X): X is a block that is bottommost on its pile
bottom(X) :-
    block(X),
    \+ block_on(X, _OtherBlock).  % X is not on any other block

यह इस तरह व्यवहार करता है:

?- top(X).
X = b ;
X = f.

?- bottom(X).
X = a ;
X = c ;
false.

और अब हम आपकी टिप्पणी पर लौट सकते हैं:

मैंने सोचा था कि दोनों ब्लॉकों पर गहरी खुदाई करने की तर्ज पर ब्लॉक एक को नल के साथ जोड़ा जाता है, लेकिन मैं इसके चारों ओर अपना सिर नहीं पा सकता।

जब तक आप सबसे ऊपरी ब्लॉक पर नहीं पहुंच जाते, तब तक आप खुदाई (ऊपर की ओर?) करने की बात कर रहे थे, लेकिन वास्तव में आपको नीचे खोदना है जब तक कि आप सबसे नीचे ब्लॉक पर नहीं पहुंच जाते। ! उम्मीद है कि आप देख सकते हैं कि अब इन अवधारणाओं के बारे में बात करना आसान हो गया है क्योंकि हमने उन्हें "null के साथ जोड़ा" जैसे विवरणों के बजाय स्पष्ट नाम दिए हैं।

आइए "से अधिक" व्यक्त करने के लिए एक गैर-पुनरावर्ती नियम से शुरू करें। कोई भी गैर-निचला ब्लॉक निश्चित रूप से किसी भी निचले ब्लॉक से "उच्च" होता है:

% higher_than(X, Y): X is a block higher on any pile than Y
higher_than(X, Y) :-
    bottom(Y),
    block(X),
    \+ bottom(X).

यह पहले से ही बहुत सारे रिश्तों को पकड़ लेता है:

?- higher_than(X, Y).
X = b,
Y = a ;
X = d,
Y = a ;
X = e,
Y = a ;
X = f,
Y = a ;
X = b,
Y = c ;
X = d,
Y = c ;
X = e,
Y = c ;
X = f,
Y = c ;
false.

कोई भी नॉन-बॉटम ब्लॉक (b, d, e, f) किसी भी बॉटम ब्लॉक (a, c) से ऊंचा होता है।

अब इसे व्यक्त करने के लिए "खुदाई" भाग करते हैं, उदाहरण के लिए, f, b से अधिक है। आपका विचार सही है: यदि हम कुछ ब्लॉक X और Y पर हैं, और X सीधे किसी ब्लॉक के शीर्ष पर है V और Y सीधे है कुछ ब्लॉक W के ऊपर, और हम किसी तरह यह स्थापित कर सकते हैं कि V W से अधिक है, तो X, Y से अधिक है! यहाँ वही विचार प्रोलॉग कोड में व्यक्त किया गया है:

higher_than(X, Y) :-
    block_on(X, V),
    block_on(Y, W),
    higher_than(V, W).

तो क्या f, b से अधिक है?

?- higher_than(f, b).
true ;
false.

अच्छा। और सभी "उच्च से अधिक" जोड़े की गणना करना:

?- higher_than(X, Y).
X = b,
Y = a ;
X = d,
Y = a ;
X = e,
Y = a ;
X = f,
Y = a ;
X = b,
Y = c ;
X = d,
Y = c ;
X = e,
Y = c ;
X = f,
Y = c ;
X = e,
Y = b ;
X = e,
Y = d ;
X = f,
Y = b ;
X = f,
Y = d ;
X = f,
Y = e ;
false.

इनमें से अधिकांश पहले की तरह हैं, लेकिन हमें कुछ नए जोड़े भी मिले हैं: e, b से अधिक है और d, f, b से अधिक है, d, और e। इतना ही!

अंतिम टिप्पणी: मैं ब्लॉक वर्ल्ड का विशेषज्ञ नहीं हूं, लेकिन मेरी धारणा यह थी कि "इससे ऊपर कुछ भी नहीं है" के लिए एक विशेष मार्कर होने के बजाय टेबल टॉप को एक विशेष "स्थान" के रूप में मॉडल करना अधिक सामान्य है।

तो मैं इस तरह से उसी दुनिया का प्रतिनिधित्व करता:

pile_on(1, a, table).
pile_on(1, b, a).

pile_on(2, c, table).
pile_on(2, d, c).
pile_on(2, e, d).
pile_on(2, f, e).

आप अपने कोड को इस प्रतिनिधित्व में बदल सकते हैं, शायद यह आपके जीवन को आसान बना देगा। आप समान higher_than परिभाषा भी रख सकते हैं -- यदि आप block और block_on की परिभाषाओं को समायोजित करते हैं, तो बाकी सभी समान रह सकते हैं।

3
Isabelle Newbie 24 जुलाई 2020, 18:55

मान लें कि is_below( A, P, B) का मतलब है कि ब्लॉक A, किसी ढेर P में ब्लॉक B के ठीक नीचे है, या उस ढेर में सबसे ऊपर है, B = null के साथ, हम B = null को कोड कर सकते हैं। is_higher( A, B) जैसा आप चाहते थे वैसा ही विधेय करें:

या तो हमारे पास पाइल्स के नीचे जाने और रिकर्स करने के लिए एक और कदम है, या हम B पाइल के निचले हिस्से तक पहुंच गए हैं और उसके अनुसार स्थिति का आकलन करते हैं:

is_higher(           A,  B) :-  % A is higher than B, if
   is_below(  A2, _, A),        %    A is atop one
   is_below(      B2, _, B),    %    which is _higher_ than that
   A \== B,                     %    which B is atop of
   is_higher( A2, B2).          %      (determined _recursively_)

is_higher( A, B) :-             % or,
   is_below( _, _, A),          %    A is not bottommost
   is_below( B, _, _),          %    while B is, because 
   \+ is_below( _, _, B).       %      there is nothing below B

%% the world:    c
%%               b  e
%%               a  d
is_below(a,1,b).
is_below(b,1,c).
is_below(c,1,null).
is_below(d,2,e).
is_below(e,2,null).

परिक्षण:

36 ?- findall( A-B, (is_higher(A,B), A\==null), X).
X = [c-b, c-e, b-a, b-d, c-a, c-d, e-a, e-d].
2
Will Ness 30 जुलाई 2020, 08:23