"ज़ेबरा का मालिक कौन है" कार्यक्रम को हल करना


128

संपादित करें: इस पहेली को "आइंस्टीन की पहेली" के रूप में भी जाना जाता है

ज़ीरो का मालिक कौन है (आप यहां ऑनलाइन संस्करण की कोशिश कर सकते हैं ) पहेली के एक क्लासिक सेट का एक उदाहरण है और मुझे यकीन है कि स्टैक ओवरफ्लो पर अधिकांश लोग इसे कलम और कागज के साथ हल कर सकते हैं। लेकिन एक प्रोग्रामेटिक समाधान क्या दिखेगा?

नीचे सूचीबद्ध सुरागों के आधार पर ...

  • पाँच घर हैं।
  • प्रत्येक घर का अपना अलग रंग होता है।
  • सभी घर के मालिक अलग-अलग राष्ट्रीयताओं के हैं।
  • वे सभी अलग-अलग पालतू जानवर हैं।
  • वे सभी अलग-अलग ड्रिंक पीते हैं।
  • वे सभी अलग-अलग सिगरेट पीते हैं।
  • अंग्रेज आदमी लाल घर में रहता है।
  • द स्वेड के पास एक कुत्ता है।
  • डेन चाय पीता है।
  • ग्रीन हाउस, व्हाइट हाउस के बाईं ओर है।
  • वे ग्रीन हाउस में कॉफी पीते हैं।
  • पाल मॉल में धूम्रपान करने वाले व्यक्ति के पास पक्षी हैं।
  • पीले घर में वे Dunhill धूम्रपान करते हैं।
  • बीच के घर में वे दूध पीते हैं।
  • नॉर्वेजियन पहले घर में रहता है।
  • ब्लेंड को धूम्रपान करने वाला व्यक्ति बिल्लियों के साथ घर के बगल में घर में रहता है।
  • घर के बगल वाले घर में जहां उनके पास एक घोड़ा है, वे डनहिल धूम्रपान करते हैं।
  • ब्लू मास्टर की धुनाई करने वाला शख्स बीयर पीता है।
  • जर्मन राजकुमार को धूम्रपान करता है।
  • नॉर्वेजियन नीले घर के बगल में रहता है।
  • वे घर के बगल में घर में पानी पीते हैं जहां वे ब्लेंड धूम्रपान करते हैं।

... ज़ेबरा का मालिक कौन है?


37
Zebras को सूचना की सूची (सुराग) में कभी उल्लेख नहीं किया गया था, इसलिए कल्पना निर्दिष्ट है। एक ठेकेदार के रूप में मैं तब समाधान में किसी भी ज़ेबरा के अस्तित्व को अनदेखा करने के लिए स्वतंत्र हूं, इसलिए मेरा जवाब बस यह है कि कोई भी ज़ेबरा का मालिक नहीं है, क्योंकि ज़ेबरा नहीं हैं। : डी
पीटर एम

10
@Peter M: उत्तर 42 था।
निर्दयी

2
@Peter M: हाँ, तथ्य यह है कि एक ज़ेबरा भी एक सुराग है, लेकिन यह इस तरह के रूप में सूचीबद्ध नहीं है।
activout.se

1
सैट सॉल्वर के लिए एक अच्छे उपयोग के मामले जैसा लगता है।
asmeurer

जवाबों:


162

यहाँ बाधा-प्रोग्रामिंग पर आधारित पायथन में एक समाधान है:

from constraint import AllDifferentConstraint, InSetConstraint, Problem

# variables
colors        = "blue red green white yellow".split()
nationalities = "Norwegian German Dane Swede English".split()
pets          = "birds dog cats horse zebra".split()
drinks        = "tea coffee milk beer water".split()
cigarettes    = "Blend, Prince, Blue Master, Dunhill, Pall Mall".split(", ")

# There are five houses.
minn, maxn = 1, 5
problem = Problem()
# value of a variable is the number of a house with corresponding property
variables = colors + nationalities + pets + drinks + cigarettes
problem.addVariables(variables, range(minn, maxn+1))

# Each house has its own unique color.
# All house owners are of different nationalities.
# They all have different pets.
# They all drink different drinks.
# They all smoke different cigarettes.
for vars_ in (colors, nationalities, pets, drinks, cigarettes):
    problem.addConstraint(AllDifferentConstraint(), vars_)

