extract firstChar, restOfWord

if firstChar is a vowel,

pigWord = word + "way"

otherwise

pigWord = restOfWord + firstChar + "ay"

end if

end foreach loop

end while loop

This pseudocode is extremely useful because it provides a blueprint for finishing the program. Implementing the program simply requires fleshing out the pseudocode with C# code. Notice that I still use English−like phrases, such as user has not said "quit". As long as you have an idea how to translate the pseudocode into actual code, using a form of English is fine. However, you often find that you don’t know exactly how to proceed on a particular piece of your code. For example, how do you write code to determine whether a certain letter is a vowel? You can do this a number of ways, for example, by using the switch structure and a series of else if clauses. Later, I’ll show you another strategy that’s more compact. When a part of your algorithm is not ready to implement, you can apply the STAIR process again to that smaller piece of the problem until you are satisfied that you will be able to implement the algorithm.

Implementing and Refining

The implementation and refinement steps aren’t really a part of the program−planning process. The implementation is the actual code, which you will see in the next section. Refinement is an ongoing process, so I’ll show you how I had to refine the plan as I wrote the actual code.

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

74

/// </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.

75

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}\t", word); //Console.Write("{0}\t", firstLetter); //Console.Write("{0}\t", restOfWord); //Console.Write("{0}\t", letterPos); //Console.WriteLine("{0}", pigWord);

76