Deliverable - Farmer Wolf Goat Cabbage

P a g e | 6

COVER/TITLE PAGE

Farmer, Wolf, Goat, Cabbage.

A C++ Programming Project

Submitted to the Faculty

Of

COP1000-70T

Eastern Florida State College

By

ME

In Partial Fulfillment of the Requirements

For the Course of

COP1000-70T Principles of Programming

May 2014

Titusville, Florida

P a g e | 7

Table of Contents: . . . . . . . 1

Time Log . . . . . . . . . . 2

Abstract of Program . . . . . . . . 3

Program’s Problem and Solution . . . . . . 4

Flow Chart . . . . . . . . . 6

List of Functions . . . . . . . . . 8

List of Preprocessor Commands/Header Files,

and Libraries used . . . . . . . . 8

List of Variables . . . . . . . . . 8

Source Code . . . . . . . . . 9

P a g e | 8

Screen Shot of Executed Program . . . . . . 14

P a g e | 9

Time Log

The project “Farmer Wolf Goat Cabbage” was started on February 3rd, 2014. During this initial process, I came up with

Algorithms and Flowcharts for the program. After flow charting and writing some pseudo code, the programming of the C++

programming commenced.

On April 22nd

, the source code and commenting was completed, and the final build of the project was completed on May 2nd,

2014.

The program was exhibited on April 30th

to Professor Canton-Sanchez, M. for review.

Professor Canton-Sanchez asked for the code to be commented further, these modifications were implemented on the evening

of April 30th

.

During this process I made myself available to help other students along with their projects.

The total number of man hours spent on this was around 16hrs.

P a g e | 10

Abstract

The program “Farmer, Wolf, Goat, Cabbage” is a classic computer program assigned to begging programmers to get them used to thinking

logically and to expose the students to how really dumb a computer is and how it is necessary to give them every single instruction.

This program does not take any user input and starts with the boat the farmer, wolf , goat cabbage sitting on the West shore of a river.

The program is run from a while loop in the main function where it will run until all items are moved from the West shore of the river to

the East shore of the river.

The criteria set up for this trip across the river were that, the wolf and the goat could not be left alone together, and the goat and the

cabbage could not be left alone.

The program verifies the coasts are safe before taking the next item across the river.

P a g e | 11

Problem and Solution

Question: How to move items safely across the river and only allow one item to be moved at a time?

This is done by moving the goat to the East side of the river first, leaving the wolf and the cabbage alone, since the wolf won’t eat

the cabbage the shoreline is considered safe.

The farmer then rows the boat back alone to the west shore to get the cabbage and rows back to the East shore where he must pick up the

goat as not to leave the goat alone with the cabbage because the goat will eat the cabbage.

After picking up the goat from the East shore the farmer rows the boat back to the east shore to drop off the goat and pickup the

wolf, then row it back to the East shore to drop the wolf

Off alone with the cabbage.

The farmer rows back to the West shore alone to pick up the cabbage and row it back to the East shore completing the task.

The Pseudo code is as follows:

Load the boat with goat at the West shore.

Cross the river.

Unload the goat from the boat

P a g e | 12

Cross the river.

Load the boat with the cabbage

Cross the River.

Unload the cabbage and load the goat.

Cross the river with goat.

Unload the goat and load the wolf into the boat.

Cross the river.

Unload the wolf from the boat.

Cross River alone.

Load the boat with the goat.

Cross River

Unload the goat.

End Loop

End Program.

P a g e | 13

While Loop

Load Boat

End While

Cross River

Unload Boat

Cross River

Is West shore

safe?

Yes

No

Is the East

shore safe?

Yes

End Program

No

P a g e | 8

Lists:

Functions:

int main()

int loadboat(void);// Loads the boat

int crossriver(void);// crosses river

int unloadboat(void);// unloads the boat

int iscompatable(void);// determines if the food chain is safe

Header Files and Libraries:

#include "stdafx.h"

#include<iostream>

#include<math.h>

#include<string>

#include<ostream>

using namespace std;

Variables:

///// Defines the food chain /////

#define cabbage 1

#define goat 2

#define wolf 3

#define farmer 4

//////// Defines the load unload locations

#define boatwest 1

#define boateast 2

int boat[2];// Holds the farmer and the cargo

int westshore[4];// holds the cargo on the west shore

int eastshore[4];// holds the cargo on the east shore

int boatlocation;// holds the east west location of the boat

std::string cargo;

int good = 0;

int lastitem = boat[0];

P a g e | 9

// FarmerWolfGoatCabbage.cpp : Defines the entry point for the console

application.

// Program Name: Farmer, Wolf, Goat, Cabbage

// Description:

// This program solves the classic Farmer, Wolf, Goat, Cabbage problem.

// The program will load the boat then determine if the shorelone

// is safe, before embarking on it's journey to the other side of the river

// the program will then unload the boat and ensure the shoreline is safe.

// The main loop contains only the logic required to ensure the boat

