Writing the Pig Latin Program

The STAIR process led to the development of some pseudocode. Now you have a solid plan, and you know which types of objects, variables, and code structures you will need. It will be relatively simple to translate this plan into a working program.

Setting Up the Variables

With the plan in place, it was easy to figure out a starting point. I did all the normal startup steps and created variables:

using System;

namespace PigLatin
{
   /// <summary>
   /// Pig Latin interpreter
   /// Demonstrate loops, string methods
   /// Andy Harris, 11/16/01 
   /// </summary> 
class Pig
{
  static void Main(string[] args)
  {
    string pigWord = "";
    string sentence = "";
    string firstLetter;
    string restOfWord;
    string vowels = "AEIOUaeiou";
     int letterPos;

The program features several useful variables. The pigWord variable holds each word after it is converted to pig latin. The sentence variable holds the entire original phrase as it comes from the user. The firstLetter variable is used to hold the (surprise!) first letter of each word. The restOfWord variable holds all the other letters in the word. The vowels variable is sneaky. I’ll use it to see whether the first letter is a vowel. I had a word variable listed in the algorithm, but it will be created in the section on breaking the sentence into words as part of a foreach structure. The foreach loop requires that you create a variable, so I’ll simply create word as part of that structure. Also, I didn’t know at first that I needed a letterPos variable, but I added it during refinement. I’ll show you how it was used in just a second.

Creating the Outside Loop

The STAIR analysis of this program makes it clear that the program requires two kinds of loops. First, you need a loop to ask for a phrase. That loop will occur every time the user is asked for a new phrase. If the user types quit, the program should exit.

while (sentence.ToLower() != "quit"){
         Console.WriteLine("Please enter a sentence (or type "quit" 
to exit)");
         sentence = Console.ReadLine();

The main loop is a simple while loop. It checks whether sentence is equal to "quit". As long as the sentence variable is anything but "quit", the program continues. Notice that sentence is initialized to the empty value (""), which is not quit, so the loop is guaranteed to run at least one time. Also note that I use the ToLower() method to convert whatever the user enters into lowercase. This way, "QUIT", "qUit", and "Quit" will be read as quit and cause the program to exit. Add this kind of feature whenever you can.

I then ask the user for a sentence. The sentence variable gets a new value from the screen. Telling the user how to exit is very important. If you don’t tell users to type quit, they might never guess, and your program would effectively have no end. The sentry variable for this loop is sentence. It is properly initialized, the condition is well conceived, and it has a mechanism for changing the sentry so that the loop can exit. This appears to be a well designed loop.

Dividing the Phrase into Words

The Pig Latin program must act independently on each word in the sentence. You have seen a tool (the foreach loop with the String.Split() method) that performs exactly this function:

foreach (string word in sentence.Split())

This code sets up another loop, which will repeat one time for each word in the sentence. Each time through the loop, the variable word will contain the value of the current word.

Extracting the First Character

When you are trying to determine tools in an object-oriented language such as C#, start by examining the objects you have on hand. Because the Pig Latin program manipulates strings, it isn’t surprising that it uses a number of methods of the string object. I wanted to find a method that lets me extract a substring from a string, and I found it in the String.SubString() method:

firstLetter = word.Substring(0,1);
restOfWord = word.Substring(1, word.Length -1);

The string manipulation methods came in handy here. The first letter of the word is a substring of the word starting at character 0 and is one character long. Don’t forget, computers often begin counting at 0, so the front character of the string is character 0, not 1. For the rest of the word, you need another substring that starts at character 1 and is one less than the total number of words in the string. You can use the Length property to determine how long a string is.

Checking for a Vowel

You can use an if…else if structure to check for a vowel, but this can be tedious, especially if you want to check for uppercase and lowercase values. Instead, I employ the String.indexOf() method as a sneaky way to determine whether the word begins with a vowel:

        letterPos = vowels.IndexOf(firstLetter);
        if (letterPos == -1)
{

          //it's a consonant
          pigWord = restOfWord + firstLetter + "ay";
        } else {
          //it's a vowel
          pigWord = word + "way";
        } // end if

        Console.Write("{0} ", pigWord);

I check to see where firstLetter occurs within the vowels string. If firstLetter is not in vowels, the IndexOf() method returns a –1, and firstLetter is a consonant. If letterPos is anything but –1, firstLetter is a vowel. I then write out the new word to the console.

Adding Debugging Code

While I was working on the program, I made some mistakes in my logic. I added a few lines that explicitly pointed out the value of various variables so I could clearly see where my logic was flawed. When I had the program working correctly, I added comments to these code lines because if I ever come back to repair this program (say, to deal with blends like sh and th), I will probably want access to these debugging codes again:

 
//debugging code 
//Console.Write("{0}	", word); 
//Console.Write("{0}	", firstLetter); 
//Console.Write("{0}	", restOfWord); 
//Console.Write("{0}	", letterPos); 
//Console.WriteLine("{0}", pigWord); 

Closing Up the code

This program has a number of structures embedded inside each other. Ensuring that all the code ends properly can be very difficult if you aren’t careful about indentation and comments. However, I was careful about these things, so closing up all the code was a straightforward job:

        } // end foreach
      } // end while loop
    } // end main
  } // end class
} // end namespace