# In the middle house they drink milk.
#NOTE: interpret "middle" in a numerical sense (not geometrical)
problem.addConstraint(InSetConstraint([(minn + maxn) // 2]), ["milk"])
# The Norwegian lives in the first house.
#NOTE: interpret "the first" as a house number
problem.addConstraint(InSetConstraint([minn]), ["Norwegian"])
# The green house is on the left side of the white house.
#XXX: what is "the left side"? (linear, circular, two sides, 2D house arrangment)
#NOTE: interpret it as 'green house number' + 1 == 'white house number'
problem.addConstraint(lambda a,b: a+1 == b, ["green", "white"])

def add_constraints(constraint, statements, variables=variables, problem=problem):
    for stmt in (line for line in statements if line.strip()):
        problem.addConstraint(constraint, [v for v in variables if v in stmt])

and_statements = """
They drink coffee in the green house.
The man who smokes Pall Mall has birds.
The English man lives in the red house.
The Dane drinks tea.
In the yellow house they smoke Dunhill.
The man who smokes Blue Master drinks beer.
The German smokes Prince.
The Swede has a dog.
""".split("\n")
add_constraints(lambda a,b: a == b, and_statements)

nextto_statements = """
The man who smokes Blend lives in the house next to the house with cats.
In the house next to the house where they have a horse, they smoke Dunhill.
The Norwegian lives next to the blue house.
They drink water in the house next to the house where they smoke Blend.
""".split("\n")
#XXX: what is "next to"? (linear, circular, two sides, 2D house arrangment)
add_constraints(lambda a,b: abs(a - b) == 1, nextto_statements)

def solve(variables=variables, problem=problem):
    from itertools  import groupby
    from operator   import itemgetter

    # find & print solutions
    for solution in problem.getSolutionIter():
        for key, group in groupby(sorted(solution.iteritems(), key=itemgetter(1)), key=itemgetter(1)):
            print key, 
            for v in sorted(dict(group).keys(), key=variables.index):
                print v.ljust(9),
            print

if __name__ == '__main__':
    solve()

आउटपुट:

1 yellow    Norwegian cats      water     Dunhill  
2 blue      Dane      horse     tea       Blend    
3 red       English   birds     milk      Pall Mall
4 green     German    zebra     coffee    Prince   
5 white     Swede     dog       beer      Blue Master

इसका समाधान खोजने में 0.6 सेकंड (CPU 1.5GHz) लगता है।
जवाब "जर्मन ज़ेबरा का मालिक है।"


के माध्यम से constraintमॉड्यूल स्थापित करने के लिए pip: पाइप स्थापित अजगर-बाधा

मैन्युअल रूप से स्थापित करने के लिए:


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

4
@LFSR परामर्श: '//' हमेशा पूर्णांक विभाजन होता है: '3 // 2 == 1'। '/' फ्लोट डिवीजन हो सकता है '3/2 == 1.5' (पायथन 3.0 में या ' भविष्य के आयात डिवीजन से' की उपस्थिति में ) या पूर्णांक विभाजन हो सकता है (जैसे C) '3/2 == 1' पर ' भविष्य के आयात विभाग से' के बिना पुराना पायथन संस्करण ।
शाम

4
यह पहला बाधा कार्यक्रम है जिसे मैंने देखा। जैसा कि कई ने बताया कि आपका पायथन कार्यान्वयन प्रभावशाली है। यह वास्तव में बहुत प्यारा है कि आपने add_constraints (), और_statements, और nextto_statements के उपयोग के साथ बाधाओं को कोडित करने से कैसे बचें।
rpattabi

1
क्या कोई कारण नहीं है pip install python-constraint? मैंने अभी कुछ समय पहले ऐसा किया था और यह अपेक्षित आउटपुट देता प्रतीत होता है।
बेन बर्न्स

1
@BenBurns: कोई कारण नहीं। उत्तर 2008 में लिखा गया था। यदि आपने इसका परीक्षण किया है और यह उसी परिणाम का उत्पादन करता है तो आप इंस्टॉलेशन निर्देशों और संबंधित लिंक को डॉक्स में अपडेट कर सकते हैं (यह उत्तर के आवश्यक पहलुओं को नहीं बदलता है - आप स्वतंत्र हैं इसे संपादित करने के लिए)।
jfs

46

प्रोलॉग में, हम केवल इसमें से तत्वों का चयन करके डोमेन को तत्काल कर सकते हैं :) ( दक्षता के लिए परस्पर-अनन्य विकल्प बनाते हुए )। SWI- प्रोलॉग का उपयोग करना,

select([A|As],S):- select(A,S,S1),select(As,S1).
select([],_). 

left_of(A,B,C):- append(_,[A,B|_],C).  
next_to(A,B,C):- left_of(A,B,C) ; left_of(B,A,C).

zebra(Owns, HS):-     % house: color,nation,pet,drink,smokes
  HS   = [ h(_,norwegian,_,_,_),    h(blue,_,_,_,_),   h(_,_,_,milk,_), _, _], 
  select([ h(red,brit,_,_,_),       h(_,swede,dog,_,_), 
           h(_,dane,_,tea,_),       h(_,german,_,_,prince)], HS),
  select([ h(_,_,birds,_,pallmall), h(yellow,_,_,_,dunhill),
           h(_,_,_,beer,bluemaster)],                        HS), 
  left_of( h(green,_,_,coffee,_),   h(white,_,_,_,_),        HS),
  next_to( h(_,_,_,_,dunhill),      h(_,_,horse,_,_),        HS),
  next_to( h(_,_,_,_,blend),        h(_,_,cats, _,_),        HS),
  next_to( h(_,_,_,_,blend),        h(_,_,_,water,_),        HS),
  member(  h(_,Owns,zebra,_,_),                              HS).

काफी तुरन्त चलता है:

?- time( (zebra(Who,HS), writeln(Who), nl, maplist(writeln,HS), nl, false 
          ; writeln('no more solutions!') )).
german

h( yellow, norwegian, cats,   water,  dunhill   )
h( blue,   dane,      horse,  tea,    blend     )
h( red,    brit,      birds,  milk,   pallmall  )
h( green,  german,    zebra,  coffee, prince    )     % formatted by hand
h( white,  swede,     dog,    beer,   bluemaster)

no more solutions!
% 1,706 inferences, 0.000 CPU in 0.070 seconds (0% CPU, Infinite Lips)
true.

16

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

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


"सामान्य ज्ञान" नियमों के बारे में अच्छी बात है। मुझे याद है कि इस साल के साथ बहुत बंधे हुए थे जब वाक्यांश " घर के बगल में घर " की व्याख्या कर रहा था - क्या इसका मतलब केवल एक ही है? यह स्पष्ट नहीं है।
क्रिस

किसी भी प्रकार की क्रांतिकारी पद्धति के बिना दशकों से ड्यूड साइकिल देव में है। साहसी दुखी, साहसी मॉडल पर जीत हासिल करने के लिए जानवर बल दृष्टिकोण को देखने के लिए साफ-सुथरा होगा।
जोश

हमने अपने AI पाठ्यक्रम में इस तरह की जानकारी को कम करने के लिए यूनी पर CLIPS का उपयोग किया।
जोश स्मेटन

15

SWI- प्रस्तावना संगत:

% NOTE - This may or may not be more efficent. A bit verbose, though.
left_side(L, R, [L, R, _, _, _]).
left_side(L, R, [_, L, R, _, _]).
left_side(L, R, [_, _, L, R, _]).
left_side(L, R, [_, _, _, L, R]).

next_to(X, Y, Street) :- left_side(X, Y, Street).
next_to(X, Y, Street) :- left_side(Y, X, Street).

m(X, Y) :- member(X, Y).

get_zebra(Street, Who) :- 
    Street = [[C1, N1, P1, D1, S1],
              [C2, N2, P2, D2, S2],
              [C3, N3, P3, D3, S3],
              [C4, N4, P4, D4, S4],
              [C5, N5, P5, D5, S5]],
    m([red, english, _, _, _], Street),
    m([_, swede, dog, _, _], Street),
    m([_, dane, _, tea, _], Street),
    left_side([green, _, _, _, _], [white, _, _, _, _], Street),
    m([green, _, _, coffee, _], Street),
    m([_, _, birds, _, pallmall], Street),
    m([yellow, _, _, _, dunhill], Street),
    D3 = milk,
    N1 = norwegian,
    next_to([_, _, _, _, blend], [_, _, cats, _, _], Street),
    next_to([_, _, horse, _, _], [_, _, _, _, dunhill], Street),
    m([_, _, _, beer, bluemaster], Street),
    m([_, german, _, _, prince], Street),
    next_to([_, norwegian, _, _, _], [blue, _, _, _, _], Street),
    next_to([_, _, _, water, _], [_, _, _, _, blend], Street),
    m([_, Who, zebra, _, _], Street).

दुभाषिया में:

?- get_zebra(Street, Who).
Street = ...
Who = german

13

यहाँ है कि मैं इसके बारे में कैसे जाना था। पहले मैं सभी ऑर्डर किए गए n-tuples जेनरेट करूंगा

(housenumber, color, nationality, pet, drink, smoke)

5 ^ 6 उन में से, 15625, आसानी से प्रबंधनीय। फिर मैं साधारण बूलियन स्थितियों को फ़िल्टर करूंगा। उनमें से दस हैं, और उनमें से प्रत्येक आप 8/25 शर्तों को फ़िल्टर करने की उम्मीद करेंगे (1/25 शर्तों में एक कुत्ते के साथ एक स्वेड शामिल है, 16/25 में एक गैर-कुत्ते के साथ एक गैर-स्वेड शामिल है) । बेशक वे स्वतंत्र नहीं हैं, लेकिन उन लोगों को छानने के बाद बहुत सारे नहीं होने चाहिए।

उसके बाद, आपको एक अच्छी ग्राफ़ समस्या मिली है। शेष n-tuples में से एक का प्रतिनिधित्व करने वाले प्रत्येक नोड के साथ एक ग्राफ़ बनाएं। अगर दोनों छोरों में कुछ n- टपल स्थिति में डुप्लिकेट हैं या किसी भी 'स्थिति' बाधाओं (वहाँ उन पांच) का उल्लंघन करते हुए ग्राफ़ में किनारों को जोड़ें। वहाँ से आप लगभग घर पर हैं, पाँच नोड्स के स्वतंत्र सेट के लिए ग्राफ खोजें (किनारों से जुड़े नोड्स में से कोई भी नहीं)। यदि बहुत अधिक नहीं हैं, तो आप संभवतः केवल सभी 5-tuples के n-tuples उत्पन्न कर सकते हैं और उन्हें फिर से फ़िल्टर कर सकते हैं।

यह कोड गोल्फ के लिए एक अच्छा उम्मीदवार हो सकता है। कोई शायद इसे एक लाइन में हल कर सकता है जैसे हस्केल :)

बाद में: प्रारंभिक फ़िल्टर पास भी स्थिति संबंधी बाधाओं से जानकारी को समाप्त कर सकता है। ज्यादा नहीं (1/25), लेकिन फिर भी महत्वपूर्ण।


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

पॉइंट लिया :) मेरा हैस्केल क्रिया है लेकिन मेरा स्कोर वैसे भी पार्क से बाहर था :)
क्रिस

