Thread: Very complex project. It's hard to explain.

Any idea what he means by swap "from" and "to"

Here's what he said:

4. For each iteration:
a. For each character that you remove from the “from” queue:
i. If it is the left side of any production, add the right side of that production to the “to” queue. Otherwise, add the character you read from the “from” queue to the “to” queue.
b. Swap “from” and “to”.

I already think I took care of part a, but what does he want me to do for part b?

I don't know how to swap "from" and "to".

With scanner.next() it gives you what is inbetween spaces, so if you use

for (int penguin = 0; penguin < numberOfProductions; penguin++)
{
// should read in single character that is on left side of production.  
c = console.next().getCharAt(0);
 
// should read in string that is right side of production
str = console.next();
}

then aslong as there are no spaces in the right hand side, which I didn't see any yet, str will contain full lefthand side.

He means make a queue of all the chars in the starting sequence, then for each char, check if it is a lhs(left hand side) symbol, if so, take the corresponding rhs and substitute the symbol

Originally Posted by Zula

With scanner.next() it gives you what is inbetween spaces, so if you use

for (int penguin = 0; penguin < numberOfProductions; penguin++)
{
// should read in single character that is on left side of production.  
c = console.next().getCharAt(0);
 
// should read in string that is right side of production
str = console.next();
}

then aslong as there are no spaces in the right hand side, which I didn't see any yet, str will contain full lefthand side.

I want str to contain right hand side.

c contains left hand side

Did I do something wrong?

	static Scanner in;
    public static void main(String[] args) throws IOException {
    	in = new Scanner(new File("generator-koch.txt"));
    	for(int i = 0;i<6;i++) {
    		System.out.println(in.next());
    	}
    	int numberOfProductions = (int)(Integer.parseInt(in.next()));
    	char c = ' ';
    	String str = "";
    	System.out.println("Read Production");
    	for (int penguin = 0; penguin < numberOfProductions; penguin++)
		{
			// should read in single character that is on left side of production.
			c = in.next().charAt(0);
 
			// should read in string that is right side of production
			str = in.next();
		}
		System.out.println("LHS: " + c + " RHS: " + str);
    	while(in.hasNext()) {
    		System.out.println(in.next());
    	}
    }

the output is:

--------------------Configuration: Turtle - JDK version 1.6.0_22 <Default> - <Default>--------------------
-200
1400
-400
1200
5
60
Read Production
LHS: F RHS: F-F++F-F
F++F++F
5
 
Process completed.

So if you can utilize the first data properly, that gives you lhs and rhs

your right, right hand side is str, I am a dumba** sometimes, heh

Originally Posted by Zula

He means make a queue of all the chars in the starting sequence, then for each char, check if it is a lhs(left hand side) symbol, if so, take the corresponding rhs and substitute the symbol

Does my code do that?

If not, how do I do that?

But what you need to do is in the for loop, once you read in a production, stick it in two queues, one for the lhs(from) and one for the rhs(to)

It appears it would yes.

Ok, but I'm only reading in from "from" and putting stuff in "to": How does he want me to swap it?

I'm wondering if he means to then do the same with to and read it into from, then do the same with from, then read it into to, then do the same with to and read it into from, etc.

How do you do that?

For the generator-koch.txt file, I get

F-F++F-F++F-F++F-F++F-F++F-FF-F++F-F++F-F++F-F++F-F++F-FF-F++F-F++F-F++F-F++F-F++F-FF-F++F-F++F-F++F-F++F-F++F-FF-F++F-F++F-F++F-F++F-F++F-F

as the product of the 5 iterations of the production and starting sequence

Make a for loop that goes to.length iterations and pop them from the 'to' queue into the 'from' queue

for(int asdf = 0;asdf<to.length();asdf++) {
    from.push(to.front());
    to.pop();
}

For the code:

for (int iter =0; iter < numberOfIterations;  iter++)
{ // beginning of for
 
for (int iter2 = 0; iter2 < from.Size(); iter2++)
{ // beginning of for
if(leftSide.contains(from.front()))
{ // beginning of if
 
for (int vvv =0; vvv<leftSide.size(); vvv++)
{ // beginning of for
 
if (leftSide.get(vvv).equals(from.front()))
{ // beginning of if
to.push(rightSide.get(vvv));
from.pop();
} // end of if
} // end of for
} // end of if
 
// if it is the right side of the production
else
{ // beginning of else
to.push(from.front());
from.pop();
} // end of else
} // end of for
} // end of for

