-
Notifications
You must be signed in to change notification settings - Fork 0
/
magicsquare.cpp
226 lines (182 loc) · 13.6 KB
/
magicsquare.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
/**************************************************************************
* ASSIGNMENT 2 - MAGIC SQUARE PROGRAM
*
* This program will create a magic square of an order chosen by the user.
* First the user will be prompted to enter a valid number which will be
* passed on as the order for the dynamic array used to create the magic
* square. This array will be filled using the method specified by French
* diplomat de la Loubère.
*
* The working and specifications are mentioned in the comments before each function.
*
* Written by Sindhura L Boppudi (slb170330)
* CS 1337. 004
* Professor: John Cole
**************************************************************************/
//HEADERS
#include "stdafx.h"
#include <iostream>
#include <iomanip>
/*FUNCTION PROTOTYPES******************************************************
* There will be two functions in this program:
*
* (1) To get users input:
* The user will be prompted to enter a number. The number will be validated
* and returned to the main function.
*
* (2) To calculate and display the magic square:
* This function will take the user's input, use it to create a dynamic array
* of the same order, and proceed to display the magic square to the user.
* It will also display the magic sum of the magic square.
*
***************************************************************************/
int getUserInput();
void calculateSquare(int);
using namespace std;
int main()
{
int userInput;
userInput = getUserInput();
//Until user ends program, keep asking for input and printing magic sqaure
while (userInput != 0)
{
cout << " " << endl;
calculateSquare(userInput);
userInput = getUserInput();
}
system("pause");
return 0;
}
/*WORKING************************************************************************
* The user will be prompted to enter an odd number larger than or equal to 3
* If they enter a non-integer character, an even number or a number less than 3,
* they will be shown an error message and re-prompted.
* If 0 is entered, the user will exit the program.
********************************************************************************/
int getUserInput()
{
int userInput;
cout << "*Enter an odd number greater than or equal to 3, or 0 to exit: ";
cin >> userInput;
//End program if user enters 0
if (userInput == 0)
return 0;
//VALIDATE INPUT.
while ((userInput < 3) || userInput % 2 == 0 || cin.fail())
{
//End program if user enters 0
if (userInput == 0)
return 0;
cout << "Input is invalid." << endl;
//Display that only numbers must be entered if user enters a letter/any other character
if (cin.fail())
{
cout << "Only numbers must be entered." << endl;
//Clear input stored
cin.clear();
cin.ignore(100, '\n');
//Display common error message and ask user for input again
cout << "*Enter an odd number greater than or equal to 3, or 0 to exit: ";
cin >> userInput;
}
//Display that user must enter an odd number if number entered is even
if (userInput % 2 == 0)
{
cout << "Number must be an odd number." << endl;
//Display common error message and ask user for input again
cout << "*Enter an odd number greater than or equal to 3, or 0 to exit: ";
cin >> userInput;
}
//Display that number must be above 3 or 0
if (userInput < 3 && userInput != 0)
{
cout << "Number must be 3 or above." << endl;
//Display common error message and ask user for input again
cout << "*Enter an odd number greater than or equal to 3, or 0 to exit: ";
cin >> userInput;
}
}
return userInput;
}
/*WORKING************************************************************************
* The user input will act as the order for the dynamic array created here.
*
* To Fill Square:
* Step 1: 1 is assigned to middle square of the first row (order/2 +1)
* Step 2: The next number is filled by moving diagonally up and right.
*
* NOTE 1: If moving diagonally results in exiting the magic square, the next
* number is filled by wrapping around the square.
* NOTE 2: If the spot which is diagonal from the current number is filled,
* the spot below the current number is filled and then Step 2 continues.\
*
* The last element of the square is not filled by the method layed out above,
* and must be filled in seperately.
*
*******************************************************************************/
void calculateSquare(int input)
{
int ORDER = input;
//Create 2D Dynamic Array
int* magicSquare = new int[ORDER * ORDER];
//Initialize array so all elements are 0
for (int ix = 0; ix < ORDER * ORDER; ix++)
magicSquare[ix] = 0;
int currentRow = 0; //For current element
int currentCol = (ORDER / 2); //For current element
int newRow, newCol; //Variables to determine where the next element should be entered
int magicSum = 0; //To store the magic sum
//The Last element must be filled in seperately
//It will always be on the opposite side of 1.
magicSquare[(ORDER - 1) * ORDER + currentCol] = ORDER * ORDER;
//Loop to fill in elements diagonally in the array
for (int arrayElement = 1; arrayElement < ORDER * ORDER; arrayElement++)
{
magicSquare[currentRow * ORDER + currentCol] = arrayElement;
//Assign new row and column
//These variables are needed to test if the array is filled or not, later in the code
newRow = currentRow - 1;
newCol = currentCol + 1;
//If the new row or new column causes the element to exit the box then WRAP AROUND
//Check if row is within the box
if (newRow < 0)
newRow = ORDER - 1;
//Check if column is within the box
if (newCol > (ORDER - 1))
newCol = 0;
//If array spot is filled, go down one space from the current element
//Otherwise assign new row and column values to current row and col variables for the loop
if (!magicSquare[newRow * ORDER + newCol] == 0)
{
newRow = currentRow + 1;
newCol = currentCol;
if (newRow > (ORDER - 1))
newRow = 0;
}
if (magicSquare[newRow * ORDER + newCol] == 0)
{
currentRow = newRow;
currentCol = newCol;
}
}
//Print the magic square
for (int rowCount = 0; rowCount < ORDER; rowCount++)
{
for (int colCount = 0; colCount < ORDER; colCount++)
{
cout << magicSquare[rowCount * ORDER + colCount] << " " ;
}
cout << endl;
}
//Calculate Magic Sum
//Set the column as a constant and move through the row
for (int tempRow = 0; tempRow < ORDER; tempRow++)
{
magicSum += magicSquare[tempRow * ORDER + 0];
}
//Display the Magic Sum
cout << " " << endl;
cout << "The Magic Sum of a Magic Square of order " << ORDER << "x" << ORDER << " is " << magicSum << endl;
cout << " " << endl;
delete[] magicSquare;
}