1
मुझे लगता है कि संभावित समाधानों का आपका 5 ^ 6 मूल्यांकन बंद है। मेरा मानना ​​है कि 'मी' श्रेणियों के भीतर 'i' वस्तुओं के संभावित संयोजनों की संख्या (i!) ^ (M-1) होनी चाहिए। उदाहरण के लिए, रंग के लिए पांच विकल्प 5 व्यवस्थित किए जा सकते हैं! तरीके। हाउस नंबर की श्रेणी प्रदान करना उसी क्रम में रहता है, अन्य 5 श्रेणियां प्रत्येक को उसी तरह से व्यवस्थित किया जा सकता है, जिसका अर्थ है कि संभावित संयोजन (5!) ^ 5 या 24,883,200,000; 15,625 की तुलना में थोड़ा अधिक है, और इससे निपटने के लिए एक क्रूर बल पर हमला करना कठिन है।
मध्यरात्रि

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

9

एक और पायथन समाधान, इस बार अजगर के PyKE (पायथन नॉलेज इंजन) का उपयोग करके। दी, यह @JFSebastian द्वारा समाधान में पायथन के "बाधा" मॉड्यूल का उपयोग करने की तुलना में अधिक क्रिया है, लेकिन यह इस प्रकार की समस्या के लिए कच्चे ज्ञान इंजन में देखने वाले किसी भी व्यक्ति के लिए एक दिलचस्प तुलना प्रदान करता है।

