– the number of states (i.e. ||)(the states are numbered from 0 to || – 1)
– the number of final states (i.e. ||)
– the number of final symbols in (i.e. ||)
– || numbers, the final states
– || characters (any white space char is significant, standing exactly for itself, so there will not be multiple spaces in this list)
– the transition table, given as a array of numbers.

If you have the basic concept of what DFA is, let’s then get started. Firstly, we have to understand that DFA is a model or a template for a specific string processing “machine”, thus we do not change the code to adjust the needs for a specific programme, we change the matrix (the ) aka transition table that allows the DFA to determine its validity.

So, firstly, we need to scan in the necessary data listed at the top of this article. Allow me to take Jim’s example with notation aside.

Example 1

Here is a visualized graph on DFA for determining odd number of 1’s in a binary input. As long as the 1’s are odd, the input is accepted.

Graphed like this:

The transition table is correspondingly this:

2      //the number of states ()
1      //the number of final states, we have only 1 final state here.
2      //the number of final symbols in 
1      //the final state is . If DFA ends here, then the input is valid.
01   //the valid characters in symbols.
0 1
1 0  //those 2 lines are the transition table, meaning and .

Let’s give out an input stream sample: 010000011

The initial state is . 0 goes in, it looks for coordinate , the result is still .

Current state is , then 1 goes in, it looks for . State is changed to .

Then five 0s goes in, the state is locked to based on what the transition table says.

Then 1 goes in, state is now .

Finally the last 1 is passed in, state is changed to .

EOF

The DFA stopped with a state at , because only is valid, in this case, is valid, so the input is valid.

Example 2

The visual graph is like this:

 and the transition table is like this:

The input for building DFA will be like this:

6
3
3
2 3 4
abc
2 1 1
1 1 1
5 3 4
5 3 5
5 5 4
5 5 5

Similarly, there are 6 states, from 0~5. 3 final states, they are . There are 3 characters accepted, which are , and the matrix map.

How to write this programme?

Well firstly we need to read the data in and build a matrix. Then we need to move around the matrix table and get its state, and finally compare the state to the final states.

The code is relatively simple:

#include 
#include 
#include 

#define N_ASCII 256
#define ACCEPT 200

int
dfa(int nstate, int nfinal, int nsymbol)
{
    int i, j, c, state = 0;
    int final[nfinal];
    int symbol[N_ASCII] = {0}, acceptable_chars[N_ASCII] = {0};
    int matrix[nstate][nsymbol];
    
    /* Buidling up the DFA */

    /* Scanning the final states */
    for (i = 0; i < nfinal; i++)
    {
        scanf("%d", &final[i]);
    }
    scanf("%*[*^\n]\n");

    /*
     * Scan in the chars that are accepted by DFA, allocate its tag from 0 to
     * 1 in symbol[c].
     */
    for (i = 0; i < nsymbol; i++)
    {
        c = getchar();
        symbol[c] = i;
        acceptable_chars[c] = ACCEPT;
    }
    scanf("%*[*^\n]\n");

    /* Scan in the \delta transition table */
    for (i = 0; i < nstate; i++)
    {
        for (j = 0; j < nsymbol; j++)
        {
            scanf("%d", &matrix[i][j]);
        }
    }
    scanf("%*[*^\n]\n");

    /* 
     * Test the input steam
     * We'll stop at either EOF or \n
     */
    bool empty = true;
    while ((c = getchar()) != EOF && c != '\n')
    {
        if (!(acceptable_chars[c] == ACCEPT))
        {
            fprintf(stderr, "/%c/ char is not in the symbol list!\n" 
                    "Because your number of symbols is %d " 
                    "and there is a %dth.\n", c, nsymbol, nsymbol + 1);
            return -1;
        }

        /* 
         * Inside the matrix we move around based on the char's nth number,
         * until the last getchar().
         */
        state = matrix[state][symbol[c]];
        empty = false;
    }

    if (empty == true)
    {
        fprintf(stderr, "No test input detected!\n");
        return -1;
    }

    for (i = 0; i < nfinal; i++)
    {
        /* 
         * Then we check the final state, if it's a match with any of the 
         * elements inside of |F|
         */
        if(state == final[i])
        {
            return 1;
        }
    }

    return 0;
}

