Battle Function

[rantiv]

My battle function doesnt seem to work. Im thinking it has something to do with my checking if it is a power of two.

#include <iostream>
#include <string>
#include <vector>
#include <cmath>

using namespace std;


const int IGNORE_VALUE = 1000;
const int MENU_MAX = 6;
const int MENU_MIN = 0;
const int NOT_FOUND = -1;

int FindRestaurant(string newRestaurant, vector<string> restaurantChoices);

void PrintMenu(){
   cout << "Please select one of the following options: " << endl;
   cout << endl;
   cout << "0 - Quit the program" << endl;
   cout << "1 - Display all restaurants" << endl;
   cout << "2 - Add a restaurant" << endl;
   cout << "3 - Remove a restaurant" << endl;
   cout << "4 - \"Cut\" the list of restaurants" << endl;
   cout << "5 - \"Shuffle\" the list of restaurants" << endl;
   cout << "6 - Begin the tournament" << endl;
   cout << endl;
   cout << "Enter your selection now: " << endl;
 return;  
}

bool menuError(int menuChoice) {

	if (menuChoice > MENU_MAX || menuChoice < MENU_MIN)
	{
		cout << "Invalid selection.  Please try again." << endl;
		PrintMenu();

		return true;
	}

	else {

		return false;
	}
}

void PrintVector(vector<string> restaurantChoices) {
   for (unsigned int i = 0; i < restaurantChoices.size(); ++i) {
      cout << "\t\"" << restaurantChoices.at(i) << "\"" << endl;
   }
}

void AddRestaurant(string& newRestaurant, vector<string>& restaurantChoices) {
   int found = 0;
   found = FindRestaurant(newRestaurant, restaurantChoices);
   if (found == NOT_FOUND) {
      restaurantChoices.push_back(newRestaurant);
      cout << newRestaurant << " has been added." << endl;
   }
   else {
      cout << "That restaurant is already on the list, you can not add it again." << endl;
   }
   return; 
}


int FindRestaurant(string newRestaurant, vector<string> restaurantChoices)
{
	for (unsigned int i = 0; i < restaurantChoices.size(); i++)
	{
		if (newRestaurant == restaurantChoices[i])
		{
			return i;
		}
	}
	return NOT_FOUND;
}
void RemoveRestaurant(string newRestaurant, vector<string>& restaurantChoices){
   int found = 0;
   found = FindRestaurant(newRestaurant, restaurantChoices);
      if (found != NOT_FOUND) {
   		restaurantChoices.erase(restaurantChoices.begin() + found);
   		cout << newRestaurant << " has been removed." << endl;
   	}
   	else {
   		cout << "That restaurant is not on the list, you can not remove it." << endl;
   	}
 return;  
}
void CutRestaurant(vector<string>& restaurantList, int cutChoice) {
  vector<string> changeVector = restaurantList;
   if (cutChoice > changeVector.size()) {
   	cout << endl << "The restaurants can not be cut there, there are only " << changeVector.size() << " current - number - of - restaurants ";
   	return;
   }
   else{
      for(unsigned int i = 0; i < cutChoice; i++){
      	changeVector.at(i) = restaurantList.at(0);
      	restaurantList.erase(restaurantList.begin());
      }
      for (int j=0; j < cutChoice; j++) {
         restaurantList.push_back(changeVector.at(j));
      }
   }
 return;
}
void ShuffleRestaurants(vector<string>& restaurantList) {
   int sizeOfVector = 0;
   int halfOfVector = 0;
   vector<string> newVector;
   sizeOfVector = restaurantList.size();
   if (sizeOfVector % 2 == 1) {
      cout << "The current tournament size (" << sizeOfVector << ") is not a power of two (2, 4, 8...)." << endl;
      cout<< "A shuffle is not possible. Please add or remove resturants." << endl;
      return;
   }
   else {
      halfOfVector = sizeOfVector/2;
      
      for (int i = 0; i < halfOfVector; i++) {
   		newVector.push_back(restaurantList.at(i + halfOfVector));
   		newVector.push_back(restaurantList.at(i));
   	}
	restaurantList.clear();
	for (int i = 0; i < sizeOfVector; i++) {
		restaurantList.push_back(newVector.at(i));
	}
	return;
}
   return;
}
void BeginTournament(vector<string>& restaurantList) {
   double logMath = 0.00;
	int logInt = 0;
   int userSelection = 0;
   int round = 0;
   int combination = 0;
   int listSize = 0;
   int halfOfList = 0;
   halfOfList = listSize/2;
   listSize = restaurantList.size();
   logMath = log(listSize / log(2.0));
	logInt = logMath;
	vector<string> tempVector;
	
	if (logInt != logMath) {
		cout << "The current tournament size(" << listSize << ") is not a power of two (2, 4, 8...)." << endl;
   	cout << "A tournament is not possible. Please add or remove resturants." << endl;
   	return;
	}
   
   while(listSize > 1) { //continues for loop until vector has one restaurant left
      round++;
      combination = halfOfList;
      cout << "Round: " << round << endl;
      tempVector.clear();
      for (int i = 0; i < combination; i++) {
         cout << "Type \"1\" if you prefer " << restaurantList.at(i) << " or" << endl;
         cout << "type \"2\" if you prefer " << restaurantList.at(i + 1) << endl;
         cout << "Choice: " << endl;
         cin >> userSelection;
         while(cin.fail() || (userSelection != 1 && userSelection != 2)) {
            cin.clear();
            cin.ignore('\n' , IGNORE_VALUE);
            cout << "invalid response." << endl;
            cin >> userSelection;
         }
         if (userSelection == 1) {
            restaurantList.erase(restaurantList.begin() + i + 1); 
         }
         else if (userSelection == 2) {
            restaurantList.erase(restaurantList.begin() + i); 
         }
      }
   }
   
   cout << "The winning restaurant is " << restaurantList.at(0) << endl << endl;
   
   return;
}
int main() {
   int menuChoice = 0;
   vector<string> restaurantChoices;
   string restaurantName;
   int userCutPoint;
   
   cout << "Welcome to the restaurant battle!" << endl;
   cout << endl;
   cout << endl;
   PrintMenu();
   
   do { 
		do {
			cin >> menuChoice;
		} while (menuError(menuChoice));

      switch (menuChoice) {
		   case 1: 
		      cout << "Here are the current restaurants: " << endl;
		      cout << endl;
   			PrintVector(restaurantChoices);
   			PrintMenu();
   			break;

		   case 2:
   		   cout << "What is the name of the restaurant you want to add? " << endl;
   		   cin.ignore();
   		   getline (cin, restaurantName);
   		   AddRestaurant(restaurantName, restaurantChoices);
   		   cout << endl;
   		   PrintMenu();
   			break;
   			
   		case 3:
   		   cout << "What is the name of the restaurant you want to remove?" << endl;
   		   cin.ignore();
   		   getline(cin, restaurantName);
   		   RemoveRestaurant(restaurantName, restaurantChoices);
   		   cout << endl;
   		   PrintMenu();
   			break;
   			
   		case 4:
   		   cout << "How many restaurants should be taken from the top and put on the bottom?" << endl;
   		   cin.ignore();
   		   cin >> userCutPoint;
   		   CutRestaurant(restaurantChoices, userCutPoint);
   		   cout << endl;
   		   PrintMenu();
   			break;
   			
   		case 5:
   		   ShuffleRestaurants(restaurantChoices);
   		   PrintMenu();
   		   break;
   		   
   		case 6:
   		   BeginTournament(restaurantChoices);
   		   PrintMenu();
   		   break;
   		   
   		case 0: 
   			cout << "Goodbye!";
   			return 0;
   			break;
		}
	} while (true);

	return 0;
}

