A3P1

[t***@engmail.uwaterloo.ca]

Quoting Troy:

"... it's not the quantity of code that's a problem, it's the fact that
you're using an accummulated value (base) to make a decision as to which
state to go to next. You are only allowed to use the current character
of input to make this decision."

This confuses me. The assignment description says that we will need to use
some accumulated ints. Given that the problem is supposed to be done in no
more than 15 states, we will clearly need to use accumulated int(s) during the
reading of the numeral to decide if we must exit due to an invalid digit,
which is more efficient than using only states to decide this anyways. That is
the same kind of decision that Dan was making in his code: using an
accumulated variable to decide if the program should exit due to an error. He
was simply using it for handling errors in the base instead of errors in the
digits. So when you said that that wasn't allowed, did you mean that even
though error checking for the digits must use an accumulated variable, error
checking for the base must use only states? I can't find any other
interpretation of your statement that makes sense.

----------------------------------------
This mail sent through www.mywaterloo.ca

[Troy Mark Gonsalves]

If you use the method that suggest for converting characters to digits (a
method from java.lang.Character) then the test that Dan had can be
replaced with a test of the return value...which is a nicer way to code this.

Find the method that I'm referring to and read the description, this might
clarify things.

Troy

Post by t***@engmail.uwaterloo.ca
"... it's not the quantity of code that's a problem, it's the fact that
you're using an accummulated value (base) to make a decision as to which
state to go to next. You are only allowed to use the current character
of input to make this decision."
This confuses me. The assignment description says that we will need to use
some accumulated ints. Given that the problem is supposed to be done in no
more than 15 states, we will clearly need to use accumulated int(s) during the
reading of the numeral to decide if we must exit due to an invalid digit,
which is more efficient than using only states to decide this anyways. That is
the same kind of decision that Dan was making in his code: using an
accumulated variable to decide if the program should exit due to an error. He
was simply using it for handling errors in the base instead of errors in the
digits. So when you said that that wasn't allowed, did you mean that even
though error checking for the digits must use an accumulated variable, error
checking for the base must use only states? I can't find any other
interpretation of your statement that makes sense.
----------------------------------------
This mail sent through www.mywaterloo.ca

[Troy Mark Gonsalves]

I misunderstood this question. Here's a better answer:

You need to use states to recognize the base, if you do this properly then
you won't need an if statement to verify that the base is between 2 and
36. This is intended as an exercise in DFA design.


Troy

Post by t***@engmail.uwaterloo.ca
"... it's not the quantity of code that's a problem, it's the fact that
you're using an accummulated value (base) to make a decision as to which
state to go to next. You are only allowed to use the current character
of input to make this decision."
This confuses me. The assignment description says that we will need to use
some accumulated ints. Given that the problem is supposed to be done in no
more than 15 states, we will clearly need to use accumulated int(s) during the
reading of the numeral to decide if we must exit due to an invalid digit,
which is more efficient than using only states to decide this anyways. That is
the same kind of decision that Dan was making in his code: using an
accumulated variable to decide if the program should exit due to an error. He
was simply using it for handling errors in the base instead of errors in the
digits. So when you said that that wasn't allowed, did you mean that even
though error checking for the digits must use an accumulated variable, error
checking for the base must use only states? I can't find any other
interpretation of your statement that makes sense.
----------------------------------------
This mail sent through www.mywaterloo.ca