943,948 Members | Top Members by Rank

Software Development > C++ > help with parrallel arrays
Ad:
  • C++ Discussion Thread
  • Unsolved
  • Views: 9173
  • C++ RSS
You are currently viewing page 4 of this multi-page discussion thread; Jump to the first page
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

Hey lsu420luv,

Sorry for the reply like 8 hours later. You see, I live in Singapore and the reply you gave was at 4am SGT. Was asleep by then.

From what I saw in your previous post, I think you still do not comprehend quite a number of the C++ concepts... Here's what I did together with an explanation:
C++ Syntax (Toggle Plain Text)
  1. #include <iostream>
  2. #include <fstream>
  3. #include <cstdlib>
  4.  
  5. using namespace std;
  6.  
  7. // Const Fields
  8. const int MAXMEMBERS = 20;
  9. const int MAXJUDGES = 5;
  10.  
  11. // Globals
  12. int pianoPlayer[MAXMEMBERS];
  13. double score[MAXMEMBERS][MAXJUDGES];
  14. double weightFactor[MAXMEMBERS];
  15. int profLevel[MAXMEMBERS];
  16. int judgeNumber[MAXMEMBERS][MAXJUDGES];
  17. double average[MAXMEMBERS];
  18. int weightedScore[MAXMEMBERS];
  19. int category;  //category of music the students are playing
  20. int judgeCount[MAXMEMBERS];
  21. int numPlayers;
  22.  
  23. // Methods
  24. int ReadScores(ifstream& fin);
  25. void PrintReport(ofstream& fout);
  26. void ProcessScores();
Ok, I've separated the globals, constants and methods. You should do that too. It makes reading them a lot easier.

Notice that I have also reduced your PrintReport method that it only takes in an ofstream as its parameter. Remember what I told you about global variables? Since all the variables required by PrintReport are global (i.e. declared outside of any method), you can access them without passing them as parameters into the method.

C++ Syntax (Toggle Plain Text)
  1. int main()
  2. {
  3. 	ifstream fin("PianoREV.data");
  4. 	ofstream fout("Report.out");
  5.  
  6. 	if (!fin)
  7. 	{
  8. 		cout << "Error: Input File";
  9. 		return 1;
  10. 	}
  11. 	if (!fout)
  12. 	{
  13. 		cout << "Error: Output File";
  14. 		return 1;
  15. 	}
  16.  
  17. 	numPlayers = ReadScores(fin);
  18. 	ProcessScores();
  19. 	PrintReport(fout);
  20.  
  21. 	fin.close();
  22. 	fout.close();
  23. }
Look at how I've reduced your file I/O code. You can simply open an ifstream or ofstream by calling their constructors; in other words, just by doing this:
C++ Syntax (Toggle Plain Text)
  1. 	ifstream fin("PianoREV.data");
  2. 	ofstream fout("Report.out");
After that, you can check if the open succeeded simply by:
C++ Syntax (Toggle Plain Text)
  1. 	if (!fin)
  2. 	{
  3. 		cout << "Error: Input File";
  4. 		return 1;
  5. 	}
  6. 	if (!fout)
  7. 	{
  8. 		cout << "Error: Output File";
  9. 		return 1;
  10. 	}
Basically, putting a stream as the condition of an if statement tells you if it is still valid. Doing this:
C++ Syntax (Toggle Plain Text)
  1. 	if (!fin)
Is (sort of) the same as:
C++ Syntax (Toggle Plain Text)
  1. 	if (fin.fail())
It's just much shorter. Why "sort of"? I will explain this later.
These are also present in the ReadScores method, the one that you've been using (underlined):
int ReadScores (ifstream& fin)
{
	int i= 0;
	int j= 0;
	fin >> category;
	for (i = 0; fin && i < MAXMEMBERS; ++i)
	{
		if (!(fin >> pianoPlayer[i]))
			break;
		if (!(fin >> profLevel[i]))
			break;
		if (!(fin >> weightFactor[i]))
			break;

		// Process the judges
		for (int j = 0; fin; ++j)
		{
			if (j >= MAXJUDGES) // If we have too many judges
			{
				// If the number of judges overflow the array size,
				// we have to clear off the remaining judge entries
				// so that we can continue reading from the next
				// player entry
				int k;
				if (!(fin >> k) || k == -1)
				{
					judgeCount[i] = MAXJUDGES; // Set judgeCount to limit
					break;
				}
				else
					continue;
			}
			if (!(fin >> judgeNumber[i][j]) || judgeNumber[i][j] == -1)
			{
				judgeCount[i] = j;
				break;
			}
			if (!(fin >> score[i][j]))
			{
				judgeCount[i] = j;
				break;
			}
		}
	}
	return i;
}
If the input (>>) and output (<<) operators makes it look confusing, think of them as methods, and that these methods return the stream you call them with. What does this mean? Whenever you do something like:
C++ Syntax (Toggle Plain Text)
  1. cout << "Bob" << 123 << "Tom" << endl;