clues.kfb

categories( POSITION, 1, 2, 3, 4, 5 )                                   # There are five houses.
categories( HOUSE_COLOR, blue, red, green, white, yellow )              # Each house has its own unique color.
categories( NATIONALITY, Norwegian, German, Dane, Swede, English )      # All house owners are of different nationalities.
categories( PET, birds, dog, cats, horse, zebra )                       # They all have different pets.
categories( DRINK, tea, coffee, milk, beer, water )                     # They all drink different drinks.
categories( SMOKE, Blend, Prince, 'Blue Master', Dunhill, 'Pall Mall' ) # They all smoke different cigarettes.

related( NATIONALITY, English, HOUSE_COLOR, red )    # The English man lives in the red house.
related( NATIONALITY, Swede, PET, dog )              # The Swede has a dog.
related( NATIONALITY, Dane, DRINK, tea )             # The Dane drinks tea.
left_of( HOUSE_COLOR, green, HOUSE_COLOR, white )    # The green house is on the left side of the white house.
related( DRINK, coffee, HOUSE_COLOR, green )         # They drink coffee in the green house.
related( SMOKE, 'Pall Mall', PET, birds )            # The man who smokes Pall Mall has birds.
related( SMOKE, Dunhill, HOUSE_COLOR, yellow )       # In the yellow house they smoke Dunhill.
related( POSITION, 3, DRINK, milk )                  # In the middle house they drink milk.
related( NATIONALITY, Norwegian, POSITION, 1 )       # The Norwegian lives in the first house.
next_to( SMOKE, Blend, PET, cats )                   # The man who smokes Blend lives in the house next to the house with cats.
next_to( SMOKE, Dunhill, PET, horse )                # In the house next to the house where they have a horse, they smoke Dunhill.
related( SMOKE, 'Blue Master', DRINK, beer )         # The man who smokes Blue Master drinks beer.
related( NATIONALITY, German, SMOKE, Prince )        # The German smokes Prince.
next_to( NATIONALITY, Norwegian, HOUSE_COLOR, blue ) # The Norwegian lives next to the blue house.
next_to( DRINK, water, SMOKE, Blend )                # They drink water in the house next to the house where they smoke Blend.

relations.krb

#############
# Categories

# Foreach set of categories, assert each type
categories
    foreach
        clues.categories($category, $thing1, $thing2, $thing3, $thing4, $thing5)
    assert
        clues.is_category($category, $thing1)
        clues.is_category($category, $thing2)
        clues.is_category($category, $thing3)
        clues.is_category($category, $thing4)
        clues.is_category($category, $thing5)


#########################
# Inverse Relationships

# Foreach A=1, assert 1=A
inverse_relationship_positive
    foreach
        clues.related($category1, $thing1, $category2, $thing2)
    assert
        clues.related($category2, $thing2, $category1, $thing1)

# Foreach A!1, assert 1!A
inverse_relationship_negative
    foreach
        clues.not_related($category1, $thing1, $category2, $thing2)
    assert
        clues.not_related($category2, $thing2, $category1, $thing1)

# Foreach "A beside B", assert "B beside A"
inverse_relationship_beside
    foreach
        clues.next_to($category1, $thing1, $category2, $thing2)
    assert
        clues.next_to($category2, $thing2, $category1, $thing1)


###########################
# Transitive Relationships

# Foreach A=1 and 1=a, assert A=a
transitive_positive
    foreach
        clues.related($category1, $thing1, $category2, $thing2)
        clues.related($category2, $thing2, $category3, $thing3)

        check unique($thing1, $thing2, $thing3) \
          and unique($category1, $category2, $category3)
    assert
        clues.related($category1, $thing1, $category3, $thing3)

# Foreach A=1 and 1!a, assert A!a
transitive_negative
    foreach
        clues.related($category1, $thing1, $category2, $thing2)
        clues.not_related($category2, $thing2, $category3, $thing3)

        check unique($thing1, $thing2, $thing3) \
          and unique($category1, $category2, $category3)
    assert
        clues.not_related($category1, $thing1, $category3, $thing3)


##########################
# Exclusive Relationships

# Foreach A=1, assert A!2 and A!3 and A!4 and A!5
if_one_related_then_others_unrelated
    foreach
        clues.related($category, $thing, $category_other, $thing_other)
        check unique($category, $category_other)

        clues.is_category($category_other, $thing_not_other)
        check unique($thing, $thing_other, $thing_not_other)
    assert
        clues.not_related($category, $thing, $category_other, $thing_not_other)

# Foreach A!1 and A!2 and A!3 and A!4, assert A=5
if_four_unrelated_then_other_is_related
    foreach
        clues.not_related($category, $thing, $category_other, $thingA)
        clues.not_related($category, $thing, $category_other, $thingB)
        check unique($thingA, $thingB)

        clues.not_related($category, $thing, $category_other, $thingC)
        check unique($thingA, $thingB, $thingC)

        clues.not_related($category, $thing, $category_other, $thingD)
        check unique($thingA, $thingB, $thingC, $thingD)

        # Find the fifth variation of category_other.
        clues.is_category($category_other, $thingE)
        check unique($thingA, $thingB, $thingC, $thingD, $thingE)
    assert
        clues.related($category, $thing, $category_other, $thingE)


###################
# Neighbors: Basic

# Foreach "A left of 1", assert "A beside 1"
expanded_relationship_beside_left
    foreach
        clues.left_of($category1, $thing1, $category2, $thing2)
    assert
        clues.next_to($category1, $thing1, $category2, $thing2)