How do I get it to do what I just did above, but this time replacing "from" and "to"?

And for the third, doing what I just did above, replacing the "from" and "to" from iteration 2, so it'll be reading in from "from" and moving to "to" again? And then for the fourth, how do I get it to do the same as the third iteration, but replacing the "from" and "to", and so on till the iterations are done.

Then for the last step, how can I find a way for it to tell which queue has the final sequence in it so that I can do this part and finally test the bloody program out in UNIX?

For whichever queue has the final sequence, interpret the characters and print out the corresponding results using System.out.println:
a. “F”: This corresponds to the “trace” command. Print “trace” followed by the step size from 2(b) above.
b. “+”: This is a counter-clockwise “turn”. Print “turn” followed by the angle from 2(c) above.
c. “-“: This is a clock-wise “turn”. Print “turn” followed by the negative of the angle from 2(c) above.
d. “[“: This is a “push”. Print “push”.
e. “]”: This is a “pop”. Print “pop”.

Here's what he said for part 3:

Part 3: Generating Turtle Commands
Many of the above files for turtle commands have been generated algorithmically. This is done by using “productions”. A production is like a Math equation, with a left side and a right side. An example of a production is:
F = F+F-F
where ‘F’, ‘+’, ‘-‘ are simply symbols (you are not performing any addition or subtraction). No two productions have the same symbol on their left side. A starting sequence of symbols is provided to you, say “++F--”. One can expand this sequence by substituting for every “F” the right side of the above production. Thus after one iteration, the sequence “++F--” becomes “++F+F-F--“. In the second iteration, one can again expand the result of the previous iteration, thus making the resulting sequence longer and longer with every iteration. When a set number of iterations is reached, the resulting sequence is converted into turtle commands. Keep in mind that there may be many productions, each with a different symbol on its left side. The starting sequence may also contain many symbols. Symbols in the sequence that are not on the left side of any production are left untouched (for example, the symbols ‘+’ and ‘-‘ above).
Some of the above pictures have been generated this way. In part 3, you have to write a program that reads productions and symbols from the keyboard, iterates over a given sequence, and convert the resulting sequence into turtle commands.
What to do:
1. Write a class MyQueue that behaves like a queue. You must use your own DoublyLinkedList class to write this queue. You are not allowed to use ArrayList or java’s LinkedList class for this purpose!
2. Write a program that reads input from the keyboard in the following order (follow along using one of the .pro files provided for this part):
a. Read in four integers xmin, xmax, ymin, ymax.
b. Read a single float number which is the “step size” of the trace command.
c. Read a single float number which is the angle you turn by using the turn command.
d. Read the number of productions (an integer).
e. Read each production as follows:
i. A single character that is the left side of the production.
ii. A string that is the right side of the production.
f. Read the starting sequence as a string of characters.
g. Read the number of iterations, which is an integer.
3. Create two queue objects, and put the starting sequence in the first one, one character at a time. This is the “from” queue, and the other is the “to” queue.
4. For each iteration:
a. For each character that you remove from the “from” queue:
i. If it is the left side of any production, add the right side of that production to the “to” queue. Otherwise, add the character you read from the “from” queue to the “to” queue.
b. Swap “from” and “to”.
5. Print the four integers xmin xmax ymin ymax.
6. For whichever queue has the final sequence, interpret the characters and print out the corresponding results using System.out.println:
a. “F”: This corresponds to the “trace” command. Print “trace” followed by the step size from 2(b) above.
b. “+”: This is a counter-clockwise “turn”. Print “turn” followed by the angle from 2(c) above.
c. “-“: This is a clock-wise “turn”. Print “turn” followed by the negative of the angle from 2(c) above.
d. “[“: This is a “push”. Print “push”.
e. “]”: This is a “pop”. Print “pop”.

I misspoke, it ends in the "from" queue, so print from the "from" queue

Not to seem like an idiot, but I have never done a switch structure before.

How would you fix this code to get one and then work for the last step?

// this class takes in productions and generates turtle commands.  
 
import java.util.ArrayList;
import java.io.*;
import java.util.*;
 