// initiates a loading, crossing and unloading function and exiting

// when all the items are moved safely accross the river.

// Developer: Anthony Olive

// Date: 5/4/14

// Development Environment: Microsoft Visual Studio 2013

// food chain:

// goat eats cabbage

// wolf eats goat

#include "stdafx.h"

#include<iostream>

#include<math.h>

#include<string>

#include<ostream>

///// Defines the food chain /////

#define cabbage 1

#define goat 2

#define wolf 3

#define farmer 4

//////// Defines the load unload locations

#define boatwest 1

#define boateast 2

int loadboat(void);// Loads the boat

int crossriver(void);// crosses river

int unloadboat(void);// unloads the boat

int iscompatable(void);// determines if the food chain is safe

int boat[2];// Holds the farmer and the cargo

int westshore[4];// holds the cargo on the west shore

int eastshore[4];// holds the cargo on the east shore

int boatlocation;// holds the east west location of the boat

using namespace std;

void main()

{

boat[1] = farmer; // Place the farmer in the boat

boatlocation = boatwest; // starts the boat on the west bank

westshore[0] = cabbage; // starts the cabbage on the west bank

P a g e | 10

westshore[1] = goat; // starts the goat on the west bank

westshore[2] = wolf; // starts the wolf on the west bank

// sets the east bank to nothing

eastshore[0] = 0;

eastshore[1] = 0;

eastshore[2] = 0;

// Main loop runs until the west shore is empty

while (westshore[0] != 0 || westshore[1] != 0 || westshore[2] != 0)

{

boat[0] = loadboat();

boatlocation = crossriver();

boat[0] = unloadboat();

boatlocation = crossriver();

}

cout << "All cargo moved and everyone survived!" << endl;

system("pause");

}

////////////////////////////////////////////////////////////

/////////////////////// Load the boat //////////////////////

////////////////////////////////////////////////////////////

// This function will load the items onto the boat.

// but first it checks to see if it already has cargo, if

// it does have cargo it will unload that cargo first

// call the iscompatable() function to see if the shoreline

// is safe, if the shoreline is not safe it unloads the

// current item then loads the next item and repeats the

// safety check until a safe shoreline is obtained.

//

int loadboat(void)

{

std::string cargo;

int good = 0;


//////// if the boat has something in it unload the boat ////////////

if (boat[0] != 0)

{

boat[0] = unloadboat();

}

/////// If the boat is on the west Shore ///////////////////

if (boatlocation == boatwest)

{

// check to see if the west shore cabbage location is empty

if (westshore[0] == cabbage && boat[0] == 0)

{

boat[0] = cabbage;

westshore[0] = 0;

cout << "loading cabbage" << endl;

good = iscompatable();

// if the shore is not compatible unload cabbage

if (good != 1)

{

P a g e | 11

cout << "unloading cabbage" << endl;

boat[0] = 0;

westshore[0] = cabbage;

}

}

// check to see if the west shore goat location is empty

// and the last item is not the goat

if (westshore[1] == goat && boat[0] == 0 && lastitem != goat)

{

boat[0] = goat;

westshore[1] = 0;

cout << "loading goat" << endl;


if (good != 1)

{


boat[0] = 0;

westshore[1] = goat;

}

}

// check to see if the west shore wolf location is empty

if (westshore[2] == wolf && boat[0] == 0)

{

boat[0] = wolf;

westshore[2] = 0;

cout << "loading wolf" << endl;


if (good != 1)

{

cout << "unloading wolf" << endl;

boat[0] = 0;

westshore[2] = wolf;

}

}

}

/////////// End West

////////// If the boat is on the East Bank /////////////////

if (boatlocation == boateast)

{

if (eastshore[2] == wolf && boat[0] == 0)

{

boat[0] = wolf;

eastshore[2] = 0;


if (good != 1)

{

boat[0] = 0;

eastshore[2] = wolf;

}

}

if (eastshore[1] == goat && boat[0] == 0)

P a g e | 12

{

boat[0] = goat;

eastshore[1] = 0;


if (good != 1)

{

boat[0] = 0;

eastshore[1] = goat;

}

}

}

///////// End East

switch (boat[0])

{

case cabbage:

cargo = "cabbage";

break;

case goat:

cargo = "goat";

break;

case wolf:

cargo = "wolf";

break;

case 0:

cargo = "nothing";

break;

default:

cargo = "unknown";

break;

}

cout << "Loading Boat with " << cargo << endl;

return boat[0];

}

////////////////////////////////////////////////////////////

/////////////////////// cross the river/////////////////////

////////////////////////////////////////////////////////////

// This function sets the location of the boat on opposite

// shore after crossing

int crossriver(void)

{

std::string cargo;

//cout << " Crossing the River" << endl;

switch (boat[0])

{

case cabbage:

cargo = "cabbage";

break;

case goat:

cargo = "goat";

break;

case wolf:

P a g e | 13

cargo = "wolf";

break;

case 0:

cargo = "nothing";

break;

default:

cargo = "unknown";

break;

}


{

cout << "Crossing to the east side of the river with " << cargo <<

endl;

boatlocation = boateast;

}

else

{

cout << "Crossing to the west side of the river with " << cargo <<

endl;

boatlocation = boatwest;

}

return boatlocation;

}