# Foreach "A beside 1", assert A!1
unrelated_to_beside
    foreach
        clues.next_to($category1, $thing1, $category2, $thing2)
        check unique($category1, $category2)
    assert
        clues.not_related($category1, $thing1, $category2, $thing2)


###################################
# Neighbors: Spatial Relationships

# Foreach "A beside B" and "A=(at-edge)", assert "B=(near-edge)"
check_next_to_either_edge
    foreach
        clues.related(POSITION, $position_known, $category, $thing)
        check is_edge($position_known)

        clues.next_to($category, $thing, $category_other, $thing_other)

        clues.is_category(POSITION, $position_other)
        check is_beside($position_known, $position_other)
    assert
        clues.related(POSITION, $position_other, $category_other, $thing_other)

# Foreach "A beside B" and "A!(near-edge)" and "B!(near-edge)", assert "A!(at-edge)"
check_too_close_to_edge
    foreach
        clues.next_to($category, $thing, $category_other, $thing_other)

        clues.is_category(POSITION, $position_edge)
        clues.is_category(POSITION, $position_near_edge)
        check is_edge($position_edge) and is_beside($position_edge, $position_near_edge)

        clues.not_related(POSITION, $position_near_edge, $category, $thing)
        clues.not_related(POSITION, $position_near_edge, $category_other, $thing_other)
    assert
        clues.not_related(POSITION, $position_edge, $category, $thing)

# Foreach "A beside B" and "A!(one-side)", assert "A=(other-side)"
check_next_to_with_other_side_impossible
    foreach
        clues.next_to($category, $thing, $category_other, $thing_other)

        clues.related(POSITION, $position_known, $category_other, $thing_other)
        check not is_edge($position_known)

        clues.not_related($category, $thing, POSITION, $position_one_side)
        check is_beside($position_known, $position_one_side)

        clues.is_category(POSITION, $position_other_side)
        check is_beside($position_known, $position_other_side) \
          and unique($position_known, $position_one_side, $position_other_side)
    assert
        clues.related($category, $thing, POSITION, $position_other_side)

# Foreach "A left of B"...
#   ... and "C=(position1)" and "D=(position2)" and "E=(position3)"
# ~> assert "A=(other-position)" and "B=(other-position)+1"
left_of_and_only_two_slots_remaining
    foreach
        clues.left_of($category_left, $thing_left, $category_right, $thing_right)

        clues.related($category_left, $thing_left_other1, POSITION, $position1)
        clues.related($category_left, $thing_left_other2, POSITION, $position2)
        clues.related($category_left, $thing_left_other3, POSITION, $position3)
        check unique($thing_left, $thing_left_other1, $thing_left_other2, $thing_left_other3)

        clues.related($category_right, $thing_right_other1, POSITION, $position1)
        clues.related($category_right, $thing_right_other2, POSITION, $position2)
        clues.related($category_right, $thing_right_other3, POSITION, $position3)
        check unique($thing_right, $thing_right_other1, $thing_right_other2, $thing_right_other3)

        clues.is_category(POSITION, $position4)
        clues.is_category(POSITION, $position5)

        check is_left_right($position4, $position5) \
          and unique($position1, $position2, $position3, $position4, $position5)
    assert
        clues.related(POSITION, $position4, $category_left, $thing_left)
        clues.related(POSITION, $position5, $category_right, $thing_right)


#########################

fc_extras

    def unique(*args):
        return len(args) == len(set(args))

    def is_edge(pos):
        return (pos == 1) or (pos == 5)

    def is_beside(pos1, pos2):
        diff = (pos1 - pos2)
        return (diff == 1) or (diff == -1)

    def is_left_right(pos_left, pos_right):
        return (pos_right - pos_left == 1)

Driver.py (वास्तव में बड़ा है, लेकिन यह सार है)

from pyke import knowledge_engine

engine = knowledge_engine.engine(__file__)
engine.activate('relations')

try:
    natl = engine.prove_1_goal('clues.related(PET, zebra, NATIONALITY, $nationality)')[0].get('nationality')
except Exception, e:
    natl = "Unknown"
print "== Who owns the zebra? %s ==" % natl

नमूना उत्पादन:

$ python driver.py

== Who owns the zebra? German ==

#   Color    Nationality    Pet    Drink       Smoke    
=======================================================
1   yellow   Norwegian     cats    water    Dunhill     
2   blue     Dane          horse   tea      Blend       
3   red      English       birds   milk     Pall Mall   
4   green    German        zebra   coffee   Prince      
5   white    Swede         dog     beer     Blue Master 

Calculated in 1.19 seconds.

स्रोत: https://github.com/DreadPirateShawn/pyke-who-owns-zebra


8

यहाँ NSOLver के उपयोग से पूर्ण समाधान का एक अंश है , C # में आइंस्टीन की पहेली पर पोस्ट किया गया है :

// The green house's owner drinks coffee
Post(greenHouse.Eq(coffee));
// The person who smokes Pall Mall rears birds 
Post(pallMall.Eq(birds));
// The owner of the yellow house smokes Dunhill 
Post(yellowHouse.Eq(dunhill));

5
यहां TinyURL का उपयोग करने की कोई आवश्यकता नहीं है, क्या वहां है? वे सभी मेरे लिए रिक्रॉल की तरह दिखते हैं।
कार्ल

1
मैंने समय सीमा समाप्त हो गई है।
JFS

बचाव के लिए @LamonteCristo Wayback मशीन
लगभग

8

यहाँ सीएलपी (एफडी) में एक सीधा समाधान है (यह भी देखें) ):

