/** Class methods that do useful things with numbers. */
public class MathOp
{
/** Return the value of 2 to the power expo. */
public static int powerOf2 (int expo)
{ int power = 1;
for (; expo > 0; expo--)
power = power * 2;
return power;
} //======================
/** Return sum divided by count, rounded to the nearest int.*/
public static int average (int sum, int count)
{ if (sum >= 0)
return (sum + count / 2) / count;
else
return (sum - count / 2) / count;
} //======================
}
public class Person extends Object
{
private static int theNumPersons = 0; // initialize num
/////////////////////////////////
private String itsFirstName;
private String itsLastName;
private int itsBirthYear;
/** Construct a new Person with given names and birth year. */
public Person (String first, String last, int year)
{ super();
theNumPersons++; // update num
itsFirstName = first;
itsLastName = last; // initialize last name
itsBirthYear = year;
} //=======================
/** Tell how many different Persons exist. */
public static int getNumPersons() // access num
{ return theNumPersons;
} //======================
/** Return the birth year. */
public int getBirthYear()
{ return itsBirthYear;
} //=======================
/** Return the first name. */
public String getFirstName()
{ return itsFirstName;
} //=======================
/** Return the last name. */
public String getLastName() // access last name
{ return itsLastName;
} //=======================
/** Replace the last name by the specified value. */
public void setLastName (String name) // update last name
{ itsLastName = name;
} //=======================
}
public class Vic extends Object
{
private static final String NONE = "0";
/////////////////////////////////
private String itsSequence = "";
private int itsPos = 1;
private final int itsID; // assigned by the constructor
public String getPosition()
{ return itsPos + "," + itsID;
} //======================
public static void say (String message)
{ System.out.println ("SAYS: " + message);
} //======================
private void trace (String action)
{ System.out.println ("Vic# " + itsID + ": " + action
+ itsPos + "; sequence= " + itsSequence);
} //======================
public void backUp()
{ if (itsPos == 1)
System.exit (0);
itsPos--;
trace ("backUp to slot ");
} //======================
public void moveOn()
{ if ( ! seesSlot())
System.exit (0);
itsPos++;
trace ("moveOn to slot ");
} //======================
public boolean seesSlot()
{ return itsPos < itsSequence.length();
} //======================
public boolean seesCD()
{ if ( ! seesSlot())
System.exit (0);
String s = itsSequence.substring (itsPos, itsPos + 1);
return ! s.equals (NONE);
} //======================
// public class Vic continued: using the stack
private static String theStack = ""; // initially empty
public static boolean stackHasCD()
{ return theStack.length() > 0;
} //======================
public void takeCD()
{ if (seesCD())
{ theStack = theStack
+ itsSequence.substring (itsPos, itsPos + 1);
itsSequence = itsSequence.substring (0, itsPos) + NONE
+ itsSequence.substring (itsPos + 1,
itsSequence.length());
}
trace ("takeCD at slot ");
} //======================
public void putCD()
{ if ( ! seesCD() && stackHasCD())
{ int atEnd = theStack.length() - 1;
itsSequence = itsSequence.substring (0, itsPos)
+ theStack.substring (atEnd, atEnd + 1)
+ itsSequence.substring (itsPos + 1,
itsSequence.length());
theStack = theStack.substring (0, atEnd);
}
trace ("putCD at slot ");
} //======================
// public class Vic completed: constructor and reset
private static final java.util.Random randy
= new java.util.Random();
private static final String LETTERS = " abcdefghijkl";
private static int theNumVics = 0;
private static String[ ] theTableau = {"", "", ""};
public static void reset (String[ ] args)
{ if (theNumVics == 0 && args.length > 0)
theTableau = args;
} //======================
public Vic()
{ super(); // 1
if (theNumVics < theTableau.length) // 2
{ itsSequence = theTableau[theNumVics]; // 3
if (itsSequence.length() == 0) // 4
{ for (int k = 3 + randy.nextInt (6); k >= 1; k--) // 5
{ if (randy.nextInt (2) == 0) // 6
itsSequence = NONE + itsSequence; // 7
else // 8
itsSequence = LETTERS.substring (k, k + 1)// 9
+ itsSequence; // 10
} // 11
} // 12
itsSequence = " " + itsSequence; // 13
} // 14
theNumVics++; // 15
itsID = theNumVics; // 16
trace ("constructed "); // 17
} //======================
}
import javax.swing.JOptionPane;
class NetApp
{
/** List all nodes and tell how many there are. */
public static void main (String[ ] args)
{ Network school = new Network();
int count = 0;
for (Position pos = school.nodes(); pos.hasNext(); pos.moveOn())
{ Node current = pos.getNext();
JOptionPane.showMessageDialog (null,
current.getName() + " is one of the nodes.");
count++;
}
JOptionPane.showMessageDialog (null,
"The total number of nodes is " + count);
System.exit (0);
} //======================
}
/** Answer queries about one or two given nodes.
* Precondition for all methods: no parameter is null. */
public class NodeOp
{
/** Tell whether par connects only to blue nodes. */
public static boolean seesOnlyBlue (Node par)
{ for (Position p = par.nodes(); p.hasNext(); p.moveOn())
{ if ( ! p.getNext().isBlue())
return false;
}
return true;
} //=======================
/** Tell whether from connects to target. */
public static boolean connected (Node from, Node target)
{ for (Position p = from.nodes(); p.hasNext(); p.moveOn())
{ if (p.getNext().equals (target))
return true;
}
return false;
} //=======================
/** Tell whether par connects to any node of the same color.*/
public static boolean seesSameColor (Node par)
{ return par.isBlue() && ! seesOnlyNonBlue (par)
|| ! par.isBlue() && ! seesOnlyBlue (par);
} //=======================
/** Tell whether par connects to no blue node. */
public static boolean seesOnlyNonBlue (Node par)
{ for (Position p = par.nodes(); p.hasNext(); p.moveOn())
{ if (p.getNext().isBlue())
return false;
}
return true;
} //=======================
}
import javax.swing.JOptionPane;
public class SmartNet extends Network
{
/** Tell whether par connects to all other nodes in this
* network.*/
public boolean connectsToAll (Node par)
{ for (Position pos = nodes(); pos.hasNext(); pos.moveOn())
{ Node current = pos.getNext();
if ( ! (current.equals (par)
|| NodeOp.connected (current, par)))
return false;
}
return true;
} //======================
/** Return the total number of nodes in this network. */
public int getNumNodes()
{ int count = 0;
for (Position pos = nodes(); pos.hasNext(); pos.moveOn())
count++;
return count;
} //======================
/** List all nodes in this network that connect to
* some node of the same color. */
public void printSameColorConnections()
{ for (Position pos = nodes(); pos.hasNext(); pos.moveOn())
{ Node current = pos.getNext();
if (NodeOp.seesSameColor (current))
JOptionPane.showMessageDialog (null,
current.getName());
}
} //======================
/** Tell whether every node is reachable from
* the given node. */
public boolean allReachableFrom (Node source)
{ checkOut (source); // sets a mark of 2 on source
boolean foundNodeToCheckOut;
do
{ foundNodeToCheckOut = false;
for (Position pos= nodes(); pos.hasNext(); pos.moveOn())
{ Node current = pos.getNext();
if (current.getMark() == 1)
{ foundNodeToCheckOut = true;
checkOut (current);
}
}
}while (foundNodeToCheckOut);
return allNodesAreMarked();
} //======================
/** Mark 2 on par; mark 1 on all nodes reachable from par
* except for those already marked 1 or 2.
* Precondition: par is not null. */
private static void checkOut (Node par)
{ par.setMark (2);
for (Position p = par.nodes(); p.hasNext(); p.moveOn())
{ Node current = p.getNext();
if (current.getMark() == 0)
current.setMark (1);
}
} //======================
/** Tell whether all the nodes have a non-zero mark.
* Also set all marks back to zero. */
private boolean allNodesAreMarked()
{ boolean valueToReturn = true;
for (Position pos = nodes(); pos.hasNext(); pos.moveOn())
{ if (pos.getNext().getMark() == 0)
valueToReturn = false;
else
pos.getNext().setMark (0);
}
return valueToReturn;
} //======================
/** Tell whether it is possible to travel through n nodes,
* all different and all marked 0, starting from Node base.
* Precondition: base is marked 0. */
public static boolean canTravelFrom (Node base, int n)
{ if (n <= 1)
return true;
base.setMark (1);
for (Position p = base.nodes(); p.hasNext(); p.moveOn())
{ Node current = p.getNext();
if (current.getMark() == 0
&& canTravelFrom (current, n - 1))
{ base.setMark (0); // restore original state
return true;
}
}
base.setMark (0); // restore original state
return false;
} //======================
}
public class Position extends Object
{
private int itsCurrent; // Node at current position on list
private int itsLast; // Node at last position on list
public Position (int first, int last)
{ super();
itsCurrent = first;
itsLast = last;
} //======================
/** Return the next Node in the sequence. Return null
* if you have come to the end of the sequence. */
public Node getNext()
{ if (itsCurrent > itsLast)
return null;
else
return new Node (itsCurrent % Network.NUM_NODES);
} //======================
/** Tell whether there is another Node in the sequence. */
public boolean hasNext()
{ return itsCurrent <= itsLast;
} //======================
/** Go one Node further in the sequence. */
public void moveOn()
{ itsCurrent++;
} //======================
}
public class Network extends Object
{
public static final int NUM_NODES = 100;
///////////////////////////////////////
/** Return an object that can produce all Nodes 1 at a time. */
public Position nodes()
{ return new Position (0, NUM_NODES - 1);
} //======================
}
public class Node extends Object
{
private int itsID; // ranges from 0 to NUM_NODES - 1
public Node (int index)
{ super();
itsID = index;
} //======================
/** Return an object that can produce all Nodes that
* are connected to the executor, 1 at a time. */
public Position nodes()
{ return new Position (itsID + 1, itsID + 4);
} //======================
/** Tell whether the parameter has the same contents as
* the executor. */
public boolean equals (Node par)
{ return par != null && this.itsID == par.itsID;
} //======================
/** Tell whether this Node has the property of being blue. */
public boolean isBlue()
{ return itsID % 2 == 1;
} //======================
/** Return the name of this Node. */
public String getName()
{ return "Darryl";
} //======================
private int itsMark = 0;
/** Assign a value to the mark on this Node. */
public void setMark (int par)
{ itsMark = par;
} //======================
/** Return the current value marked on this Node. */
public int getMark()
{ return itsMark;
} //======================
}
|
2