10:44 a.m.
I've been playing with DROOLS again and had another look at
LogicProblems. I am quite pleased with the program I have now created.
It's pretty simple and should be easily modifiable for any of the
magazine type logic problems. Anyway, just in case it's of interest to
anyone else:
The java is:
package com.mda.logic;
import java.io.InputStreamReader;
import org.drools.RuleBase;
import org.drools.RuleBaseFactory;
import org.drools.StatefulSession;
import org.drools.compiler.PackageBuilder;
public class MonkeyDROOLS {
/**
* @param args
*/
public static void main(final String[] args) throws Exception {
//Standard stuff to load in the DROOLS rules and set it all up
final PackageBuilder builder = new PackageBuilder();
builder.addPackageFromDrl( new
InputStreamReader( MonkeyDROOLS.class.getResourceAsStream( "/
MonkeyDROOLS.drl" ) ) );
final RuleBase ruleBase = RuleBaseFactory.newRuleBase();
ruleBase.addPackage( builder.getPackage() );
final StatefulSession session = ruleBase.newStatefulSession();
//Define the various names being used for he problem
String[] names = new String[] { "anna", "harriet",
"mike", "sam" };
String[] fruits = new String[] { "apple", "banana",
"orange", "pear" };
String[] positions = new String[] { "branch", "grass",
"rock", "stream" };
//Insert all the possible combinations
for ( int n = 0; n < names.length; n++ ) {
for ( int c = 0; c < fruits.length; c++ ) {
for ( int p = 0; p < positions.length; p++ ) {
session.insert( new GRID( names[n], fruits[c],
positions[p]) );
//System.out.printf("Insert:%7s %7s %7s
\n",names[n], fruits[c], positions[p]);
}
}
}
//System.out.println( "----------------------------------");
//Fire the rules and then clean-up
session.fireAllRules();
session.dispose();
}
//Storage for the logic problem items plus accessors to get each item
public static class GRID {
private String name;
private String fruit;
private String position;
public GRID(String name,
String fruit,
String position) {
super();
this.name = name;
this.fruit = fruit;
this.position = position;
}
/**
* @return the fruit
*/
public String getFruit() {
return this.fruit;
}
/**
* @return the name
*/
public String getName() {
return this.name;
}
/**
* @return the position
*/
public String getPosition() {
return this.position;
}
}
}
The rules file is:
//Monkey Puzzle Logic Problem
//
//Mark Armitage 2008
//
//The basic idea is, in the JAVA we assert every possible combination.
//Then we have rules that retract anything given by the problems data.
//If it's a negative, i.e. 'sam doesn't like bananas' then that will
//equate to one rule; 'GRID( name == "sam", fruit ==
"banana")'
//in other words; if the entry is for 'sam' and the fruit is 'banana'
then
//we know it can't be true so retract it.
//Positive rules are a bit more complicated, they require 2 rules ;-)
//So e.g. 'sam likes sitting on grass'. We are retracting remember, so
we
//want to remove entries where sam isn't sitting on grass, or where
someone
//else IS sitting on grass, we know both of those cases are false. So
the
//rules would be; 'GRID( name == "sam", position != "grass"
)' &
// 'GRID( name != "sam", position == "grass"
)'
//I've tried to make it all as simple as possible, basically so that it
//should be easy to modify for ANY of the Logic Problems in the
magazines.
//There is one final rule that has to be added; that's to remove
duplicates.
//Sam can't be sat in two places, the apple can't be liked by two
monkeys etc.
package com.mda.logic;
//So we can access the java GRID with the data
import com.mda.logic.MonkeyDROOLS.GRID;
//Salience 150 so it is printed first
//Just an introduction to the problem.
rule "Intro"
salience 150
when
then
System.out.println("Monkey Logic Problem from Puzzler's
Paradise");
System.out.println("============================================");
System.out.println("1) Sam doesn't like bananas, likes
sitting on grass.");
System.out.println("2) Monkey sat on the rock ate the apple.");
System.out.println(" Monkey who ate the pear didn't sit on
the tree branch.");
System.out.println("3) Anna sat by the stream but she didn't
eat the pear.");
System.out.println("4) Harriet didn't sit on the tree
branch.");
System.out.println(" Mike doesn't like oranges.");
System.out.println("");
end
//1) Sam doesn't like bananas, likes sitting on grass.
//[We're retracting, so if sam likes bananas then that can't be right,
// also if sam is not on the grass that has to come out,
// but so does anything on the grass that isn't sam.]
rule "#1"
salience 100
when
$fact: (GRID( name == "sam", fruit == "banana") or
GRID( name == "sam", position != "grass" ) or
GRID( name != "sam", position == "grass" ));
then
retract ($fact);
end
//2) Monkey sat on the rock ate the apple.
// Monkey who ate the pear didn't sit on the tree branch.
//[We're retracting, so if the position is rock but not an apple then
bin it,
// again you also have to do the other; if it is an apple but not on
the rock.
// positive facts such as pos=rock, fruit=apple will equate to two
retraction criteria,
// firstly the pos=rock but fruit<>apple; but also the other way
around, fruit=apple but pos<>rock.]
rule "#2"
salience 100
when
$fact: (GRID( position == "rock", fruit != "apple" ) or
GRID( fruit == "apple", position != "rock" ) or
GRID( fruit == "pear", position == "branch"));
then
retract ($fact);
end
//3) Anna sat by the stream but she didn't eat the pear.
rule "#3"
salience 100
when
$fact: (GRID( name == "anna", position != "stream") or
GRID( position == "stream", name != "anna" ) or
GRID( name == "anna", fruit == "pear" ));
then
retract ($fact);
end
//4) Harriet didn't sit on the tree branch.
// Mike doesn't like oranges.
rule "#4"
salience 100
when
$fact: (GRID( name == "harriet", position == "branch") or
GRID( name == "mike", fruit == "orange"));
then
retract ($fact);
end
//Ensure everything is used just once
//Find a solution but ensure that we don't have any duplicates.
rule "No duplicates"
salience 50
when
$sol1: GRID( name == "anna", $aP : position,
$aF : fruit);
$sol2: GRID( name == "harriet", $hP : position != $aP,
$hF : fruit != $aF);
$sol3: GRID( name == "mike", $mP : position != $aP,
position != $hP,
$mF : fruit != $aF, fruit != $hF);
$sol4: GRID( name == "sam", $sP : position != $aP,
position != $hP, position != $mP,
$sF : fruit != $aF, fruit != $hF, fruit != $mF);
then
printGrid( " ",$sol1,0);
printGrid( " 1:",$sol1,1);
printGrid( " 2:",$sol2,1);
printGrid( " 3:",$sol3,1);
printGrid( " 4:",$sol4,1);
end
//Salience -99 so it is printed last
rule "Summary"
salience -99
when
then
System.out.println("");
System.out.println("The solution should be:");
System.out.printf(" %-7.7s %-7.7s %-8.8s
\n","Name","Fruit","Position");
System.out.printf(" %-7.7s %-7.7s %-8.8s
\n","====","=====","========");
System.out.printf(" %-7.7s %-7.7s %-8.8s
\n","anna","orange","stream");
System.out.printf(" %-7.7s %-7.7s %-8.8s
\n","harriet","apple","rock");
System.out.printf(" %-7.7s %-7.7s %-8.8s
\n","mike","banana","branch");
System.out.printf(" %-7.7s %-7.7s %-8.8s
\n","sam","pear","grass");
end
function void printGrid( String tmp, GRID summary, int mode)
{
if (mode == 0)
{
System.out.println("");
System.out.println("The solution from DROOLS:");
System.out.printf(tmp+"%-7.7s %-7.7s %-8.8s
\n","Name","Fruit","Position");
System.out.printf(tmp+"%-7.7s %-7.7s %-8.8s
\n","====","=====","========");
}
else
{
System.out.printf(tmp+"%-7.7s %-7.7s %-8.8s
\n",summary.getName(),summary.getFruit(),summary.getPosition());
}
}
A sample run is:
Monkey Logic Problem from Puzzler's Paradise
============================================
1) Sam doesn't like bananas, likes sitting on grass.
2) Monkey sat on the rock ate the apple.
Monkey who ate the pear didn't sit on the tree branch.
3) Anna sat by the stream but she didn't eat the pear.
4) Harriet didn't sit on the tree branch.
Mike doesn't like oranges.
The solution from DROOLS:
Name Fruit Position
==== ===== ========
1:anna orange stream
2:harriet apple rock
3:mike banana branch
4:sam pear grass
The solution should be:
Name Fruit Position
==== ===== ========
anna orange stream
harriet apple rock
mike banana branch
sam pear grass