CS 454, Section 001	Sonoma State University	Spring, 2026

Theory of Computation
Instructor: Henry M. Walker Lecturer, Sonoma State University Professor Emeritus of Computer Science and Mathematics, Grinnell College

Although much of this course has been well developed in recent semesters, some details may be adjusted from semester to semester. For example, the Signature Project for this course has satisfied SSU's Upper Division GE Area B Requirement for CS Majors for several years, and satisfying that requirement again this semester. However, details of this project likely vary from instructor to instructor and from semester to semester. Also,

This course syllabus can be expected to remain stable through the semester (except for clarifying statements or for correcting typographical errors, if any).
The course schedule, assignments, elements of the Signature Project, and other course materials may be adjusted as the semester progresses, until the week before student work is due. Be sure to check/reload Web pages for the course before starting required course work.

Assignment on DFAs/NFAs and Regular/Non-regular Expressions

A Regular Expression and Its Corresponding NFA

Consider the regular expression ( (1 00 1^*)^* ) ∪ 10^*.
1. Identify two strings that are members of the language described by this regular expression.
2. Identify two strings that are NOT members of the language described by this regular expression.
3. Use the procedure described in Lemma 1.55 to convert the above regular expression to an NFA.

Regular and Non-regular Languages

For each of the following, determine if the language is regular or not, and justify your answer in each case.
1. Let the alphabet Σ = {0, 1, +, =} and let A be the language: A = {x+y=z | x, y, and z are binary unsigned integers and z is the sum of x and y} Is A an regular language? Justify your answer.
2. Let the alphabet Σ = {a, b}, and let B be the strings over this alphabet with either an odd number of a's or an even number of b's, but not both an odd number of a's and an even number of b's. Is B a regular language? Justify your answer.
3. Consider the alphabet Σ = {a, b}. For a string s ∈ Σ^*, define s^R as the reverse of s. That is, the characters in s^R are the same as the characters in s, but the characters appear in the reverse order. Is {s s^R | s ∈ Σ^*} a regular language? Be sure to justify your answer.

Comments in C/C++:

C/C++ allows two types of comments:

Any character sequence [on one or more lines] that starts with /*, ends with */ and does not contain */ except at its end.
Any part of a line that begins with // and concludes at the end of the line.

For the purposes of this problem, suppose all characters within a C/C++ program are from the set Σ = {/, *, a, b, N, E}, where N represents the end-of-line character and E represents the end-of-file character. (In a real C/C++ program, of course, the characters a, b would be extended to all letters, digits, punctuation, etc., but that seems too extensive for this exercise.)

Notes:

A comment beginning with /*, but having no concluding */, is considered to have a syntax error. A compiler will generate an error, and the program likely will not compile.
All programs must end with an end-of-file character E, but that character may appear only at the end.
An end-of-line character is not required before the end-of-file. Thus, a comment beginning with // may be completed with either N or E.
Comments in C/C++ do not nest.
In the discussion for this exercise, string literals (strings enclosed by double quotes ". . .") are ignored

Here are selected examples from Section 6.4.9 Comments in the 2011 C Standard.

// */;	// comment, not syntax error
f = g/**//h;	// equivalent to f = g / h;
//// l();	// equivalent to l();
m = n//**/o + p;	// equivalent to m = n + p;

Exercise: Draw an NFA state diagram with no more than 12 states that accepts exactly "programs" in which all comments are correctly specified in C/C++ and rejects any "program" that does not have the proper comment structure.

The NFA should read any sequence of characters from the above alphabet until the end-of-line character E is encountered.
Once the start of a comment is encountered, subsequent characters are ignored until the end of the comment is found.
When not within a comment, all characters should be ignored (except to identify the start of the next comment—elements of C/C++ syntax other than comments should not be analyzed).

DFA-based/Table-driven Program

Recognizing Numbers Although C/C++ allow several different formats for numbers, this problem considers only two main forms.
- Integers
  - An integer is a sequence of one or more digits {0, 1, . . . 9}.
  - For an integer, the digit sequence may (or may not) be preceded by a single plus (+) or minus (-) sign.
  - An integer may not contain a period or any non-digit character (except for a possible + or - character at the start).
- Floating-point numbers
  - A floating-point number is a sequence of one or more digits (0, 1, 2, . . . 9}, with exactly one period inserted at some position (e.g., at the start, the end, or somewhere between the ends.
  - For a floating-point number, the digit/period sequence may be preceded by a single plus (+) or minus (-) sign.
  - No other characters are permitted within a floating-point number.
Notes: For this problem:
- Integers may begin with any number of zeros, but an initial zero is not required..
- Floating-point numbers must contain a period, but the period may or may not be preceded by a digit.
- Both integers and floating-point numbers may contain any number of digits; the overall magnitude of the number or the number of digits is irrelevant to the specification of these numbers.
- A period character, by itself, is not a floating-point number.
- In parts a and b that follow, use the symbol D to represent any digit in the set {0, 1, 2, . . . 9}.—in the interests of simplicity of writing, you need not use each separate decimal digit in your state diagrams, unless you find that necessary.
1. Write a DFA to recognize both integers and floating-point numbers, as defined above.
  When scanning characters to identify a number, find the longest sequence of characters that can be a number.
  Thus, 123.456 should be identified as a floating-point number, not the integer 123 , following by the floating-point number .456 .
  Similarly, 123.45.6789 should be identified as the floating-point number 123.45 , followed by the floating point number .6789 .
2. Write a regular expression to accept all strings that are either integers or floating-point numbers, as defined above.
3. Using either the program dfa-comments.c or or the template dfa-comments-2.c as an example, write a DFA-based/table-driven program that uses your DFA of part a to identify and print all numbers read (until an end-of-file character is encountered). For each number identified, the program should label it appropriately as an integer or floating point type.
  As with all programs for this course,
  - The program must conform to the SSU CS C/C++ Style Guide (see SSU CS Department copy or Instructor's copy).
  - For this problem, submit both a listing of the C/C++ program, and a description of test runs, and the corresponding results.
  - If you use a file in testing, print and submit the contents of the file.

created Fall, 2023 revised Fall, 2023 revised October, 2025
For more information, please contact Henry M. Walker at walker@cs.grinnell.edu.

Copyright © 2011-2026 by Henry M. Walker.
Selected materials copyright by Marge Coahran, Samuel A. Rebelsky, John David Stone, and Henry Walker and used by permission.
This page and other materials developed for this course are under development.
This and all laboratory exercises for this course are licensed under a Creative Commons Attribution-NonCommercial-Share Alike 4.0 International License.