public class program6_part_3
{ // beginning of class
 
static Scanner console = new Scanner(System.in);
 
public static void main(String[] args)
{ // beginning of main
 
 
// declares variables and initializes them
 
int xMin = 0;
int xMax = 0;
int yMin = 0;
int yMax = 0;
float stepSize = 0;
float angleToTurn = 0;
int numberOfProductions = 0;
int numberOfIterations = 0;
char c = 'F';
String str = "";
String startingSequence = "";
 
// reads in xMin
xMin = console.nextInt();
 
// reads in xMax
xMax = console.nextInt();
 
// reads in yMin
yMin = console.nextInt();
 
// reads in yMax
yMax = console.nextInt();
 
// reads in step size
stepSize = console.nextFloat();
 
// reads in angle
angleToTurn = console.nextFloat();
 
// reads in number of productions
numberOfProductions = console.nextInt();
 
ArrayList<Character> leftSide= new ArrayList<Character>(numberOfProductions);
 
ArrayList<String> rightSide = new ArrayList<String>(numberOfProductions);
/*
Read each production as follows:
i. A single character that is the left side of the production.
ii. A string that is the right side of the production.
Read the starting sequence as a string of characters.
*/
 
for (int penguin = 0; penguin < numberOfProductions; penguin++)
{ // beginning of for
 
// should read in single character that is on left side of production.  
c = console.next().getCharAt(0);
leftSide.add((Character) c);
 
 
// should read in string that is right side of production
str = console.nextLine();
rightSide.add(str);
} // end of for
 
// should read in starting sequence as a whole String
startingSequence = console.nextLine();
 
// reads in number of iterations
 
numberOfIterations = console.nextInt();
 
// creates MyQueue object "from"
MyQueue<Character> from = new MyQueue<Character>();
 
// puts startingSequence into from, one character at a time.  
for (int aaa = 0; aaa < startingSequence.length; aaa++)
{ // beginning of for
from.push(startingSequence.getCharAt(aaa););
} // end of for
 
// creates MyQueue object "to"
MyQueue<Character> to = new MyQueue<Character>();
 
// for the number of iterations, it will remove from the "from" MyQueue and put it in the "to" MyQueue, one character at a time
/* for (int iter =0; iter < numberOfIterations; iter++)
{ // beginning of for
 
for (int iter2 = 0; iter2 < from.Size(); iter2++)
{ // beginning of for
if(leftSide.contains(from.front()))
{ // beginning of if
 
for (int vvv =0; vvv<leftSide.size(); vvv++)
{ // beginning of for
 
if (leftSide.get(vvv).equals(from.front()))
{ // beginning of if
to.push(rightSide.get(vvv));
from.pop();
} // end of if
} // end of for
} // end of if
 
// if it is the right side of the production
else
{ // beginning of else
to.push(from.front());
from.pop();
} // end of else
 
*/
for (int iter =0; iter < numberOfIterations;  iter++)
{ // beginning of for
 
for (int iter2 = 0; iter2 < from.Size(); iter2++)
{ // beginning of for
if(leftSide.contains(from.front()))
{ // beginning of if
 
for (int vvv =0; vvv<leftSide.size(); vvv++)
{ // beginning of for
 
if (leftSide.get(vvv).equals(from.front()))
{ // beginning of if
to.push(rightSide.get(vvv));
                       from.pop();
                  } // end of if
             } // end of for
        } // end of if
 
// if it is the right side of the production
        else
        { // beginning of else
            to.push(from.front());
            from.pop();
        } // end of else
    } // end of for
 
    for(int asdf = 0;asdf<to.length();asdf++) {
        from.push(to.front());
        to.pop();
    }
} // end of for
} // end of for
} // end of for
 
// prints out four integers
System.out.println(xMin + " " + xMax + " " + yMin + " " + yMax + " ");
} // end of main
 
} // end of program

// this class takes in productions and generates turtle commands.
 
import java.util.ArrayList;
import java.io.*;
import java.util.*;
 
public class program6_part_3
{ // beginning of class
	static Scanner console = new Scanner(System.in);
 