////////////////////////////////////////////////////////////

/////////////////////// UnLoad the boat ////////////////////

////////////////////////////////////////////////////////////

// This function will unload the items onto the shoreline then

// call the iscompatable() function to see if the shoreline

// is safe, if the shoreline is not safe it does not load the

// current item but instead loads the next item, and repeats

// the safety check until a safe shoreline is obtained.

int unloadboat(void)

{

std::string cargo;

int good = 0;


// This code block is for user display purposes only

// displays to the user what is being loaded and unloaded

switch (boat[0])

{

case cabbage:

cargo = "cabbage";

break;

case goat:

cargo = "goat";

break;

case wolf:

cargo = "wolf";

break;

case 0:

cargo = "nothing";

break;

P a g e | 14

default:

cargo = "unknown";

break;

}

cout << "UnLoading " << cargo << " from Boat" << endl;

////////// If the boat is on the East Bank /////////////////


{

if (eastshore[0] == 0 && boat[0] == cabbage)

{

boat[0] = 0;

eastshore[0] = cabbage;


good = iscompatable();// check to see if the east shore is

compatable

if (good == (goat + cabbage))

{

cout << "loading goat" << endl;

boat[0] = goat;

eastshore[1] = 0;

}

}

if (eastshore[1] == 0 && boat[0] == goat && lastitem != cabbage)

{

boat[0] = 0;

eastshore[1] = goat;

cout << "unloading goat" << endl;


if (good != 1)

{

cout << "reloading goat" << endl;

boat[0] = goat;

eastshore[1] = 0;

}

}

if (eastshore[2] == 0 && boat[0] == wolf)

{

boat[0] = 0;

eastshore[2] = wolf;



if (good != 1)

{

cout << "reloading wolf" << endl;

boat[0] = wolf;

eastshore[2] = 0;

}

}

}

P a g e | 15

///////// End East

/////// boat is on the west shore ///////////////


{

if (westshore[0] == 0 && boat[0] == cabbage)

{

boat[0] = 0;

westshore[0] = cabbage;



if (good != 1)

{

cout << "reloading cabbage" << endl;

boat[0] = cabbage;

westshore[0] = 0;

}

}

if (westshore[1] == 0 && boat[0] == goat)

{

boat[0] = 0;

westshore[1] = goat;

cout << "unloading goat" << endl;


if (good != 1 && lastitem != goat)

{

cout << "reloading goat" << endl;

boat[0] = goat;

westshore[1] = 0;

}

}

if (westshore[2] == 0 && boat[0] == wolf)

{

boat[0] = 0;

westshore[2] = wolf;



if (good != 1)

{

cout << "reloading wolf" << endl;

boat[0] = wolf;

westshore[2] = 0;

}

}

}

/////////// End West

return boat[0];

}

////////////////////////////////////////////////////////////////////////

//////////////// Check to see if shore is compatable ///////////////////

P a g e | 16

////////////////////////////////////////////////////////////////////////

int iscompatable(void)

{

int compatable;

//cout << " Checking compatability" << endl;


{

if (eastshore[0] == cabbage && eastshore[1] == goat &&

eastshore[2] != wolf)

{

compatable = cabbage + goat;// = 1+2=3

}

else if (eastshore[0] != cabbage && eastshore[1] == goat &&

eastshore[2] == wolf)

{

compatable = goat + wolf;//2+3=5

}

else

{

compatable = 1;

}

switch (compatable)

{

case 0:

cout << " east shore is not compatable" << endl;

break;

case 1:

cout << " east shore is compatable" << endl;

break;

case cabbage + goat:

cout << " east shore is not compatable, goat will eat

cabbage " << endl;

break;

case wolf + goat:

cout << " east shore is not compatable, wolf will eat goat

" << endl;

break;

}

}


{

if (westshore[0] == cabbage && westshore[1] == goat &&

westshore[2] != wolf)

{

compatable = cabbage + goat;// = 1+2=3

}

else if (westshore[0] != cabbage && westshore[1] == goat &&

westshore[2] == wolf)

P a g e | 17

{

compatable = goat + wolf;//2+3=5

}

else

{

compatable = 1;

}

switch (compatable)

{

case 0:

cout << " west shore is not compatable" << endl;

break;

case 1:

cout << " west shore is compatable" << endl;

break;

case cabbage + goat:

cout << " west shore is not compatable, goat will eat

cabbage " << endl;

break;

case wolf + goat:

cout << " west shore is not compatable, wolf will eat goat

" << endl;

break;

}

}

return compatable;

}

P a g e | 18

Deliverable - Farmer Wolf Goat Cabbage

Documents

Transcript of Deliverable - Farmer Wolf Goat Cabbage