int
main(int argc, char *argv[])
{
    int nstate, nfinal, nsymbol, ret;
    ret = scanf("%d\n", &nstate);
    if (ret != 1)
    {
        fprintf(stderr, "No. of states is invalid!\n");
        return EXIT_FAILURE;
    }
    ret = scanf("%d\n", &nfinal);
    if (ret != 1)
    {
        fprintf(stderr, "No. of finals is invalid!\n");
        return EXIT_FAILURE;
    }
    ret = scanf("%d\n", &nsymbol);
    if (ret != 1)
    {
        fprintf(stderr, "No. of symbols is invalid!\n");
        return EXIT_FAILURE;
    }
    ret = dfa(nstate, nfinal, nsymbol);

    if (ret == 0)
    {
        printf("Not accepted.\n");
    }
    else if (ret == -1)
    {
        fprintf(stderr, "Invalid input.\n");
        return EXIT_FAILURE;
    }
    else
        printf("Accepted.\n");

    return EXIT_SUCCESS;
}

This has to be compiled using -std=c99 flag in gcc.

When I wrote this program, I did not consider '\n' as a valid element of set .

#include 
#include 
#include 

int
main(int argc, char *argv[])
{
    char c;
    short int failed = 0;
    int min = 0, sec = 0, total_min = 0, total_sec = 0,
        line = 0, wrong = 0, char_count = 0;
    printf("Enter a sequence of times, end with 0:00 or EOF.\n");

    while (wrong < 2)
    {
        /* MM:SS, This part checks the MM part. */
        c = getchar();
        if (!isdigit(c) && c != EOF)
        {
            printf("Invalid song time!\n");
            if (failed == 1)
                wrong++;
            else
                failed = 1;
            for (;;)
            {
                if (c == '\n')
                    break;
                c = getchar();
            }
            continue;
        }
        else if (c == EOF)
        {
            break;
        }
        else
            ungetc(c, stdin);
        scanf("%d", &min);

        /* The : part. */
        c = getchar();
        if (c != ':')
        {
            fprintf(stderr,"Invalid song time!\n");
            if (failed == 1)
                wrong++;
            else
                failed = 1;
            for (;;)
            {
                if (c == '\n')
                    break;
                c = getchar();
            }
            continue;
        }

        /* Now the SS part. */
        c = getchar();
        if (!isdigit(c))
        {
            fprintf(stderr, "Invalid song time!\n");
            if (failed == 1)
                wrong++;
            else
                failed = 1;
            for (;;)
            {
                if (c == '\n')
                    break;
                c = getchar();
            }
            continue;
        }
        else
            ungetc(c, stdin);
        scanf("%d%n", &sec, &char_count);
        if (char_count > 2)
        {
            fprintf(stderr, "You've input more than 2 character's" 
                    " length in seconds.\n");
            char_count = 0;
        }

        if ((c = getchar()) == ':')
        {
            fprintf(stderr, "Make sure you do not have an hour!\n");
            if (failed == 1)
                wrong++;
            else
                failed = 1;
            for (;;)
            {
                if (c == '\n')
                    break;
                c = getchar();
            }
            continue;
        }
        /* Check and verify the next lines */
        for (;;)
        {
            if (c == '\n')
                break;
            c = getchar();
        }

        /* Minutes validation part */
        if (sec > 60)
        {
            fprintf(stderr, "Invalid song time!\n");
            if (failed == 1)
                wrong++;
            else
                failed = 1;
            for (;;)
            {
                if (c == '\n')
                    break;
                c = getchar();
            }
            continue;
        }

        if (sec == 0 && min == 0)
            break;


        total_sec += sec;
        total_min += min;
        line++;
        wrong = 0;
    }

    if (wrong > 1)
    {
        fprintf(stderr, "Three invalid song times in a row; I'm quitting!\n");
        return EXIT_FAILURE;
    }

    fprintf(stdout, "There were %d valid song times.\n", line);
    if (total_sec > 60)
    {
        total_min += total_sec / 60;
        total_sec = total_sec % 60;
    }
    fprintf(stdout, "The total times is %d:%.2d\n", total_min, total_sec);

    return EXIT_SUCCESS;
}

Please feel free to critisize the coding if you have a better solution.

For thoses who don’t know what a5p1 means, it means Assignment 5, Problem 1.

Yesterday, my professor Jim added a new assignment for us to do. I am going to talk about the first in this article.

I am not a good coder and I just started learning C this term. Still, I am trying to solve the puzzle as best I can. I know it is not a good style to put everything under main(), but since it’s a simple and straightforward problem, please accept my messy style of coding.

You can view the question here. I started writing the first problem this morning and I think I have finished this problem at the noon. (Just before the time I was writing this article.)

If you get a 404 error, that means this term has finished, you can get the problem sets by emailing me.

Things need attention:

1. I need to justify what format the input/output is:

input:
N
Year(%d) Month(%s) Day(%d)
....

output:
Year(%d) Month(%d) Day(%s)

I happened to mixed the order up during programming, but it wasn’t a big deal.

2. It’s important to know that the Highwings calendar count from 0 in day section but Lowwings calendar count start from 1 in month section.

3. Those calendar systems have different days per year. Highwings has days per year and Lowwings has days per year, we can write a macro for further use.

#define TOTAL_DAYS_PERYR_HIGHWING (12 * 30 + 20)
#define TOTAL_DAYS_PERYR_LOWWING (20 * 12)

The structure is simple, parse every line until N is reached using a for loop. Using getchar and scanf to read the values from stdin, assign it to corresponding values. Professor has already talked about this in a3p1, we can extract his ideas and implement them into our code.

Why we don’t just parse the whole line all-together using

 scanf("%d %s %D\n", &h_yr, &h_m, &h_d)

You’ll never know what the user is going to type in, therefore the stdin might not be what you expected. This is for error checking which I’ll talk about it later.

When you have all the correct values assigned to correct variables, then how to convert it to Lowwings Calendar system?

What I did was to find the total days, it should be the only thing in common between these 2 systems of calendar, I call the variable unify_day.

Now things are getting clearer.

In this case,

1 charlie 17

charlie is the month in Year 1, but the month has not passed, so we only need to count the first 2 months into unify_day, then calculate the day/month/year in Lowwings system.

Finally you need to reset unify_day to 0 at the end of loop.

When you try to divide a number with 12, and if the remainder is 0, it doesn’t mean that it’s the start of next month, it’s the end of the previous month. So I have put zulu first in my string array.

*lowwing_day_names[] = {"zulu", "november", "oscar", "papa", "quebec",
        "romeo", "sierra", "tango", "uniform", "victor", "whiskey", "xray"};

The error detect part, which types of error have I considered?

(a). When N = 0.
(b). When N < next few lines. (When N > next few lines I just ignore the rest)
(c). Invalid data:
   i. When !isdigit(N)
   ii. !isdigit(h_day)
   iii. !isdigit(h_yr)
(d). spaces/tabs as seperator.

Programme ends whenever an error occurs.

/*
 * File:    lightplane.c
 * Author:  Luxing Huang
 * Version: 1.0
 *
 * Purpose:
 * When we have 2 different calendar systems, we need to translate the old one
 * to the new one. 
 *
 * Here we have an old system called Highwings: A year with 13 month, 30 days 
 * for the 1-12th month, and 20 days for the 13th month. We will have 30x12+20
 * = 380 days a year. Every month has its own name.
 *
 * And the second system is 240 days a year. We have 20 months with 12 days in
 * each month. Every day in each month has its own name. This system is called
 * Lowwings.
 *
 * The input format is:
 * N
 * Year(%d) Month(%s) Day(%d)
 *
 * The output format is:
 * Year(%d) Month(%d) Day(%s)
 */
#include 
#include 
#include 
#include 

#define CHAR_LENGTH 128
#define TOTAL_DAYS_PERYR_HIGHWING (12 * 30 + 20)
#define TOTAL_DAYS_PERYR_LOWWING (20 * 12)