First of all, the stream you work with now is cout.
You use the output operator (<<) on cout.
And with the output operator, you tell cout to print "Bob", 123, "Tom" and endl (I'll explain endl later) Understood so far?

What I mean when that these operators are like methods and the return the stream you call them with, means that I call a method something like this happens when I use << (C++ pros, don't flame me with this, it's just an abstraction for explanation):
ostream& << (ostream& s)
{
	// Some logic ...

	return s;
}
Don't get it? Basically, this:
C++ Syntax (Toggle Plain Text)
  1. cout << "Bob" << 123 << "Tom" << endl;
Is exactly the same as:
C++ Syntax (Toggle Plain Text)
  1. cout << "Bob"; cout << 123; cout << "Tom"; cout << endl;
What does all these mean to you? Basically (look carefully at where the exclamation mark goes):
		if (!(fin >> pianoPlayer[i]))
			break;
Is exactly the same as:
		fin >> pianoPlayer[i];
		if (!fin)
			break;
Which is also (sort of) the same as:
		fin >> pianoPlayer[i];
		if (fin.fail())
			break;
Why "sort of the same"? Because (look, no exclamation mark):
		if (fin)
Is actually doing this:
		if (fin.good())
(And of course, if (!fin) the same as if (!fin.good()), the NOT operator (!) just changes true to false and vice versa).
It's sort of the same, because fin.good() is not just the opposite of fin.fail()! It's also the opposite of fin.eof() and fin.bad(). What are these?
  • fin.eof() returns true if the End-Of-File (EOF) has been reached.
  • fin.fail() returns true if some I/O error occurred.
  • fin.bad() returns true if some fatal I/O error occurred.
So, by using if (!fin.good()), or simply if (!fin) checks for all these possible errors.

Now, what is endl? endl is the C++ representation of a newline. You should not use "\n" because this is quite restricted as different OSes use different line terminators. *nix will use "\n" but Windows "\r\n". In order to make your code compile without being OS specific, you should use endl.

I've used endl in your PrintReport method too (underlined):
void PrintReport (ofstream& fout)
{
	for (int i = 0; i < numPlayers; ++i)
	{
		fout << "Piano Player: " << pianoPlayer[i] << endl;
		for (int j = 0; j < judgeCount[i]; ++j)
		{
			fout << "Judge Number: " << judgeNumber[i][j] << "   "
				<< "Score: " << score[i][j] << endl;
		}
		fout << "Average Score: " << average[i] << endl
			<< "Weighted Score: " << weightedScore[i] << endl << endl;
	}
}
You were asking why your PrintReport method print every player and judge? Look at the changes (underlined):
void PrintReport (ofstream& fout)
{
	for (int i = 0; i < numPlayers; ++i)
	{
		fout << "Piano Player: " << pianoPlayer[i] << endl;
		for (int j = 0; j < judgeCount[i]; ++j)
		{
			fout << "Judge Number: " << judgeNumber[i][j] << "   "
				<< "Score: " << score[i][j] << endl;
		}
		fout << "Average Score: " << average[i] << endl
			<< "Weighted Score: " << weightedScore[i] << endl << endl;
	}
}
You used MAXMEMBERS and MAXJUDGES earlier, and that's why you print to MAXMEMBERS and MAXJUDGES! It's that simple a logic error. Since you said you wanted a judgeCount array, I've included it in too. Notice that this is also reflected in the ReadScores method; ReadScores will determine how many judges are there per student (underlined):
int ReadScores (ifstream& fin)
{
	int i= 0;
	int j= 0;
	fin >> category;
	for (i = 0; fin && i < MAXMEMBERS; ++i)
	{
		if (!(fin >> pianoPlayer[i]))
			break;
		if (!(fin >> profLevel[i]))
			break;
		if (!(fin >> weightFactor[i]))
			break;

		// Process the judges
		for (int j = 0; fin; ++j)
		{
			if (j >= MAXJUDGES) // If we have too many judges
			{
				// If the number of judges overflow the array size,
				// we have to clear off the remaining judge entries
				// so that we can continue reading from the next
				// player entry
				int k;
				if (!(fin >> k) || k == -1)
				{
					judgeCount[i] = MAXJUDGES; // Set judgeCount to limit
					break;
				}
				else
					continue;
			}
			if (!(fin >> judgeNumber[i][j]) || judgeNumber[i][j] == -1)
			{
				judgeCount[i] = j;
				break;
			}
			if (!(fin >> score[i][j]))
			{
				judgeCount[i] = j;
				break;
			}
		}
	}
	return i;
}
In case that you do not know what break and continue is, break terminates the innermost loop and continues immediately on the code outside the loop. continue forces the loop to reiterate and evaluate the condition immediately, not executing the remaining code before a normal iteration.

As for ProcessScores, I've also changed it to use judgeCount. Other than that, nothing else is changed. I was unable to find any fault with the logic.
void ProcessScores ()
{
	int j;
	double totalScore;
	for (int i = 0; i < numPlayers; ++i)
	{
		for (j = 0, totalScore = 0; j < judgeCount[i]; ++j)
		{
			totalScore += score[i][j];
		}
		if (j != 0)
			average[i] = totalScore / j;
		weightedScore[i] = average[i] * weightFactor[i];
	}
}

Putting everything together, here is the full source code:
C++ Syntax (Toggle Plain Text)
  1. #include <iostream>
  2. #include <fstream>
  3. #include <cstdlib>
  4.  
  5. using namespace std;
  6.  
  7. // Const Fields
  8. const int MAXMEMBERS = 20;
  9. const int MAXJUDGES = 5;
  10.  
  11. // Globals
  12. int pianoPlayer[MAXMEMBERS];
  13. double score[MAXMEMBERS][MAXJUDGES];
  14. double weightFactor[MAXMEMBERS];
  15. int profLevel[MAXMEMBERS];
  16. int judgeNumber[MAXMEMBERS][MAXJUDGES];
  17. double average[MAXMEMBERS];
  18. int weightedScore[MAXMEMBERS];
  19. int category;  //category of music the students are playing
  20. int judgeCount[MAXMEMBERS];
  21. int numPlayers;
  22.  
  23. // Methods
  24. int ReadScores(ifstream& fin);
  25. void PrintReport(ofstream& fout);
  26. void ProcessScores();
  27.  
  28. int main()
  29. {
  30. 	ifstream fin("PianoREV.data");
  31. 	ofstream fout("Report.out");
  32.  
  33. 	if (!fin)
  34. 	{
  35. 		cout << "Error: Input File";
  36. 		return 1;
  37. 	}
  38. 	if (!fout)
  39. 	{
  40. 		cout << "Error: Output File";
  41. 		return 1;
  42. 	}
  43.  
  44. 	numPlayers = ReadScores(fin);
  45. 	ProcessScores();
  46. 	PrintReport(fout);
  47.  
  48. 	fin.close();
  49. 	fout.close();
  50. }
  51.  
  52. int ReadScores (ifstream& fin)
  53. {
  54. 	int i= 0;
  55. 	int j= 0;
  56. 	fin >> category;
  57. 	for (i = 0; fin && i < MAXMEMBERS; ++i)
  58. 	{
  59. 		if (!(fin >> pianoPlayer[i]))
  60. 			break;
  61. 		if (!(fin >> profLevel[i]))
  62. 			break;
  63. 		if (!(fin >> weightFactor[i]))
  64. 			break;
  65.  
  66. 		// Process the judges
  67. 		for (int j = 0; fin; ++j)
  68. 		{
  69. 			if (j >= MAXJUDGES) // If we have too many judges
  70. 			{
  71. 				// If the number of judges overflow the array size,
  72. 				// we have to clear off the remaining judge entries
  73. 				// so that we can continue reading from the next
  74. 				// player entry
  75. 				int k;
  76. 				if (!(fin >> k) || k == -1)
  77. 				{
  78. 					judgeCount[i] = MAXJUDGES; // Set judgeCount to limit
  79. 					break;
  80. 				}
  81. 				else
  82. 					continue;
  83. 			}
  84. 			if (!(fin >> judgeNumber[i][j]) || judgeNumber[i][j] == -1)
  85. 			{
  86. 				judgeCount[i] = j;
  87. 				break;
  88. 			}
  89. 			if (!(fin >> score[i][j]))
  90. 			{
  91. 				judgeCount[i] = j;
  92. 				break;
  93. 			}
  94. 		}
  95. 	}
  96. 	return i;
  97. }
  98.  
  99. void ProcessScores ()
  100. {
  101. 	int j;
  102. 	double totalScore;
  103. 	for (int i = 0; i < numPlayers; ++i)
  104. 	{
  105. 		for (j = 0, totalScore = 0; j < judgeCount[i]; ++j)
  106. 		{
  107. 			totalScore += score[i][j];
  108. 		}
  109. 		if (j != 0)
  110. 			average[i] = totalScore / j;
  111. 		weightedScore[i] = average[i] * weightFactor[i];
  112. 	}
  113. }
  114.  
  115. void PrintReport (ofstream& fout)
  116. {
  117. 	for (int i = 0; i < numPlayers; ++i)
  118. 	{
  119. 		fout << "Piano Player: " << pianoPlayer[i] << endl;
  120. 		for (int j = 0; j < judgeCount[i]; ++j)
  121. 		{
  122. 			fout << "Judge Number: " << judgeNumber[i][j] << "   "
  123. 				<< "Score: " << score[i][j] << endl;
  124. 		}
  125. 		fout << "Average Score: " << average[i] << endl
  126. 			<< "Weighted Score: " << weightedScore[i] << endl << endl;
  127. 	}
  128. }

Ok, I admit, all the help I gave you thus far are all done without the use of a compiler. I wasn't able to get my C++ compiler up but I can give you the guarantee that the code works. It should. Unless I make some careless mistake, which I believe I didn't.

I would recommend two books if you intend to go into C++:The first is an extremely good guide and reference (though it states only reference). I would dare to give you my fullest support that this book is the definite reference to C++ (and some C too). It even goes through some more advanced topics like the Standard Library and RTTI. The same author has written many other good books on C++, C and Java as well.
The second is also a must-have for every C++ programmer. The Standard Library is the equivalent of the Java API for C++ (though not as extensive), and no other book gives a tutorial and reference on it as worth as Mr. Josuttis'.

It's sometimes hard to find a good reference on the Internet (which is surprising), so I had to rely on these books for C++ help. In fact, these two books propelled me into programming C++.
You can also check out How Not to Program in C++ by Steve Oualline. It's a rather light-hearted good read on the common mistakes people make with C++.

I believe all's done and you can submit your work. It's been nice working with ya on this, and if there's anything else that needs to be done, don't hesitate to post it. I've sent the PM. Thanks again!
Reputation Points: 10
Solved Threads: 2
Junior Poster in Training
AstroNox is offline Offline
50 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

Finally got my C++ compiler working. I've compiled the code and fixed some small compilation warnings:
C++ Syntax (Toggle Plain Text)
  1. #include <iostream>
  2. #include <fstream>
  3. #include <cstdlib>
  4.  
  5. using namespace std;
  6.  
  7. // Const Fields
  8. const int MAXMEMBERS = 20;
  9. const int MAXJUDGES = 5;
  10.  
  11. // Globals
  12. int pianoPlayer[MAXMEMBERS];
  13. double score[MAXMEMBERS][MAXJUDGES];
  14. double weightFactor[MAXMEMBERS];
  15. int profLevel[MAXMEMBERS];
  16. int judgeNumber[MAXMEMBERS][MAXJUDGES];
  17. double average[MAXMEMBERS];
  18. double weightedScore[MAXMEMBERS];
  19. int category;  //category of music the students are playing
  20. int judgeCount[MAXMEMBERS];
  21. int numPlayers;
  22.  
  23. // Methods
  24. int ReadScores(ifstream& fin);
  25. void PrintReport(ofstream& fout);
  26. void ProcessScores();
  27.  
  28. int main()
  29. {
  30. 	ifstream fin("PianoREV.data");
  31. 	ofstream fout("Report.out");
  32.  
  33. 	if (!fin)
  34. 	{
  35. 		cout << "Error: Input File";
  36. 		return 1;
  37. 	}
  38. 	if (!fout)
  39. 	{
  40. 		cout << "Error: Output File";
  41. 		return 1;
  42. 	}
  43.  
  44. 	numPlayers = ReadScores(fin);
  45. 	ProcessScores();
  46. 	PrintReport(fout);
  47.  
  48. 	fin.close();
  49. 	fout.close();
  50. }
  51.  
  52. int ReadScores (ifstream& fin)
  53. {
  54. 	int i= 0;
  55. 	fin >> category;
  56. 	for (i = 0; fin && i < MAXMEMBERS; ++i)
  57. 	{
  58. 		if (!(fin >> pianoPlayer[i]))
  59. 			break;
  60. 		if (!(fin >> profLevel[i]))
  61. 			break;
  62. 		if (!(fin >> weightFactor[i]))
  63. 			break;
  64.  
  65. 		// Process the judges
  66. 		for (int j = 0; fin; ++j)
  67. 		{
  68. 			if (j >= MAXJUDGES) // If we have too many judges
  69. 			{
  70. 				// If the number of judges overflow the array size,
  71. 				// we have to clear off the remaining judge entries
  72. 				// so that we can continue reading from the next
  73. 				// player entry
  74. 				int k;
  75. 				if (!(fin >> k) || k == -1)
  76. 				{
  77. 					judgeCount[i] = MAXJUDGES; // Set judgeCount to limit
  78. 					break;
  79. 				}
  80. 				else
  81. 					continue;
  82. 			}
  83. 			if (!(fin >> judgeNumber[i][j]) || judgeNumber[i][j] == -1)
  84. 			{
  85. 				judgeCount[i] = j;
  86. 				break;
  87. 			}
  88. 			if (!(fin >> score[i][j]))
  89. 			{
  90. 				judgeCount[i] = j;
  91. 				break;
  92. 			}
  93. 		}
  94. 	}
  95. 	return i;
  96. }
  97.  
  98. void ProcessScores ()
  99. {
  100. 	int j;
  101. 	double totalScore;
  102. 	for (int i = 0; i < numPlayers; ++i)
  103. 	{
  104. 		for (j = 0, totalScore = 0; j < judgeCount[i]; ++j)
  105. 		{
  106. 			totalScore += score[i][j];
  107. 		}
  108. 		if (j != 0)
  109. 			average[i] = totalScore / j;
  110. 		weightedScore[i] = average[i] * weightFactor[i];
  111. 	}
  112. }
  113.  
  114. void PrintReport (ofstream& fout)
  115. {
  116. 	for (int i = 0; i < numPlayers; ++i)
  117. 	{
  118. 		fout << "Piano Player: " << pianoPlayer[i] << endl;
  119. 		for (int j = 0; j < judgeCount[i]; ++j)
  120. 		{
  121. 			fout << "Judge Number: " << judgeNumber[i][j] << "   "
  122. 				<< "Score: " << score[i][j] << endl;
  123. 		}
  124. 		fout << "Average Score: " << average[i] << endl
  125. 			<< "Weighted Score: " << weightedScore[i] << endl << endl;
  126. 	}
  127. }
Enjoy.
Reputation Points: 10
Solved Threads: 2
Junior Poster in Training
AstroNox is offline Offline
50 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

I know that I am not that good. The reason I do not understand that if (!(fin stuff is because we have not learned it yet. I am not supposed to use things we have not learned yet. Thanks for making it work though. I will check my pm's. An ideas on how to add a selection sort. I hope you check this before 12 noon tommorow because that is when it is due
Reputation Points: 10
Solved Threads: 0
Light Poster
lsu420luv is offline Offline
49 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

What do you want to sort? And how do you want it sorted (ascending, descending etc.)?
Reputation Points: 10
Solved Threads: 2
Junior Poster in Training
AstroNox is offline Offline
50 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

I want to sort by weighted player average descending. Also can you change the
C++ Syntax (Toggle Plain Text)
  1. if (!(fin >> judgeNumber[i][j]) || judgeNumber[i][j] == -1)
  2. 			{
  3. 				judgeCount[i] = j;
  4. 				break;
  5. 			}
  6. 			if (!(fin >> score[i][j]))
  7. 			{
  8. 				judgeCount[i] = j;
  9. 				break;
  10. 			}

I know it seems like I dont know what I am doing, but it is only partially that. I have to do it how she wants it. Here is what I have so far. I had to change some things to setup 2d arrays for weighted scores. she wants each score for each judge weigted. Everything is fine except those lines above and the selection sort. I need a sort of average[i] descending. Here is the code exactly how i need it except for those two things.
C++ Syntax (Toggle Plain Text)
  1. #include <iostream>
  2. #include <fstream>
  3. #include <cstdlib>
  4.  
  5. using namespace std;
  6.  
  7. // Const Fields
  8. const int MAXMEMBERS = 20;
  9. const int MAXJUDGES = 7;
  10.  
  11. //set text values to numbers for switch statement for CatType
  12. typedef int CATEGORY;
  13. const int BALLAD    = 1;
  14. const int CONCERTO  = 2;
  15. const int MODERN    = 3;
  16. const int SONATA    = 4;
  17. const int WALTZ     = 5;
  18. //set text values to numbers for switch statement for ProfLevel
  19. typedef int PROFICIENCY;
  20. const int PRIMARY    = 1;
  21. const int INTERMEDIATE  = 2;
  22. const int ADVANCEDINTERMEDIATE    = 3;
  23. const int SENIOR = 4;
  24.  
  25.  
  26.  
  27.  
  28.  
  29. // Globals
  30. int pianoPlayer[MAXMEMBERS];
  31. double score[MAXMEMBERS][MAXJUDGES];
  32. double weightFactor[MAXMEMBERS];
  33. int profLevel[MAXMEMBERS];
  34. int judgeNumber[MAXMEMBERS][MAXJUDGES];
  35. double average[MAXMEMBERS];
  36. double weightedScore[MAXMEMBERS][MAXJUDGES];
  37. int categoryName;  //category of music the students are playing
  38. int judgeCount[MAXMEMBERS];
  39. int numPlayers;
  40.  
  41. // Methods
  42. int ReadScores(ifstream& fin);
  43. void PrintReport(ofstream& fout);
  44. void ProcessScores();
  45. void SwitchCatType(ofstream& fout,CATEGORY categoryName);
  46. void SwitchProfLevel(ofstream& fout, PROFICIENCY profLevel[MAXMEMBERS]);
  47. void Header(ofstream& fout);
  48. void SetFormat(ofstream& fout);
  49.  
  50. int main()
  51. {
  52. 	ifstream fin("PianoREV.data");
  53. 	ofstream fout("Report.out");
  54.  
  55. 	if (!fin)
  56. 	{
  57. 		cout << "Error: Input File";
  58. 		return 1;
  59. 	}
  60. 	if (!fout)
  61. 	{
  62. 		cout << "Error: Output File";
  63. 		return 1;
  64. 	}
  65.  
  66. 	numPlayers = ReadScores(fin);
  67. 	ProcessScores();
  68. 	PrintReport(fout);
  69.  
  70. 	fin.close();
  71. 	fout.close();
  72. }
  73.  
  74. /************************************************************************************************/
  75. /* Function Name: SetFormat									*/
  76. /* Function Purpose: Setup formatting of fout							*/
  77. /* Input Parameters: none									*/
  78. /* Return value: none										*/
  79. /************************************************************************************************/
  80. void SetFormat (ofstream& fout)
  81. {
  82. 	fout.setf(ios::fixed);
  83. 	fout.setf(ios::showpoint);
  84. 	fout.precision(1);
  85. 	return;
  86. }  //end Set Format
  87.  
  88. /************************************************************************************************/
  89. /* Function Name: Header									*/
  90. /* Function Purpose: Output the header of file							*/
  91. /* Input Parameters: none									*/
  92. /* Return value: none										*/
  93. /************************************************************************************************/
  94. void Header (ofstream& fout)
  95. {
  96. 	// output header to file
  97. 	fout << "    \n\n	Federation of Music Teachers\n";
  98. 	fout << " Mardi Gras Piano Invitational Competition\n";
  99. 	fout << "	 Baton Rouge, Louisiana\n\n";
  100. 	return;
  101. } //end Header
  102. int ReadScores (ifstream& fin)
  103. {
  104. 	int i= 0;
  105. 	fin >> categoryName;
  106. 	while (fin >> pianoPlayer)
  107. 	// input profLEvel, weightFactor, judgeNumbers, and scores
  108. 		fin >> profLevel[i];
  109. 		fin >> weightFactor[i];
  110. 		// Process the judges
  111. 		for (int j = 0; fin; ++j)
  112. 		{
  113. 			if (!(fin >> judgeNumber[i][j]) || judgeNumber[i][j] == -1)
  114. 			{
  115. 				judgeCount[i] = j;
  116. 				break;
  117. 			}
  118. 			if (!(fin >> score[i][j]))
  119. 			{
  120. 				judgeCount[i] = j;
  121. 				break;
  122. 			}
  123. 		}
  124. 	}
  125. 	return i;
  126. }
  127.  
  128. void ProcessScores ()
  129. {
  130. 	int j;
  131. 	double totalScore;
  132. 	for (int i = 0; i < numPlayers; i++)
  133. 	{
  134. 		for (j = 0; j < judgeCount[i]; j++)
  135. 		{
  136. 			weightedScore[i][j] = score[i][j] * weightFactor[i];
  137. 			totalScore += weightedScore[i][j];
  138. 		}
  139. 		average[i] = totalScore / j;
  140. 		totalScore = 0;
  141.  
  142. 	}
  143. }
  144. /************************************************************************/
  145. /* Function Name: SwitchProfLevel					*/
  146. /* Function Purpose: determine what level player is and output the level*/
  147. /*		     ftom numerical to actually name ex: 1 is primary   */
  148. /* Input Parameters: level						*/
  149. /* Return value: none							*/
  150. /************************************************************************/
  151. void SwitchProfLevel(ofstream& fout, PROFICIENCY profLevel[MAXMEMBERS])
  152. {
  153. 	int i = 0;
  154. 	switch (profLevel[i])
  155. 	{
  156. 		case PRIMARY:
  157. 			fout << " Primary\n";
  158. 			break;
  159. 		case INTERMEDIATE:
  160. 			fout << " Intermediate\n";
  161. 			break;
  162. 		case ADVANCEDINTERMEDIATE: 
  163. 			fout << " Advanced Intermediate\n";
  164. 			break;
  165. 		case SENIOR:
  166. 			fout << " Senior\n";
  167. 			break;
  168. 		default:
  169. 			cout << " Invalid Proficiency Level\n";
  170. 			break;
  171. 	}
  172. }  //end SwitchProfLevel
  173. /************************************************************************/
  174. /* Function Name: SwitchCatType						*/
  175. /* Function Purpose: determine what category player is and output       */
  176. /*		     from numerical to actually name ex: 1 is Ballad    */
  177. /* Input Parameters: categoryName					*/
  178. /* Return value: none							*/
  179. /************************************************************************/
  180. void SwitchCatType(ofstream& fout,CATEGORY categoryName)
  181. {
  182. 	switch (categoryName)
  183. 	{
  184. 		case BALLAD:
  185. 			fout << " Ballad\n";
  186. 			break;
  187. 		case CONCERTO:
  188. 			fout << " Concerto\n";
  189. 			break;
  190. 		case MODERN: 
  191. 			fout << " Modern\n";
  192. 			break;
  193. 		case SONATA:
  194. 			fout << " Sonata\n";
  195. 			break;
  196. 		case WALTZ: 
  197. 			fout << " Waltz\n";
  198. 			break;
  199. 		default:
  200. 			cout << " Invalid Category\n";
  201. 			break;
  202. 	}
  203. } //end SwitchCatType
  204. /************************************************************************/
  205. /* Function Name: PrintReport						*/
  206. /* Function Purpose:  Recieve arrays and print to output file		*/
  207. /* Input Parameters: 	pianoPlayer, score, judgeNumber, judgeCount 	*/			
  208. /* Return value: none							*/
  209. /************************************************************************/
  210. void PrintReport(ofstream& fout)
  211. {
  212. 	int i=0, j=0;
  213. 	Header(fout);
  214. 	SetFormat(fout);
  215. 	for (i = 0; i < numPlayers; i++)
  216. 	{
  217. 		//output piano player and category 
  218. 		fout << "Piano Player: ";
  219. 		fout << pianoPlayer[i] << "\n";
  220. 		fout << "Category:";
  221. 		// call switch function for category and Proficiency
  222. 		SwitchCatType(fout, categoryName);
  223. 		fout << "Proficiency Level:";
  224. 		SwitchProfLevel(fout, profLevel);
  225. 		fout << "           ";
  226. 		//outpur judges' to file use switch to get correct amount
  227. 		for (j =0; j < judgeCount[i]; j++)
  228. 		{		
  229. 			fout << "Judge";
  230. 			fout.width(10);	
  231. 		}
  232. 		fout << "\n         ";
  233. 		// output judges' numbers
  234. 		for (j =0; j < judgeCount[i]; j++)
  235. 		{
  236. 			fout.width(7);
  237. 			fout << judgeNumber[i][j] << "   ";	
  238. 		}
  239. 		fout << "\n     -----------------------------------------------------------------------\n";
  240. 		fout << "         ";
  241. 		//output scores		
  242. 		for (j =0; j < judgeCount[i]; j++)
  243. 		{
  244. 			fout.width(7);
  245. 			fout << score[i][j] << "   ";
  246. 		}
  247. 		fout << "\n         ";
  248. 		//output weighted scores
  249. 		for (j =0; j < judgeCount[i]; j++)
  250. 		{
  251. 			fout.width(7);
  252. 			fout << weightedScore[i][j] << "   ";
  253. 		}
  254. 		fout << "\nWeight: " << weightFactor[i];
  255. 		fout << "\nAverage Score: " << average[i] << "\n\n\n";
  256. 	}	
  257. 	return;
  258. } //end PrintReport

the problem is that she is a bad teacher. I usually learn things on my own and this summer will become a c++ guru. I have learned a hell of a lot of stuff on my own, but never on time restraints doing shit the way someone else wants it. For instance why would she make me use an inferior method to the one you used? No one knows, but that is neither here nor there. All your help is greatly appreciated. The program runs great.
Reputation Points: 10
Solved Threads: 0
Light Poster
lsu420luv is offline Offline
49 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

Before I start working on those, let me confirm these:
  1. You want the sort to be descending, according to average. This means if I have:
    4, 6, 3, 8, 1, 5, 7
    You want it to be sorted as:
    8, 7, 6, 5, 4, 3, 1
  2. A thing to note is that, if you were to sort the average, means that every single array is implicated—they all need to be sorted in relation to the average array. A lazy version of this is to have an index, i.e., another array to store the sorted indices of the arrays. I think the second method is a far more efficient and less error prone method, but I do not know if you are allowed to do such a thing.

Also, I'm sorry if I demeaned or offended you in anyway indirectly or directly (regarding the "you seemed not to know what you're doing" part). Yes, I understand now, that your lecturer is making things difficult for you. Just wanted to clear that up too.
Reputation Points: 10
Solved Threads: 2
Junior Poster in Training
AstroNox is offline Offline
50 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

no you didnt offend me. I am just used to being the one that solves all the problems. She has led us into the darka with no flashlight. How she does the selection if this helps is by seting a low index and a target. i believe it checks to see if each one is the low value and if it is resets that as the low one. she just gave us
selection = 0
low integer = -0
j = i+1
j = 1
low index j==2, low index j =2 or something. the lowindex i value change the values. I hope this helkps. I would think it would be the sloppier. she likes to do this shit. Any thoughts on how to replace the if(!( statements. I did it for profLevel and weight factor but cannot seem to get the others.
Reputation Points: 10
Solved Threads: 0
Light Poster
lsu420luv is offline Offline
49 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

I know how to do a selection sort algorithm, no worry on that. But I need answers to those two questions...
  1. Are you sure you want it descending?
  2. Do you want the sort to reshuffle ALL the arrays, or you want an additional array that stores the sorted indices of all the arrays?

I'm working on the simplification of those statements, don't worry about that.
Reputation Points: 10
Solved Threads: 2
Junior Poster in Training
AstroNox is offline Offline
50 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

It needs to reshuffle all the arrays descending
Reputation Points: 10
Solved Threads: 0
Light Poster
lsu420luv is offline Offline
49 posts
since Mar 2006
Permalink
Mar 28th, 2006
0

Re: help with parrallel arrays

also my switch for the prof level is not cycling for each player. any thoughts. I will definately be hooking you up for all this help
Reputation Points: 10
Solved Threads: 0
Light Poster
lsu420luv is offline Offline
49 posts
since Mar 2006

This thread is more than three months old

No one has posted to this discussion for at least three months. Please let old threads die and do not reply to them unless you feel you have something new and valuable to contribute that absolutely must be added to make the discussion complete. Otherwise, please start a new thread in this forum instead.
Message:
Previous Thread in C++ Forum Timeline: Need help with Array Validation
Next Thread in C++ Forum Timeline: Stacks - balanced parentheses





About Us | Contact Us | Advertise | Acceptable Use Policy
Forum Index | Build Custom RSS Feed


Follow us on Twitter


© 2011 DaniWeb® LLC