Question

Please help with my car traffic simulator!

Code that I already have below, I do not know how to start it off!

public class IntersectionSimulation
{
        private final static int   EAST_WEST_GREEN_TIME    = 30 ;
        private final static int[] NORTH_SOUTH_GREEN_TIMES = { 20, 24, 30, 42 } ;
        private final static int[] CAR_INTERSECTION_RATES  = { 3,  5, 10 } ;
        private final static int[] CAR_QUEUEING_RATES      = { 5, 10, 30 } ;
        private final static int[] EXPERIMENT_DURATIONS    = { 3*60, 5*60, 10*60 } ;
                        
        public static void main( String[] args )
        {
                System.out.println( "E/W Green  N/S Green  Int. Rate  Q. Rate  Duration  N Cars  S Cars  E Cars  W Cars" ) ;
                System.out.println( "----------------------------------------------------------------------------------" ) ;

                for( int i = 0 ; i < 4 ; ++i )
                {
                        for( int j = 0 ; j < 3 ; ++j )
                        {
                                for( int k = 0 ; k < 3 ; ++k )
                                {
                                        for( int l = 0 ; l < 3 ; ++l )
                                        {
                                                int northSouthGreenTime = NORTH_SOUTH_GREEN_TIMES[ i ] ;
                                                int carIntersectionRate = CAR_INTERSECTION_RATES [ j ] ;
                                                int carQueueingRate     = CAR_QUEUEING_RATES     [ k ] ;
                                                int experimentDuration  = EXPERIMENT_DURATIONS   [ l ] ;
                                                
                                                //Logic goes here...
                                        }
                                }
                        }
                }
        }
        
        private static class Car
        {
                //This class can be completely empty.
                // We just need *something* in our queues.
                // It's the count of items in the queues we are concerned with,
                //  not the properties of the items in the queues.
        }
}

public class CircularArrayQueue<T> implements QueueADT<T>
{
   private final static int DEFAULT_CAPACITY = 100; //Static b/c it's only 1 version of it
   private int front, rear, count;
   private T[] queue;
  
   @SuppressWarnings("unchecked")
   public CircularArrayQueue(int initialCapacity)
   {
       front = rear = count = 0;
       queue = (T[]) new Object [ initialCapacity];
   }
     
   public CircularArrayQueue()
   {
       this(DEFAULT_CAPACITY);
   }
  
   public void enqueue(T element)
   {
       if (size() == queue.length)
           expandCapacity();
      
       queue [rear] = element;
       rear = (rear + 1) % queue.length;
       ++count;
   }
  
  

   public T dequeue() throws EmptyCollectionException
   {
       if(isEmpty())
      
           throw new EmptyCollectionException();
      
       T result = queue[front];
       queue [front] = null;
       front = (front + 1) % queue.length;
       --count;
      
       return result;
   }
  
   public T first() throws EmptyCollectionException
   {
       if(isEmpty())
           throw new EmptyCollectionException();
      
       return queue[front];
   }
  
   public int size()
   {
       return count;
   }

   public boolean isEmpty()
   {
       return count <=0;
   }
  
   private void expandCapacity()
   {
       @SuppressWarnings("unchecked")
       T[] larger = (T[]) new Object [queue.length * 2];
       for(int i = 0; i < count; i++)
       {
           larger[i] = queue [front];
           front = (front + 1) % queue.length;
       }
       front = 0;
       rear = count;
      
       queue = larger;
   }
  
   public String toString()
   {
       String output= "CircularArrayQueue -> [ ";
       int pointer = front;
       for(int i =0; i < count; i++)
       {
           output+= queue [pointer] + " ";
           pointer = (pointer + 1) % queue.length;
       }
       output+= "]";
       return output;
   }

  
}

public class EmptyCollectionException extends Exception
{
  
   private static final long serialVersionUID = 358083002087971606L;

   public EmptyCollectionException()
   {
       super();
   }
  
   public EmptyCollectionException(String msg)
   {
       super(msg);
   }
}
public class LinearNode<T>
{
   private LinearNode<T> next;
   private T           element;
  
   public LinearNode()
   {
       next = null;
       element = null;
   }
  
   public LinearNode(T elem)
   {
       next = null;
       element = elem;
   }
  
   public LinearNode<T> getNext()
   {
       return next;
   }
  
  
   public void setNext (LinearNode<T> node)
   {
       next = node;
   }
   public T getElement()
   {
       return element;
   }
  
   public void setElement(T elem)
   {
       element = elem;
   }
}

public class LinkedQueue<T> implements QueueADT<T>
{

   private int count;
   private LinearNode<T> head;
   private LinearNode<T> tail;
          
   public LinkedQueue()
   {
       count = 0;
       head = null;
       tail = null;
   }
   @Override
   public void enqueue(T element)
   {
       LinearNode<T> node = new LinearNode<T> (element);
       if(isEmpty())
           head = node;
       else
           tail.setNext(node);
       tail = node;
       ++count;
      
   }

   @Override
   public T dequeue() throws EmptyCollectionException
   {
       if (isEmpty())
       {
           throw new EmptyCollectionException();
       }
          
           T result = head.getElement();
           head = head.getNext();
           --count;
           if(isEmpty())
               tail = null;
           return result;
       }
      
  
  

   @Override
   public T first() throws EmptyCollectionException
   {
       if(isEmpty())
           throw new EmptyCollectionException();
       return head.getElement();
   }

   @Override
   public int size()
   {
       return count;
   }

   @Override
   public boolean isEmpty()
   {
       return count<=0;
   }
  