int
main(int argc, char *argv[])
{
    /*
     * Structure:
     * 1. scan the input, preferrably using getchar then scanf
     * 2. Convert Highwing days to unify_day.
     * 3. Error detect:
     *  a. N < next a few lines. If > I just ignore the rest.
     *  b. Invalid data:
     *      (a) when it should be a number, it's a char.
     *      (b) after year we have more char rather than \n.
     * 4. Calculate the unify day to Lowwing system.
     */
    unsigned int i, unify_day = 0, highwing_year = 0, highwing_day = 0, 
                 lowwing_year = 0, lowwing_month = 0, lowwing_day = 0;
    int highwing_month = -1, entries = 0, c = 0;
    char highwing_month_name[CHAR_LENGTH] = "";
    char *highwing_compare[] = {"alpha", "bravo", "charlie", "delta", "echo", 
        "foxtrot", "golf", "hotel", "india", "juliet", "kilo", "lima", "mike"},
         *lowwing_day_names[] = {"zulu", "november", "oscar", "papa", "quebec", 
        "romeo", "sierra", "tango", "uniform", "victor", "whiskey", "xray"};
    
    /* Ignoring spaces if have any */
    scanf("%*[ \t]");

    /* check if is a digit */
    c = getchar();
    if (!isdigit(c))
    {
        fprintf(stderr, "You need to put a positive integer in the first " 
                "line!\n");
        return EXIT_FAILURE;
    }
    else
        ungetc(c, stdin);

    scanf("%d", &entries);
    if (entries <= 0)
    {
        fprintf(stdout, "Nothing to calculate!\n");
        return EXIT_SUCCESS;
    }
    else
    {
        /* 
         * Error detect for:
         * N more_char_here
         */
        scanf("%*[ \t]");
        c = getchar();
        if (c == EOF)
        {
            fprintf(stderr, "Where are your next lines?\n");
            return EXIT_FAILURE;
        }
        else if (c != '\n')
        {
            fprintf(stderr, "You should not input anything "
                            "behind %d!\n", entries);
            return EXIT_FAILURE;
        }

        /* We need to have a loop for entries time */
        for (i = 0; i < entries; i++)
        {
            /* We get year first, ignoring spaces */
            scanf("%*[ \t]");
            c = getchar();
            if (c == EOF)
            {
                fprintf(stderr, "Where's the %d(th) set of data?\n", i+1);
                return EXIT_FAILURE;
            }
            else if (!isdigit(c))
            {
                fprintf(stderr, "This is not a valid day!\n");
                return EXIT_FAILURE;
            }
            ungetc(c, stdin);
            scanf("%d", &highwing_year);

            /* Now the name (string) for highwing month */
            int m;
            c = getchar();
            if (c != ' ' && c != '\t')
                fprintf(stderr, "Your input format is wrong but we'll " 
                        "proceed anyway.\n");
            scanf("%*[ \t]");

            scanf("%s", highwing_month_name);
            for (m = 0; m <= 13; m++)
            {
                if (strcmp(highwing_month_name, highwing_compare[m]) == 0)
                {
                    /* Array of strings position start from 0 */
                    highwing_month = m;
                    break;
                }
            }
            if (highwing_month == -1)
            {
                fprintf(stderr, "Invalid month name.\n");
                return EXIT_FAILURE;
            }

            /* 
             * Let's now scan the day
             * First we need to make sure that the first character is a digit.
             */
            c = getchar();
            if (c != ' ' && c != '\t')
                fprintf(stderr, "Your input format is wrong but we'll "
                        "proceed anyway.\n");

            scanf("%*[ \t]");
            c = getchar();
            if (!isdigit(c))
            {
                fprintf(stderr, "Invalid input!\n");
                return EXIT_FAILURE;
            }
            else
                ungetc(c, stdin);

            scanf("%d", &highwing_day);

            if (highwing_day > 29)
            {
                fprintf(stderr, "You shouldn't input more than 30 days!\n");
                return EXIT_FAILURE;
            }
            highwing_day++;

            /* 
             * We need to make sure about the boundary values, 
             * In this case, the last day of mike is 20th
             */
            if (highwing_month == 12 && highwing_day > 20)
            {
                fprintf(stderr, "You cannot input 20 or more in day in " 
                        "Mike!\n");
                return EXIT_FAILURE;
            }

            /* ignoreing the spaces afterwards */
            scanf("%*[ \t]");

            /* Make sure that we have a nextline in the end */
            c = getchar();
            if (!(c == '\n'))
            {
                fprintf(stderr, "Nothing behind %d please!", highwing_day);
                return EXIT_FAILURE;
            }
            /* 
             * Once it is all done, we add the current inputs to unify_day.
             * Every Highwing month has 30 days except the last one.
             */
            unify_day = highwing_year * TOTAL_DAYS_PERYR_HIGHWING + highwing_month * 30
                        + highwing_day;

            /* 
             * From unify_day we need to calculate the year for Lowwing calendar
             */
            lowwing_year = unify_day / TOTAL_DAYS_PERYR_LOWWING;
            unify_day -= lowwing_year * TOTAL_DAYS_PERYR_LOWWING;

            /* We need to have lowwing_month at this point. */
            lowwing_month = unify_day / 12;
            unify_day -= lowwing_month * 12;

            if ((unify_day % 12) == 0)
                lowwing_month--;

            /* Now the day */
            lowwing_day = unify_day;

            printf("Highwings %d %s %d\t is\t Lowwings %d %d %s\n", 
                    highwing_year, highwing_month_name, highwing_day - 1,
                    lowwing_year, lowwing_month + 1, 
                    lowwing_day_names[lowwing_day]);
            
            /* Reset all the values which won't be re-assigned from stdin. */
            unify_day = 0;
        }
    }

    return EXIT_SUCCESS;
}