### CS30 - Spring 2015 - Class 24

#### Lecture notes

- assignment 10
- use debug mode if your program is freezing
- remember, will use many different starting piles (all with 4 piles, though)

- NIM tournament in class next Tuesday

• DFA vs. NFA
- DFAs must have a transition for each letter in alphabet to exactly one state
- NFAs for each letter in the alphabet can have zero, one or *more* transitions to other states
- NFAs can also have \lambda transitions which move to a different state without reading a character

• number representation
- when you type:

>> x = 17

how does the computer actually store this information, specifically the number 17?

- if you look far enough down into the details of what's going on when you run your computer, almost everything is represented using binary, i.e. some combination of 1's and 0's
- why binary?
- a combination of ease of use and cost
- basic idea: "1" electrical current is flowing, "0" current is not flowing
- transistors can do built to do this efficiently, cheaply and at a extremely small scale
- could do other representations, but this is what is most effective right now... (and has been for a long time)

• decimal numbers
- most commonly used number systems have a "base"
- each digit in the number can range from 0...base-1
- each digit in the number has an index, starting at the right-most digit with 0 and working up to the left
- the contribution of the digit is:

base^index * value

- by summing up the contribution of all of the digits, we get the value of the number

- what is the base for our numbering system?
- 10

- for example
- 245 = 5*10^0 + 4*10^1 + 2*10^2
- 80498 = 8*10^0 + 9*10^1 + 4*10^2 + 0*10^3 + 8*10^4

• binary numbers
- we can represent numbers using any base we want
- binary numbers are numbers represented as base 2
- digits can only be a 0 or a 1

- for example, the following binary numbers:
- 101 = 1*2^0 + 0*2^2 + 1*2^2 = 5
- 11 = 1*2^0 + 1*2^1 = 3
- 10111 = 1*2^0 + 1*2^1 + 1*2^2 + 0*2^3 + 1*2^4 = 23
- 100001 = 1*2^0 + 1*2^5 = 33

• some number examples (DFA) (look in DFA examples)
- greater_5.jff: all numbers 5 or greater (represented as binary)

- odd_number.jff: all odd numbers (represented as binary)
- (O|1)*1

• play with JFLAP

• design a DFA that accepts 0^n1^n
- First hint that this is a problem is that we can't represent this as a regular expression
- seems like we need to count the number of zeros
- problem is we could have any number of 0s

• turing machines
- similar to DFAs
- they have states with transitions defined over the alphabet
- they have a starting state and one or more final/accepting states
- key differences:
- Can *write* to the input tape as well as read
- Can more right *and* left on the input tape
- The input tape is infinite!

• look at the 0n1n example (found in turing examples)
- transitions are labeled with three things:
1) the input character read
2) the output character to write
3) which way to move the head (L, R or S)

- basic idea of this example:
- put Xs over the 0s. For each X you put on a 0, go find the next 1 and put a Y over it
- if you get to the point where everything is X and Y (and no 0s or 1s) you're done!

- slightly more detailed
- read a 0: put an X down and move right
- keep reading 0s and Ys to the right until you find a 1
- put a Y on that 1 and move left
- keep reading Ys and 0s until you find an X
- move right
- repeat
- if you get to a point where the first character is a Y
- read all the Ys and move right
- make sure that you get a blank (and not a 1 or a 0). If so, we're done!

• look at eq1s0s (found in turing examples)

• look at palindrome (found in turing examples)