   public String toString()
   {
       String output = "LinkedQueue -> [ ";
       LinearNode<T> current = head;
       while(current != null)
       {
           output+= current.getElement().toString() + " ";
           current = current.getNext();
       }
       output+= "]";
       return output;
   }

}

public interface QueueADT<T>
{
       public void enqueue(T element);
      
       public T dequeue() throws EmptyCollectionException;
      
       public T first() throws EmptyCollectionException;
      
       public int size();
      
       public boolean isEmpty();
}

2.) Create a simulation of an intersection using queues. Assume that there is a single lane going irn each direction, that the lights are only red or green and change immediately (which would be super dangerous in real life), and that all vehicles perfectly follow the rules. These assumptions will make the program much simpler. Use a queue to represent the traffic coming from each of the four directions..names like northBoundVehicles, southBoundVehicles, etc make sense to me. The four variables in the experiment will be: The number of seconds the east/west lights will be a constant of 30 seconds for all experiments before switching to red. The number of seconds the north/south lights are green before switching to red will vary. (This is one variable that will have four possible values: 20, 24, 30, and 42.) The rate at which cars travel through the intersection: one car every 3 seconds, one car ever 5 seconds, and one car every 10 seconds. (This is one variable that will have three possible values.) The rate at which cars arrive in each of the 4 lanes: once every 5 seconds, once every 10 seconds, and once every 30 seconds. (This is one variables that will have three possible values.) Additionally, I want you to run this simulation for three different time periods: 3 minutes, 5 minutes, and 10 minutes. a. b. C. d. Some hints . Ultimately, with four variables, that means you will have four loops nested within each other in order to try all combinations Within each loop, you will "run a simulation", which means a loop with a counter that represents the number of seconds the simulation runs for (so that's a fifth nested loop) That makes this a software engineering challenge regarding how to make the code readable and maintainable. A small number of points (5) will be reserved for the readability/maintainability that I perceive. If all of these loops are just embedded in each other in your main method, I will not perceive that as readable/maintainable, so use methods judiciously . We will be running 108 total experiments (each of the four variables' possible values multiplied together: 4x3x3x3). An additional challenge for this assignment is how to report out the data we collect from the experiment in a digestible manner. Here's a sample of the output from my implementation for 3 of the 108 experiments E/W Green N/S Green Int. Rate Q. Rate Duration N Cars scars E Cars พ Cars 30 30 30 20 20 180 300 600 18 18 10 10 48 48 Legend E/W Green: the number of seconds the east/west light is green N/S Green: the number of seconds the north/south light is green Int. Rate: the rate (in seconds) at which cars travel through the intersection Q. Rate: the rate (in seconds) at which cars arrive in line from each direction Duration: how long (in virtual seconds) the experiment ran for N Cars: the number of cars in the north bound lane waiting to go at the conclusion of the experiment S Cars: the number of cars in the south bound lane waiting to go at the conclusion of the experiment E Cars: the number of cars in the east bound lane waiting to go at the conclusion of the experiment W Cars: the number of cars in the west bound lane waiting to go at the conclusion of the experiment You will want to use String.fomat() to specify the width of the "fields" Store al variables and work with everything in seconds to avoid unit conversion and confusion This program is more about implementing a logical problem, with queues as a tool involved than anything else. I have provided IntersectionSimulationStarter.java ...this will help you get started, but note it has a bunch of embedded loops. You can do better than this. I suggest getting your program running with those loops, then do what's called "refactoring", which is changing the structure of a program to be better, without changing the logic the

Answer 1

/Here's the code with comments for both the parts of the question 1:

public class Palindrome{
public static void main (String[] args) throws Exception{
checkPalindrome();
}

public static void checkPalindrome() throws Exception{
Scanner sc = new Scanner(System.in);
System.out.print("Enter a string: ");
taking the input into the variable str
String str = sc.nextLine();
checking using the queue
boolean queueCheck = checkForPalindromeUsingQueue(str);
checking using the stack
boolean stackCheck = checkForPalindromeUsingStack(str);
String isNotStringQueue = queueCheck ? "IS" : "IS NOT";
String isNotStringStack = stackCheck ? "IS" : "IS NOT";
printing the desired output
System.out.println("According to the queue method that statement " + isNotStringQueue + " a palindrome");
System.out.println("According to the queue method that statement " + isNotStringStack + " a palindrome");
System.out.println("Try another (y/n)?");
String input = sc.nextLine();
if (input.equals("y"))
checkPalindrome();
}

public static boolean checkForPalindromeUsingQueue(String str) throws Exception{
LinkedQueue queue = new LinkedQueue();
storing the string character by character into the queue in reverse order
because queue follows FIRST IN FIRST OUT logic
for(int i = str.length()-1; i >= 0; i--)
queue.enqueue(str.charAt(i));
creating the reverse string using the queue created above
on dequeuing the queue, it will output a new string in the reverse order of the original string
String reverse = "";
while(!queue.isEmpty()){
reverse += queue.dequeue();
}
if the reverse string is equal to the original string, then str is a palindrom otherwise no.
same logic is followed in the implementation using the stack except that the stack data structure is
used to store the string character by character.
return reverse.equals(str);
}

public static boolean checkForPalindromeUsingStack(String str){
Stack stack = new Stack();
for(int i = 0; i < str.length(); i++)
stack.push(str.charAt(i));

String reverse = "";
while(!stack.isEmpty())
reverse+=stack.pop();
return reverse.equals(str);
}
}