:- use_module(library(clpfd)).

solve(ZebraOwner) :-
    maplist( init_dom(1..5), 
        [[British,  Swedish,  Danish,  Norwegian, German],     % Nationalities
         [Red,      Green,    Blue,    White,     Yellow],     % Houses
         [Tea,      Coffee,   Milk,    Beer,      Water],      % Beverages
         [PallMall, Blend,    Prince,  Dunhill,   BlueMaster], % Cigarettes
         [Dog,      Birds,    Cats,    Horse,     Zebra]]),    % Pets
    British #= Red,        % Hint 1
    Swedish #= Dog,        % Hint 2
    Danish #= Tea,         % Hint 3
    Green #= White - 1 ,   % Hint 4
    Green #= Coffee,       % Hint 5
    PallMall #= Birds,     % Hint 6
    Yellow #= Dunhill,     % Hint 7
    Milk #= 3,             % Hint 8
    Norwegian #= 1,        % Hint 9
    neighbor(Blend, Cats),     % Hint 10
    neighbor(Horse, Dunhill),  % Hint 11
    BlueMaster #= Beer,        % Hint 12
    German #= Prince,          % Hint 13
    neighbor(Norwegian, Blue), % Hint 14
    neighbor(Blend, Water),    % Hint 15
    memberchk(Zebra-ZebraOwner, [British-british, Swedish-swedish, Danish-danish,
                                 Norwegian-norwegian, German-german]).

init_dom(R, L) :-
    all_distinct(L),
    L ins R.