	public static void main(String[] args)
	{ // beginning of main
 
 
		// declares variables and initializes them
 
		int xMin = 0;
		int xMax = 0;
		int yMin = 0;
		int yMax = 0;
		float stepSize = 0;
		float angleToTurn = 0;
		int numberOfProductions = 0;
		int numberOfIterations = 0;
		char c = 'F';
		String str = "";
		String startingSequence = "";
 
		// reads in xMin
		xMin = console.nextInt();
 
		// reads in xMax
		xMax = console.nextInt();
 
		// reads in yMin
		yMin = console.nextInt();
 
		// reads in yMax
		yMax = console.nextInt();
 
		// reads in step size
		stepSize = console.nextFloat();
 
		// reads in angle
		angleToTurn = console.nextFloat();
 
		// reads in number of productions
		numberOfProductions = console.nextInt();
 
		ArrayList<Character> leftSide= new ArrayList<Character>(numberOfProductions);
 
		ArrayList<String> rightSide = new ArrayList<String>(numberOfProductions);
		/*
		Read each production as follows:
		i. A single character that is the left side of the production.
		ii. A string that is the right side of the production.
		Read the starting sequence as a string of characters.
		*/
 
		for (int penguin = 0; penguin < numberOfProductions; penguin++)
		{ // beginning of for
 
			// should read in single character that is on left side of production.
			c = console.next().charAt(0);
			leftSide.add((Character) c);
 
 
			// should read in string that is right side of production
			str = console.nextLine();
			rightSide.add(str);
		} // end of for
 
		// should read in starting sequence as a whole String
		startingSequence = console.nextLine();
 
		// reads in number of iterations
 
		numberOfIterations = console.nextInt();
 
		// creates MyQueue object "from"
		MyQueue<Character> from = new MyQueue<Character>();
 
		// puts startingSequence into from, one character at a time.
		for (int aaa = 0; aaa < startingSequence.length(); aaa++)
		{ // beginning of for
			from.push(startingSequence.charAt(aaa));
		} // end of for
 
		// creates MyQueue object "to"
		MyQueue<Character> to = new MyQueue<Character>();
 
		for (int iter =0; iter < numberOfIterations;  iter++)
		{ // beginning of for
			for (int iter2 = 0; iter2 < from.Size(); iter2++)
			{ // beginning of for
				if(leftSide.contains(from.front()))
				{ // beginning of if
 
					for (int vvv =0; vvv<leftSide.size(); vvv++)
					{ // beginning of for
 
						if (leftSide.get(vvv).equals(from.front()))
						{ // beginning of if
			/* ADDED THIS TO CONTINUE ADDING CHARS NOT A STRING*/
							String tmpRightSide = rightSide.get(vvv);
							for(int fdsa = 0;fdsa < tmpRightSide.length();fdsa++) {
								to.push(tmpRightSide.charAt(fdsa));
							}
							from.pop();
	                  	} // end of if
	             	} // end of for
	        	} // end of if
 
				// if it is not the left side of a production
	    	    else
	        	{ // beginning of else
	            	to.push(from.front());
	            	from.pop();
	        	} // end of else
	    	} // end of for
			for(int asdf = 0;asdf<to.size();asdf++) {
	        	from.push(to.front());
	        	to.pop();
	    	}
		} // end of for
 
		// prints out four integers
		System.out.println(xMin + " " + xMax + " " + yMin + " " + yMax + " ");
 
		for(int iter = 0;iter<from.size();iter++) {
			switch(from.front()) {
				case 'F': System.out.println("trace " + stepSize); break;
				case '+': System.out.println("turn " + angleToTurn); break;
				case '-': System.out.println("turn " + -angleToTurn); break;
				case '[': System.out.println("push"); break;
				case ']': System.out.println("pop"); break;
				default: System.out.println("Error!!"); break;
			}
			from.pop();
		}
	} // end of main
 
} // end of program

Alright..give that a try, I changed the way righthand string was added to the "to" queue as chars are needed, not one str in there.

Hmm...well, you need to empty from as you go through it or it will build up, but I see that doing so changes Size() and makes me run out faster than I should.

For iteration 1:

You pop a character from one queue, and either put it directly into the other queue, else you put the right side of the corresponding production into the other queue.

Now at the end of the first iteration, the "from" queue is empty and the "to" queue is full.

For iteration 2:

You now pop a character from the full queue and do the same thing. Thus what was the "to" queue in iteration 1 becomes the "from" queue here.

You don't necessarily need to duplicate entire queues. Just change the meaning of what "from" and "to" mean.

Here is an example:

The production is F=F+F

The starting sequence is F-F

Iteration 1:

From queue: F-F
To queue: empty

After iteration 1:
From queue: empty
To queue: F+F-F+F

Iteration 2:
From queue: F+F-F+F
To queue: empty

After iteration 2:
From queue: empty
To queue: F+F+F+F-F+F+F+F

I hope that clarifies things.

Just got a response back.

Am I doing it right?

Iteration 1:

From queue: F-F
To queue: empty

After iteration 1:
From queue: empty
To queue: F+F-F+F

Iteration 2:
From queue: F+F-F+F
To queue: empty

After iteration 2:
From queue: empty
To queue: F+F+F+F-F+F+F+F

In that example what happens between "After Iteration 1" when the from queue is empty and "Iteration 2" where it has data...you must transfer it...