I wonder why this hasn't been locked yet? Well, I'll give a reason to lock it...
Here's my Java program I'm writing...
import java.io.*;
public class MagicSquareTester
{
public boolean isMagic(int arr[][])
{
int sums[] = new int[8];
for (int k = 0; k < 3; k++)
sums[0] += arr[k][0];
int magicSum = sums[0];
for (int k = 0; k < 3; k++)
sums[1] += arr[k][1];
if (magicSum != sums[1])
return false;
for (int k = 0; k < 3; k++)
sums[2] += arr[k][2];
if (magicSum != sums[2])
return false;
for (int k = 0; k < 3; k++)
sums[3] += arr[0][k];
if (magicSum != sums[3])
return false;
for (int k = 0; k < 3; k++)
sums[4] += arr[1][k];
if (magicSum != sums[4])
return false;
for (int k = 0; k < 3; k++)
sums[5] += arr[2][k];
if (magicSum != sums[5])
return false;
for (int k = 0; k < 3; k++)
sums[6] += arr[k][k];
if (magicSum != sums[6])
return false;
for (int k = 0; k < 3; k++)
sums[7] += arr[k][3 - k - 1];
if (magicSum != sums[7])
return false;
return true;
}
public void print(int arr[][])
{
for (int j = 0; j < arr.length; j++)
{
for (int k = 0; k < arr[j].length; k++)
System.out.print(arr[j][k] + " ");
System.out.println();
}
}
public static void main(String argv[])
{
int magic[][] = { {6,7,2}, {1,5,9}, {8,3,4} };
int notMagic[][] = { {1,7,2}, {6,5,9}, {3,8,4} };
MagicSquareTester tester = new MagicSquareTester();
tester.print(magic);
if ( tester.isMagic(magic))
System.out.println("This is a magic square");
else
System.out.println("This is NOT a magic square");
tester.print(notMagic);
if ( tester.isMagic(notMagic))
System.out.println("This is a magic square");
else
System.out.println("This is NOT a magic square");
}
}
*******************************************************************
I wonder why this hasn't been locked yet? Well, I'll give a reason to lock it...
Here's my Java program I'm writing...
import java.io.*;
public class MagicSquareTester
{
public boolean isMagic(int arr[][])
{
int sums[] = new int[8];
for (int k = 0; k < 3; k++)
sums[0] += arr[k][0];
int magicSum = sums[0];
for (int k = 0; k < 3; k++)
sums[1] += arr[k][1];
if (magicSum != sums[1])
return false;
for (int k = 0; k < 3; k++)
sums[2] += arr[k][2];
if (magicSum != sums[2])
return false;
for (int k = 0; k < 3; k++)
sums[3] += arr[0][k];
if (magicSum != sums[3])
return false;
for (int k = 0; k < 3; k++)
sums[4] += arr[1][k];
if (magicSum != sums[4])
return false;
for (int k = 0; k < 3; k++)
sums[5] += arr[2][k];
if (magicSum != sums[5])
return false;
for (int k = 0; k < 3; k++)
sums[6] += arr[k][k];
if (magicSum != sums[6])
return false;
for (int k = 0; k < 3; k++)
sums[7] += arr[k][3 - k - 1];
if (magicSum != sums[7])
return false;
return true;
}
public void print(int arr[][])
{
for (int j = 0; j < arr.length; j++)
{
for (int k = 0; k < arr[j].length; k++)
System.out.print(arr[j][k] + " ");
System.out.println();
}
}
public static void main(String argv[])
{
int magic[][] = { {6,7,2}, {1,5,9}, {8,3,4} };
int notMagic[][] = { {1,7,2}, {6,5,9}, {3,8,4} };
MagicSquareTester tester = new MagicSquareTester();
tester.print(magic);
if ( tester.isMagic(magic))
System.out.println("This is a magic square");
else
System.out.println("This is NOT a magic square");
tester.print(notMagic);
if ( tester.isMagic(notMagic))
System.out.println("This is a magic square");
else
System.out.println("This is NOT a magic square");
}
}
*******************************************************************
I wonder why this hasn't been locked yet? Well, I'll give a reason to lock it...
Here's my Java program I'm writing...
import java.io.*;
public class MagicSquareTester
{
public boolean isMagic(int arr[][])
{
int sums[] = new int[8];
for (int k = 0; k < 3; k++)
sums[0] += arr[k][0];
int magicSum = sums[0];
for (int k = 0; k < 3; k++)
sums[1] += arr[k][1];
if (magicSum != sums[1])
return false;
for (int k = 0; k < 3; k++)
sums[2] += arr[k][2];
if (magicSum != sums[2])
return false;
for (int k = 0; k < 3; k++)
sums[3] += arr[0][k];
if (magicSum != sums[3])
return false;
for (int k = 0; k < 3; k++)
sums[4] += arr[1][k];
if (magicSum != sums[4])
return false;
for (int k = 0; k < 3; k++)
sums[5] += arr[2][k];
if (magicSum != sums[5])
return false;
for (int k = 0; k < 3; k++)
sums[6] += arr[k][k];
if (magicSum != sums[6])
return false;
for (int k = 0; k < 3; k++)
sums[7] += arr[k][3 - k - 1];
if (magicSum != sums[7])
return false;
return true;
}
public void print(int arr[][])
{
for (int j = 0; j < arr.length; j++)
{
for (int k = 0; k < arr[j].length; k++)
System.out.print(arr[j][k] + " ");
System.out.println();
}
}
public static void main(String argv[])
{
int magic[][] = { {6,7,2}, {1,5,9}, {8,3,4} };
int notMagic[][] = { {1,7,2}, {6,5,9}, {3,8,4} };
MagicSquareTester tester = new MagicSquareTester();
tester.print(magic);
if ( tester.isMagic(magic))
System.out.println("This is a magic square");
else
System.out.println("This is NOT a magic square");
tester.print(notMagic);
if ( tester.isMagic(notMagic))
System.out.println("This is a magic square");
else
System.out.println("This is NOT a magic square");
}
}
*******************************************************************
EDIT: Due to popular request, I have modified my Java program. It is now complete. yes, it is worthless, but I guess some people just wanted to see the complete thing.