neighbor(X, Y) :-
    (X #= (Y - 1)) #\/ (X #= (Y + 1)).

यह चल रहा है, उत्पादन:

3? - समय (हल (जेड))।
% 111,798 इनविटेशन, 0.016 सीपीयू इन सेकेंड्स (78% सीपीयू, 7166493 लिप्स)
Z = जर्मन।


neighbor(X,Y) :- abs(X-Y) #= 1.
झूठी


7

ईएस 6 (जावास्क्रिप्ट) समाधान

ईएस 6 जनरेटर के बहुत सारे और लताड़ का एक छोटा सा के साथ । इसे चलाने के लिए आपको बैबिल की आवश्यकता होगी ।

var _ = require('lodash');

function canBe(house, criteria) {
    for (const key of Object.keys(criteria))
        if (house[key] && house[key] !== criteria[key])
            return false;
    return true;
}

function* thereShouldBe(criteria, street) {
    for (const i of _.range(street.length))
        yield* thereShouldBeAtIndex(criteria, i, street);
}

function* thereShouldBeAtIndex(criteria, index, street) {
    if (canBe(street[index], criteria)) {
        const newStreet = _.cloneDeep(street);
        newStreet[index] = _.assign({}, street[index], criteria);
        yield newStreet;
    }
}

function* leftOf(critA, critB, street) {
    for (const i of _.range(street.length - 1)) {
        if (canBe(street[i], critA) && canBe(street[i+1], critB)) {
            const newStreet = _.cloneDeep(street);
            newStreet[i  ] = _.assign({}, street[i  ], critA);
            newStreet[i+1] = _.assign({}, street[i+1], critB);
            yield newStreet;
        }
    }
}
function* nextTo(critA, critB, street) {
    yield* leftOf(critA, critB, street);
    yield* leftOf(critB, critA, street);
}

const street = [{}, {}, {}, {}, {}]; // five houses

// Btw: it turns out we don't need uniqueness constraint.

const constraints = [
    s => thereShouldBe({nation: 'English', color: 'red'}, s),
    s => thereShouldBe({nation: 'Swede', animal: 'dog'}, s),
    s => thereShouldBe({nation: 'Dane', drink: 'tea'}, s),
    s => leftOf({color: 'green'}, {color: 'white'}, s),
    s => thereShouldBe({drink: 'coffee', color: 'green'}, s),
    s => thereShouldBe({cigarettes: 'PallMall', animal: 'birds'}, s),
    s => thereShouldBe({color: 'yellow', cigarettes: 'Dunhill'}, s),
    s => thereShouldBeAtIndex({drink: 'milk'}, 2, s),
    s => thereShouldBeAtIndex({nation: 'Norwegian'}, 0, s),
    s => nextTo({cigarettes: 'Blend'}, {animal: 'cats'}, s),
    s => nextTo({animal: 'horse'}, {cigarettes: 'Dunhill'}, s),
    s => thereShouldBe({cigarettes: 'BlueMaster', drink: 'beer'}, s),
    s => thereShouldBe({nation: 'German', cigarettes: 'Prince'}, s),
    s => nextTo({nation: 'Norwegian'}, {color: 'blue'}, s),
    s => nextTo({drink: 'water'}, {cigarettes: 'Blend'}, s),

    s => thereShouldBe({animal: 'zebra'}, s), // should be somewhere
];

function* findSolution(remainingConstraints, street) {
    if (remainingConstraints.length === 0)
        yield street;
    else
        for (const newStreet of _.head(remainingConstraints)(street))
            yield* findSolution(_.tail(remainingConstraints), newStreet);
}

for (const streetSolution of findSolution(constraints, street)) {
    console.log(streetSolution);
}

परिणाम:

[ { color: 'yellow',
    cigarettes: 'Dunhill',
    nation: 'Norwegian',
    animal: 'cats',
    drink: 'water' },
  { nation: 'Dane',
    drink: 'tea',
    cigarettes: 'Blend',
    animal: 'horse',
    color: 'blue' },
  { nation: 'English',
    color: 'red',
    cigarettes: 'PallMall',
    animal: 'birds',
    drink: 'milk' },
  { color: 'green',
    drink: 'coffee',
    nation: 'German',
    cigarettes: 'Prince',
    animal: 'zebra' },
  { nation: 'Swede',
    animal: 'dog',
    color: 'white',
    cigarettes: 'BlueMaster',
    drink: 'beer' } ]

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

धन्यवाद, यह एक अच्छी चुनौती थी!


4

यह वास्तव में एक समस्या को हल करने में बाधा है। आप इसे भाषा की तरह लॉजिक-प्रोग्रामिंग में एक सामान्यीकृत प्रकार के बाधा प्रसार के साथ कर सकते हैं। हमारे पास विशेष रूप से एईएल में ज़ेबरा समस्या (विशेषता तर्क इंजन) प्रणाली के लिए एक डेमो है:

http://www.cs.toronto.edu/~gpenn/ale.html

यहाँ एक सरल ज़ेबरा पहेली के कोडिंग का लिंक दिया गया है:

http://www.cs.toronto.edu/~gpenn/ale/files/grammars/baby.pl

यह कुशलता से करने के लिए एक और मामला है।


3

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

यहाँ एक सरल एफ # समाधान एफ # जर्नल में एक लेख से लिया गया है :

let rec distribute y xs =
  match xs with
  | [] -> [[y]]
  | x::xs -> (y::x::xs)::[for xs in distribute y xs -> x::xs]

let rec permute xs =
  match xs with
  | [] | [_] as xs -> [xs]
  | x::xs -> List.collect (distribute x) (permute xs)

let find xs x = List.findIndex ((=) x) xs + 1

let eq xs x ys y = find xs x = find ys y

let nextTo xs x ys y = abs(find xs x - find ys y) = 1

let nations = ["British"; "Swedish"; "Danish"; "Norwegian"; "German"]

let houses = ["Red"; "Green"; "Blue"; "White"; "Yellow"]

let drinks = ["Milk"; "Coffee"; "Water"; "Beer"; "Tea"]

let smokes = ["Blend"; "Prince"; "Blue Master"; "Dunhill"; "Pall Mall"]

let pets = ["Dog"; "Cat"; "Zebra"; "Horse"; "Bird"]

[ for nations in permute nations do
    if find nations "Norwegian" = 1 then
      for houses in permute houses do
        if eq nations "British" houses "Red" &&
           find houses "Green" = find houses "White"-1 &&
           nextTo nations "Norwegian" houses "Blue" then
          for drinks in permute drinks do
            if eq nations "Danish" drinks "Tea" &&
               eq houses "Green" drinks "Coffee" &&
               3 = find drinks "Milk" then
              for smokes in permute smokes do
                if eq houses "Yellow" smokes "Dunhill" &&
                   eq smokes "Blue Master" drinks "Beer" &&
                   eq nations "German" smokes "Prince" &&
                   nextTo smokes "Blend" drinks "Water" then
                  for pets in permute pets do
                    if eq nations "Swedish" pets "Dog" &&
                       eq smokes "Pall Mall" pets "Bird" &&
                       nextTo pets "Cat" smokes "Blend" &&
                       nextTo pets "Horse" smokes "Dunhill" then
                      yield nations, houses, drinks, smokes, pets ]

9ms में प्राप्त आउटपुट है:

val it :
  (string list * string list * string list * string list * string list) list =
  [(["Norwegian"; "Danish"; "British"; "German"; "Swedish"],
    ["Yellow"; "Blue"; "Red"; "Green"; "White"],
    ["Water"; "Tea"; "Milk"; "Coffee"; "Beer"],
    ["Dunhill"; "Blend"; "Pall Mall"; "Prince"; "Blue Master"],
    ["Cat"; "Horse"; "Bird"; "Zebra"; "Dog"])]

यह मुझे पंसद है। मुझे उम्मीद नहीं थी कि यह सीधा हमला संभव होगा।
चमत्कार 173

1

Microsoft सॉल्वर फ़ाउंडेशन उदाहरण से: https://msdn.microsoft.com/en-us/library/ff525831%28v=vs.93%29.aspx?f=255&MSPPError=-2147280396

delegate CspTerm NamedTerm(string name);

public static void Zebra() {
  ConstraintSystem S = ConstraintSystem.CreateSolver();
  var termList = new List<KeyValuePair<CspTerm, string>>();

  NamedTerm House = delegate(string name) {
    CspTerm x = S.CreateVariable(S.CreateIntegerInterval(1, 5), name);
    termList.Add(new KeyValuePair<CspTerm, string>(x, name));
    return x;
  };

  CspTerm English = House("English"), Spanish = House("Spanish"),
    Japanese = House("Japanese"), Italian = House("Italian"),
    Norwegian = House("Norwegian");
  CspTerm red = House("red"), green = House("green"),
    white = House("white"),
    blue = House("blue"), yellow = House("yellow");
  CspTerm dog = House("dog"), snails = House("snails"),
    fox = House("fox"),
    horse = House("horse"), zebra = House("zebra");
  CspTerm painter = House("painter"), sculptor = House("sculptor"),
    diplomat = House("diplomat"), violinist = House("violinist"),
    doctor = House("doctor");
  CspTerm tea = House("tea"), coffee = House("coffee"),
    milk = House("milk"),
    juice = House("juice"), water = House("water");

  S.AddConstraints(
    S.Unequal(English, Spanish, Japanese, Italian, Norwegian),
    S.Unequal(red, green, white, blue, yellow),
    S.Unequal(dog, snails, fox, horse, zebra),
    S.Unequal(painter, sculptor, diplomat, violinist, doctor),
    S.Unequal(tea, coffee, milk, juice, water),
    S.Equal(English, red),
    S.Equal(Spanish, dog),
    S.Equal(Japanese, painter),
    S.Equal(Italian, tea),
    S.Equal(1, Norwegian),
    S.Equal(green, coffee),
    S.Equal(1, green - white),
    S.Equal(sculptor, snails),
    S.Equal(diplomat, yellow),
    S.Equal(3, milk),
    S.Equal(1, S.Abs(Norwegian - blue)),
    S.Equal(violinist, juice),
    S.Equal(1, S.Abs(fox - doctor)),
    S.Equal(1, S.Abs(horse - diplomat))
  );
  bool unsolved = true;
  ConstraintSolverSolution soln = S.Solve();

  while (soln.HasFoundSolution) {
    unsolved = false;
    System.Console.WriteLine("solved.");
    StringBuilder[] houses = new StringBuilder[5];
    for (int i = 0; i < 5; i++)
      houses[i] = new StringBuilder(i.ToString());
    foreach (KeyValuePair<CspTerm, string> kvp in termList) {
      string item = kvp.Value;
      object house;
      if (!soln.TryGetValue(kvp.Key, out house))
        throw new InvalidProgramException(
                    "can't find a Term in the solution: " + item);
      houses[(int)house - 1].Append(", ");
      houses[(int)house - 1].Append(item);
    }
    foreach (StringBuilder house in houses) {
      System.Console.WriteLine(house);
    }
    soln.GetNext();
  }
  if (unsolved)
    System.Console.WriteLine("No solution found.");
  else
    System.Console.WriteLine(
"Expected: the Norwegian drinking water and the Japanese with the zebra.");
}

1

यह ज़ेबरा पहेली का एक छोटा सा समाधान है जैसा कि विकिपीडिया में परिभाषित किया गया है:

include "globals.mzn";

% Zebra puzzle
int: nc = 5;

% Colors
int: red = 1;
int: green = 2;
int: ivory = 3;
int: yellow = 4;
int: blue = 5;
array[1..nc] of var 1..nc:color;
constraint alldifferent([color[i] | i in 1..nc]);

% Nationalities
int: eng = 1;
int: spa = 2;
int: ukr = 3;
int: nor = 4;
int: jap = 5;
array[1..nc] of var 1..nc:nationality;
constraint alldifferent([nationality[i] | i in 1..nc]);

% Pets
int: dog = 1;
int: snail = 2;
int: fox = 3;
int: horse = 4;
int: zebra = 5;
array[1..nc] of var 1..nc:pet;
constraint alldifferent([pet[i] | i in 1..nc]);

% Drinks
int: coffee = 1;
int: tea = 2;
int: milk = 3;
int: orange = 4;
int: water = 5;
array[1..nc] of var 1..nc:drink;
constraint alldifferent([drink[i] | i in 1..nc]);

% Smokes
int: oldgold = 1;
int: kools = 2;
int: chesterfields = 3;
int: luckystrike = 4;
int: parliaments = 5;
array[1..nc] of var 1..nc:smoke;
constraint alldifferent([smoke[i] | i in 1..nc]);

% The Englishman lives in the red house.
constraint forall ([nationality[i] == eng <-> color[i] == red | i in 1..nc]);

% The Spaniard owns the dog.
constraint forall ([nationality[i] == spa <-> pet[i] == dog | i in 1..nc]);

% Coffee is drunk in the green house.
constraint forall ([color[i] == green <-> drink[i] == coffee | i in 1..nc]);

% The Ukrainian drinks tea.
constraint forall ([nationality[i] == ukr <-> drink[i] == tea | i in 1..nc]);

% The green house is immediately to the right of the ivory house.
constraint forall ([color[i] == ivory -> if i<nc then color[i+1] == green else false endif | i in 1..nc]);

% The Old Gold smoker owns snails.
constraint forall ([smoke[i] == oldgold <-> pet[i] == snail | i in 1..nc]);

% Kools are smoked in the yellow house.
constraint forall ([smoke[i] == kools <-> color[i] == yellow | i in 1..nc]);

% Milk is drunk in the middle house.
constraint drink[3] == milk;

% The Norwegian lives in the first house.
constraint nationality[1] == nor;

% The man who smokes Chesterfields lives in the house next to the man with the fox.
constraint forall ([smoke[i] == chesterfields -> (if i>1 then pet[i-1] == fox else false endif \/ if i<nc then pet[i+1] == fox else false endif) | i in 1..nc]);

% Kools are smoked in the house next to the house where the horse is kept.
constraint forall ([smoke[i] == kools -> (if i>1 then pet[i-1] == horse else false endif \/ if i<nc then pet[i+1] == horse else false endif)| i in 1..nc]);

%The Lucky Strike smoker drinks orange juice.
constraint forall ([smoke[i] == luckystrike <-> drink[i] == orange | i in 1..nc]);

% The Japanese smokes Parliaments.
constraint forall ([nationality[i] == jap <-> smoke[i] == parliaments | i in 1..nc]);

% The Norwegian lives next to the blue house.
constraint forall ([color[i] == blue -> (if i > 1 then nationality[i-1] == nor else false endif \/ if i<nc then nationality[i+1] == nor else false endif) | i in 1..nc]);

solve satisfy;

उपाय:

Compiling zebra.mzn
Running zebra.mzn
color = array1d(1..5 ,[4, 5, 1, 3, 2]);
nationality = array1d(1..5 ,[4, 3, 1, 2, 5]);
pet = array1d(1..5 ,[3, 4, 2, 1, 5]);
drink = array1d(1..5 ,[5, 2, 3, 4, 1]);
smoke = array1d(1..5 ,[2, 3, 1, 4, 5]);
----------
Finished in 47msec
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.