nFoundOne = 0;
while (nFoundOne == 0)
{
     nIndex = (int) GetRandomNumber(0, nLetteredTiles - 1);
     if (nDiscardTilesOnceChosen == 0)
     {
	// Doesn't matter if the tile has been 
	// chosen previously because selected
	// tiles are placed back into the urn.
	nFoundOne = 1;
     }
     else if (cUrn[nIndex][2] == 'T')
     {
	// This tile has already been chosen and
	// discarded: it can't be selected again.
	nFoundOne = 0;
     }
     else if (cUrn[nIndex][2] == 'F')
     {
	// This tile has not been chosen previously.
	nFoundOne = 1;
     }
}

[0, 0]	[0, 1]	[0, 2]
[1, 0]	[1, 1]	[1, 2]
[2, 0]	[2, 1]	[2, 2]
[3, 0]	[3, 1]	[3, 2]
[4, 0]	[4, 1]	[4, 2]
[5, 0]	[5, 1]	[5, 2]
[6, 0]	[6, 1]	[6, 2]
[7, 0]	[7, 1]	[7, 2]
[8, 0]	[8, 1]	[8, 2]

for (int row = 0; row < 9; ++row)
{
	for (int col = 0; col < 3; ++col)
	{
		cout << myArray[row][col] << endl;
	}
}

for (int index = 0; index < 27; ++index)
{
	cout << *(myArray + index) << endl;
}

// backwards.cpp
// Tests a stack implemented using a doubly linked list.

#include <iostream>

using std::cin;
using std::cout;
using std::endl;

#include "Stack.h"

int main()
{
	char userInput[80], singleChar;
	int lcv = 0;

	Stack myStack;

	cout << "Enter some text: ";
	cin.getline(userInput, 80, '\n');

	// push characters one at a time onto the stack
	while (userInput[lcv]) myStack.Push(userInput[lcv++]);

	cout << endl;

	// pop characters one at a time off of the stack
	while (singleChar = myStack.Pop()) cout << singleChar;

	cout << endl;

	return 0;
}

// Stack.h

#ifndef STACK_H
#define STACK_H

#include "Node.h"

class Stack 
{
	private:
		Node *ptrFirstNode;
		Node *ptrLastNode;

	public:
		Stack();
		~Stack();

		void Push(char letter);
		char Pop();

		Node * GetFirstNode();
		void SetFirstNode(Node *pFirst);
		
		Node * GetLastNode();
		void SetLastNode(Node *pLast);
};

#endif

// Stack.cpp


#include "Stack.h"


Stack::Stack()
{
	SetFirstNode(0);
	SetLastNode(0);
}


Stack::~Stack()
{
	char singleChar;
	while (singleChar = Pop()) ;
}
	
	
void Stack::Push(char letter)
{
	Node *ptrNewest = new Node(letter);

	if (!GetFirstNode())
	{
		// Pushing first item onto the stack.
		SetFirstNode(ptrNewest);

		// There is only 1 item on the stack so it 
		// is both the first and the last item.
		SetLastNode(ptrNewest);
	}
	else
	{
		// Pushing item #2 or higher onto the stack.
		// First, create the back link from the newest 
		// node to its previous one.
		Node *ptrWasLastNode = GetLastNode();	
		ptrNewest->SetPrev(ptrWasLastNode);

		// Assign the Newest Node's pointer to what 
		// was the LastNode's Next pointer.
		ptrWasLastNode->SetNext(ptrNewest);
		
		// Point the LastNode pointer to the Newest Node
		// making it the last node in the series.
		SetLastNode(ptrNewest);
	}
}


char Stack::Pop()
{
	Node *pLastNode = GetLastNode();

	if (!pLastNode)
		// Stack is empty
		return 0;

	// Before deleting LastNode, save its data 
	// for returning
	char Letter = pLastNode->GetLetter();

	
	// NextToLastNode is needed to reassign LastNode 
	// once what is currently the LastNode is deleted
	// (since it is being popped off the stack).
	// If the current LastNode is the first node, 
	// then NextToLastNode will be NULL since the 
	// first node doesn't have a previous Node.
	Node *ptrNextToLastNode = pLastNode->GetPrev();

	// Delete the current LastNode.
	// Remember, if the first item is being popped, 
	// then ptrNextToLastNode will be NULL.
	if (!ptrNextToLastNode)
	{
		delete pLastNode;
		SetLastNode(0);
		SetFirstNode(0);
	}
	else
	{
		delete pLastNode;
		// Reassign LastNode since what was the 
		// LastNode is now gone.
		SetLastNode(ptrNextToLastNode);
	}

	return Letter;
}


void Stack::SetFirstNode(Node * pFirst)
{
	ptrFirstNode = pFirst;
}


void Stack::SetLastNode(Node * pLast)
{
	ptrLastNode = pLast;
}


Node * Stack::GetFirstNode()
{
	return ptrFirstNode;
}


Node * Stack::GetLastNode()
{
	return ptrLastNode;
}

// Node.h

#ifndef NODE_H
#define NODE_H

class Node
{
	private:
		char letter;

		Node *ptrNext;
		Node *ptrPrev;

	public:
		Node(char Letter);
		
		void SetLetter(char Letter);
		char GetLetter();
	
		Node * GetNext();
		void SetNext(Node *pNext);

		Node * GetPrev();
		void SetPrev(Node *pPrev);
};

#endif

// Node.cpp

#include "Node.h"

Node::Node(char Letter)
{
	SetLetter(Letter);
	SetPrev(0);
	SetNext(0);
}


void Node::SetLetter(char Letter)
{ 
	letter = Letter;
}


char Node::GetLetter() 
{
	return letter;
}

	
Node * Node::GetNext() 
{ 
	return ptrNext;
}


void Node::SetNext(Node *pNext) 
{ 
	ptrNext = pNext;
}


Node * Node::GetPrev() 
{ 
	return ptrPrev;
}


void Node::SetPrev(Node *pPrev) 
{ 
	ptrPrev = pPrev;
}