[Dorby]

Wow great job, and it is only standard input and out text based?

[whitenite1]

@rantiv

Yes, you do have a problem on line 112..
if (sizeOfVector % 2 == 1)
Checking if the result is 1, means that you have an ODD number. 3, 5, 7, 9 etc. You want to check if it's a 0, meaning NO left over results when the number is divided by 2.

[rantiv]

I dont think that is the problem. We put it though on online compliler that grades it and it has to do with battle function. Like i said for the battle section the checking for the power of two isnt working.

[lastchance]

Your line 142 won't find logarithm of listsize to base 2 because it is bracketed wrongly.

Even when bracketed correctly it could easily be defeated by floating-point rounding.

There are alternative ways of finding whether an int is a power of 2. One suggestion is below. (It is actually more general: finding powers of other bases than 2).

#include <iostream>
using namespace std;

//==========================================================================================================
// Function determines whether n is an integer power of base and, if so, returns that power; otherwise -1 //
//==========================================================================================================
int powerOfInt( int n, int base )                
{
   const int NOTPOWER = -1;                      // This will indicate false
   if ( n < 1 || base <= 1 ) return NOTPOWER;    // Daft input

   int power = 0;                                // Will hold power (exponent)
   while ( n > 1 )                               // Keep dividing by base; if no remainders then ok;
   {
      if ( n % base != 0 ) return NOTPOWER;      // Not a power, so indicate this
      n /= base;                                 // Take out successive factors of base ...
      power++;                                   // ... thus incrementing power
   }
   return power;                                
}


//======================================================================


int main()                                       // Now test it
{
   for ( int base : { 2, 3, 5 } )
   {
      cout << "\nTesting powers of " << base << ":\n";
      for ( int i = -2; i <= 30; i++ )
      {
         cout << i << ": ";
         int p = powerOfInt( i, base );
         if ( p < 0 ) cout << "---" << endl;
         else         cout << "Power " << p << endl;
      }
   }
}

Testing powers of 2:
-2: ---
-1: ---
0: ---
1: Power 0
2: Power 1
3: ---
4: Power 2
5: ---
6: ---
7: ---
8: Power 3
9: ---
10: ---
11: ---
12: ---
13: ---
14: ---
15: ---
16: Power 4
17: ---
18: ---
19: ---
20: ---
21: ---
22: ---
23: ---
24: ---
25: ---
26: ---
27: ---
28: ---
29: ---
30: ---

Testing powers of 3:
-2: ---
-1: ---
0: ---
1: Power 0
2: ---
3: Power 1
4: ---
5: ---
6: ---
7: ---
8: ---
9: Power 2
10: ---
11: ---
12: ---
13: ---
14: ---
15: ---
16: ---
17: ---
18: ---
19: ---
20: ---
21: ---
22: ---
23: ---
24: ---
25: ---
26: ---
27: Power 3
28: ---
29: ---
30: ---

Testing powers of 5:
-2: ---
-1: ---
0: ---
1: Power 0
2: ---
3: ---
4: ---
5: Power 1
6: ---
7: ---
8: ---
9: ---
10: ---
11: ---
12: ---
13: ---
14: ---
15: ---
16: ---
17: ---
18: ---
19: ---
20: ---
21: ---
22: ---
23: ---
24: ---
25: Power 2
26: ---
27: ---
28: ---
29: ---
30: ---

[rantiv]

Thank you