";
$valuesArray = Array('EMPTY',$_POST[a1],$_POST[a2],$_POST[a3],$_POST[a4],$_POST[a5],$_POST[a6],$_POST[a7],$_POST[a8],$_POST[a9],$_POST[b1],$_POST[b2],$_POST[b3],$_POST[b4],$_POST[b5],$_POST[b6],$_POST[b7],$_POST[b8],$_POST[b9],$_POST[c1],$_POST[c2],$_POST[c3],$_POST[c4],$_POST[c5],$_POST[c6],$_POST[c7],$_POST[c8],$_POST[c9],$_POST[d1],$_POST[d2],$_POST[d3],$_POST[d4],$_POST[d5],$_POST[d6],$_POST[d7],$_POST[d8],$_POST[d9],$_POST[e1],$_POST[e2],$_POST[e3],$_POST[e4],$_POST[e5],$_POST[e6],$_POST[e7],$_POST[e8],$_POST[e9],$_POST[f1],$_POST[f2],$_POST[f3],$_POST[f4],$_POST[f5],$_POST[f6],$_POST[f7],$_POST[f8],$_POST[f9],$_POST[g1],$_POST[g2],$_POST[g3],$_POST[g4],$_POST[g5],$_POST[g6],$_POST[g7],$_POST[g8],$_POST[g9],$_POST[h1],$_POST[h2],$_POST[h3],$_POST[h4],$_POST[h5],$_POST[h6],$_POST[h7],$_POST[h8],$_POST[h9],$_POST[i1],$_POST[i2],$_POST[i3],$_POST[i4],$_POST[i5],$_POST[i6],$_POST[i7],$_POST[i8],$_POST[i9]);
// THIS ARRAY WILL HAVE ALL THE VALUES FILLED OUT AT THE END
$solvedArray = Array('0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0');
$hsArray = Array('','','','','','','','');
$vsArray = Array('','','','','','','','');
$secArray = Array('','','','','','','','');
// FIRST CHECK TO SEE IF THE ANSWER IS ALREADY PROVIDED
for ($counter = 1; $counter <= 81; $counter++){
// CHECK IF THE VALUES ALREADY EXISTS AS ENETERD BY THE USER
if ($valuesArray[$counter] != 0){
$solvedArray[$counter] = $valuesArray[$counter];
}else {
$solvedArray[$counter] = Array('1','2','3','4','5','6','7','8','9');
}
}
echo "number ENTERED = " . checkIfFinished() . "
";
//LOOP TIMES
for ($i=0; $i<10; $i++){
// Reprocess all value arrays
processArrays();
}
// IF Unfinished Run Complex 3
if (checkIfFinished < 81){
for ($iterations = 1; $iterations <= 10; $iterations++){
hardPuzzleRows();
processArrays();
hardPuzzleColumns();
processArrays();
hardPuzzleSectors();
processArrays();
hardPuzzle2CellSectorSwap();
processArrays();
echo "ANSWERS FOUND = " . checkIfFinished() . " and POSSIBLE ANSWERS REMAINING = " . checkValuesRemaining() . "
";
}
}
printDebug();
printResults();
echo "";
// FIND OUT ALL POSSIBLE NUMBERS FOR EACH COORDINATE
function processArrays(){
global $solvedArray;
// global $valuesArray;
global $hsArray;
global $vsArray;
global $secArray;
for ($currentBox = 1; $currentBox <= 81; $currentBox++){
clearTempArrays();
// ONLY RUN THE LOOP IF THE VALUE DOES NOT ALREADY EXIST
// if ($valuesArray[$currentBox] == 0)
if (is_array($solvedArray[$currentBox])){
fillTempArrays($currentBox);
processPuzzle($currentBox);
}
}
}
function processPuzzle($currentBox){
global $solvedArray;
global $hsArray;
global $vsArray;
global $secArray;
for($tempCounter = 0; $tempCounter <= 8; $tempCounter++){
// check if any given spot is equal to one number and not an array. if it is equal to
// one number then remove that number from the array of possible number-answers for
// current box being addressed
if (is_array($solvedArray[$hsArray[$tempCounter]])){
// do nothing
}else {
// Get the integer from that box and remove it from the currentBox array of possible answers
$valueToRemove = $solvedArray[$hsArray[$tempCounter]];
if ($valueToRemove != ''){
// echo "CurrentBox $currentBox valueToRemove = $valueToRemove
";
$solvedArray[$currentBox][$valueToRemove - 1] = '0';
}
}
// Do the same thing for the vsArray
if (is_array($solvedArray[$vsArray[$tempCounter]])){
// do nothing
}else {
// Get the integer from that box and remove it from the currentBox array of possible answers
$valueToRemove = $solvedArray[$vsArray[$tempCounter]];
if ($valueToRemove != ''){
// echo "CurrentBox $currentBox valueToRemove VERTICAL= $valueToRemove
";
$solvedArray[$currentBox][$valueToRemove - 1] = '0';
}
}
// Do the same thing for the sector array
if (is_array($solvedArray[$secArray[$tempCounter]])){
// do nothing
}else {
// Get the integer from that box and remove it from the currentBox array of possible answers
$valueToRemove = $solvedArray[$secArray[$tempCounter]];
if ($valueToRemove != ''){
// echo "CurrentBox $currentBox valueToRemove SECTOR= $valueToRemove
";
$solvedArray[$currentBox][$valueToRemove - 1] = '0';
}
}
}
// Check how many values are in the currentBoxArray.
$answer = 0;
for ($currentValue = 0; $currentValue <= 8; $currentValue++){
if ($solvedArray[$currentBox][$currentValue] != 0){
$finalAnswer = $solvedArray[$currentBox][$currentValue];
$answer++;
}
}
if ($answer == 1){
// $valuesArray[$currentBox] = $finalAnswer;
$solvedArray[$currentBox] = $finalAnswer;
}
}
function hardPuzzle2CellSectorSwap(){
global $solvedArray;
global $secArray;
$sectorTopLefts = Array('1','4','7','28','31','34','55','58','61');
for ($arraySpot = 0; $arraySpot <= 8; $arraySpot++){
// FILL THE $secArray ARRAY
fillTempArrays($sectorTopLefts[$arraySpot]);
/*
echo "testing $secArray[0]
";
echo "testing $secArray[1]
";
echo "testing $secArray[2]
";
echo "testing $secArray[3]
";
echo "testing $secArray[4]
";
echo "testing $secArray[5]
";
echo "testing $secArray[6]
";
echo "testing $secArray[7]
";
echo "testing $secArray[8]
";
*/
// COUNT THE NUMBER OF CELLS WITH 2 AND ONLY 2 VALUES
$cellsWithTwo = Array();
$cellsWithMoreThanTwo = Array();
// IF THERE ARE EXACTLY 2 CELLS WITH ONLY 2 VALUES, THEN CHECK IF THEY HAVE THE SAME 2 VALUES.
$value1 = 0;
$value2 = 0;
$value3 = 0;
$value4 = 0;
// MOVE THROUGH EACH ARRAY OF EACH BOX IN THE SECTOR
for ($box = 0; $box <= 8; $box++){
// ONLY PROCESS THE BOX IF IT IS AN ARRAY
if (is_array($solvedArray[$secArray[$box]])){
$numValuesInCell = 0;
// IT'S AN ARRAY, SO COUNT THE NUMBER OF POSSIBLE VALUES, WE ARE LOOKING FOR TWO
for ($value = 0; $value <= 8; $value++){
if ($solvedArray[$secArray[$box]][$value] != 0){
$numValuesInCell++;
$val = $value + 1;
// echo "box = ". $secArray[$box] . " and value $val
";
}
}
// IF THERE ARE 2 VALUES IN CELL INCREASE THE COUNTER THAT IS TRACKING THE NUMBER OF
// CELLS IN THE SECTOR WITH 2 AND ONLY 2 VALUES
if ($numValuesInCell == 2){
array_push($cellsWithTwo, $secArray[$box]);
}else if ($numValuesInCell > 2){
array_push($cellsWithMoreThanTwo, $secArray[$box]);
}
}
}
/* echo "
";
echo "$cellsWithTwo[0]
";
echo "$cellsWithTwo[1]
";
echo "xxx " . count($cellsWithTwo) . "
";
echo "
";
*/
// IF THERE ARE EXACTLY 2 CELLS IN THE CURRENT SECTOR WITH 2 VALUES, THEN
// CHECK IF THOSE 2 CELLS HAVE THE SAME 2 VALUES
if (count($cellsWithTwo) == 2){
// GET THOSE VALUES FROM THE FIRST CELL
for ($i=0; $i<=8; $i++){
if ($solvedArray[$cellsWithTwo[0]][$i] != 0){
if ($value1 == 0){
$value1 = $solvedArray[$cellsWithTwo[0]][$i];
} else {
$value2 = $solvedArray[$cellsWithTwo[0]][$i];
}
}
}
// GET THOSE VALUES FROM THE SECOND CELL
for ($i=0; $i<=8; $i++){
if ($solvedArray[$cellsWithTwo[1]][$i] != 0){
if ($value3 == 0){
$value3 = $solvedArray[$cellsWithTwo[1]][$i];
} else {
$value4 = $solvedArray[$cellsWithTwo[1]][$i];
}
}
}
// CHECK IF THE TWO VALUES IN THE 2 DIFFERENT CELLS ARE THE SAME
if (($value1 == $value3) && ($value2 == $value4)){
//echo "algorithm matched
";
// REMOVE THE VALUES FROM THE OTHER CELLS IN THE SAME SECTOR
for ($cellToChange = 0; $cellToChange < count($cellsWithMoreThanTwo); $cellToChange++){
// echo "
box to chane = " . $cellsWithMoreThanTwo[$cellToChange] . " xx ";
// echo "and values to remove = $value1 and $value2
";
// THIS MIGHT BE A PROBLEM IF IT LEAVES ONLY 1 VALUE IN THE CELL
$solvedArray[$cellsWithMoreThanTwo[$cellToChange]][$value1 - 1] = '0';
$solvedArray[$cellsWithMoreThanTwo[$cellToChange]][$value2 - 1] = '0';
}
}
}
}
}
function hardPuzzleSectors(){
global $solvedArray;
global $secArray;
$sectorTopLefts = Array('1','4','7','28','31','34','55','58','61');
for ($arraySpot = 0; $arraySpot <= 8; $arraySpot++){
// FILL THE $secArray ARRAY
fillTempArrays($sectorTopLefts[$arraySpot]);
// echo " CURRENT SECTOR TOP LEFT = " . $secArray[0] . " END
";
// MOVE THROUGH EACH BOX IN THE SECTOR. THOSE BOXES ARE PROVIDED SEQUENTIALLY BY THE $secArray
// WHICH IS FILLED USING THE FUNCTION fillTempArrays($box) WHERE $box IS THE TOP LEFT BOX OF THE SECTOR
for ($box = 0; $box <= 8; $box++){
// ONLY PROCESS THE BOX IF IT IS AN ARRAY
if (is_array($solvedArray[$secArray[$box]])){
// echo " WE have an array " . $secArray[$box] . " END
";
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY IN THE SAME sECTOR THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN SECTOR CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN SECTOR. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
// echo " value = $value --";
for ($baseBox = $box; $baseBox<=8; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
// echo " - " . $secArray[$baseBox] . " - ";
if (is_array($solvedArray[$secArray[$baseBox]])){
// echo " is array ";
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$secArray[$baseBox]][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$secArray[$baseBox]] == $value + 1){
$val = $value + 1;
// echo "GOT HERE " . $val . "----";
$appearances++;
}
}
}
// echo "
";
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
// echo " -->-->-->--> PFV = $possibleFinalValue and box = " . $secArray[$possibleBox] . "
";
$solvedArray[$secArray[$possibleBox]] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 8;
}
}
}
}
function hardPuzzleColumns(){
global $solvedArray;
// RUN IT ON THE FIRST COLUMN (1-73)
for ($box = 1; $box <= 73; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=73; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 73;
}
}
// RUN IT ON THE SECOND COLUMN (2-74)
for ($box = 2; $box <= 74; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=74; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 74;
}
}
// RUN IT ON THE THIRD COLUMN (3-75)
for ($box = 3; $box <= 75; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=75; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 75;
}
}
// RUN IT ON THE FOURTH COLUMN (4-76)
for ($box = 4; $box <= 76; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=76; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 76;
}
}
// RUN IT ON THE FIFTH COLUMN (5-77)
for ($box = 5; $box <= 77; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=77; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 77;
}
}
// RUN IT ON THE SIXTH COLUMN (6-78)
for ($box = 6; $box <= 78; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=78; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 78;
}
}
// RUN IT ON THE SEVENTH COLUMN (7-79)
for ($box = 7; $box <= 79; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=79; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 79;
}
}
// RUN IT ON THE EIGHTH COLUMN (8-80)
for ($box = 8; $box <= 80; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=80; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 80;
}
}
// RUN IT ON THE NINTH COLUMN (9-81)
for ($box = 9; $box <= 81; $box+=9){
// GET THE FIRST ARRAY IN THE BOXES OF THIS COLUMN
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME COLUMN THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN COLUMN CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN COLUMN. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE COLUMN
for ($baseBox = $box; $baseBox<=81; $baseBox+=9){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE COLUMN TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE COLUMN AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE COLUMN.
$box = 81;
}
}
}
function hardPuzzleRows(){
global $solvedArray;
// RUN IT ON THE FIRST ROW (1-9)
for ($box = 1; $box <= 9; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=9; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 9;
}
}
// RUN IT ON THE SECOND ROW (10 - 18)
for ($box = 10; $box <= 18; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=18; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 18;
}
}
// RUN IT ON THE THIRD ROW (19 - 27)
for ($box = 19; $box <= 27; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=27; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 27;
}
}
// RUN IT ON THE FOURTH ROW (28 - 36)
for ($box = 28; $box <= 36; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=36; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 36;
}
}
// RUN IT ON THE FIFTH ROW (37 - 45)
for ($box = 37; $box <= 45; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=45; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 45;
}
}
// RUN IT ON THE SIXTH ROW (46 - 54)
for ($box = 46; $box <= 54; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=54; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 54;
}
}
// RUN IT ON THE SEVENTH ROW (55 - 63)
for ($box = 55; $box <= 63; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=63; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 63;
}
}
// RUN IT ON THE EIGHTH ROW (64 - 72)
for ($box = 64; $box <= 72; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=72; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 72;
}
}
// RUN IT ON THE NINTH ROW (73 - 81)
for ($box = 73; $box <= 81; $box++){
// GET THE FIRST ARRAY IN THE BOXES OF THIS ROW
if (is_array($solvedArray[$box])){
// COMPARE EACH VALUE OF THE FIRST ARRAY YOU COME ACROSS TO THE CORRESPONDING VALUES
// OF EACH ARRAY THAT IN THE SAME ROW THAT COME AFTER THIS ARRAY. IGNORE BOXES THAT ARE
// NOT ARRAYS - i.e. THAT HAVE THEIR VALUES SET
for ($value = 0; $value <= 8; $value++){
// THIS ALGORITHM TRACKS IF ONLY ONE BOX IN A GIVEN ROW CAN BE A VALUE
// ACCORDINGLY WE MUST KEEP TRACK OF THAT VALUE AND DETERMINE IF IT APPEARS ONLY ONCE AS
// A POSSIBLE VALUE IN A GIVEN ROW. IF SO, THEN IT BECOMES THE FINAL VALUE FOR THE
// CORRESPONDING BOX.
$possibleFinalValue = 0;
// IF THIS IS 1 AFTER THE BELOW RELEVANT LOOP COMPLETES WE
// KNOW WE HAVE A FINAL VALUE FOR A BOX THAT WE DID NOT HAVE FROM THE ABOVE ALGORITHMS
$appearances = 0;
// WE WILL HAVE TO KNOW TO WHICH BOX THE NEW VALUE BELONGS
$possibleBox = 0;
// RUN IT FROM THE CURRENT BOX TO THE LAST BOX OF THE ROW
for ($baseBox = $box; $baseBox<=81; $baseBox++){
// COMPARE $box-$value TO $baseBox-$value, BUT ONLY IF $baseBox IS AN ARRAY
// WE ALREADY KNOW THAT $box IS AN ARRAY
if (is_array($solvedArray[$baseBox])){
// HERE'S THE MEAT: IF THE VALUE OF $box OR! $baseBox IS 1-9 (NOT 0)
// THEN RECOGNIZE THAT FACT AND STORE THE VALUE.
if ($solvedArray[$baseBox][$value] != 0){
$possibleFinalValue = $value + 1;
$appearances++;
$possibleBox = $baseBox;
}
} else {
if ($solvedArray[$baseBox] == $value + 1){
$appearances++;
}
}
}
if (($appearances == 1) && ($possibleFinalValue != 0)){
// WE'VE GOT A NEW FINAL VALUE!
$solvedArray[$possibleBox] = $possibleFinalValue;
}
}
// SET THIS TO THE LAST BOX OF THE ROW TO BREAK OUT OF THE LOOP ONCE WE KNOW WE HAVE FOUND THE FIRST
// ARRAY IN THE ROW AND WILL THEREFORE HAVE PROCESSED ALL THE VALUES FOR ALL THE BOXES IN THE ROW.
$box = 81;
}
}
}
function clearTempArrays(){
global $hsArray;
global $vsArray;
global $secArray;
$hsArray[0] = '';
$hsArray[1] = '';
$hsArray[2] = '';
$hsArray[3] = '';
$hsArray[4] = '';
$hsArray[5] = '';
$hsArray[6] = '';
$hsArray[7] = '';
$vsArray[0] = '';
$vsArray[1] = '';
$vsArray[2] = '';
$vsArray[3] = '';
$vsArray[4] = '';
$vsArray[5] = '';
$vsArray[6] = '';
$vsArray[7] = '';
$secArray[0] = '';
$secArray[1] = '';
$secArray[2] = '';
$secArray[3] = '';
$secArray[4] = '';
$secArray[5] = '';
$secArray[6] = '';
$secArray[7] = '';
$secArray[8] = '';
}
function fillTempArrays($currentBox){
global $hsArray;
global $vsArray;
global $secArray;
// Find those values in $hsArray that are > then the last box in the current row
// (which will be a multiple of 9) and then jump back to the beginning of the row
$currentRow = floor(($currentBox) / 9.1);
for ($tempCounter = 1; $tempCounter < 9; $tempCounter++){
if ($currentBox + $tempCounter <= ($currentRow * 9 + 9)){
$hsArray[$tempCounter - 1] = $currentBox + $tempCounter;
}else {
$hsArray[$tempCounter - 1] = (($currentBox + $tempCounter) - (($currentRow + 1) * 9)) + ($currentRow * 9);
}
}
// ADD Multiple of 9 to the $vsArray
for ($multCounter = 1; $multCounter < 9; $multCounter++){
$vsArray[$multCounter - 1] = $currentBox + ($multCounter * 9);
}
// Find those values in $vsArray that are > 81 and then modulus by 81
for ($tempCounter = 1; $tempCounter < 9; $tempCounter++){
if ($vsArray[$tempCounter - 1] > 81){
$vsArray[$tempCounter -1] = $vsArray[$tempCounter - 1] % 81;
}
}
// Find the other box numbers in the currentBox's sector
switch($currentBox){
// BEGIN Sector 1
case 1:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 2:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 3:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 10:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 11:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 12:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 19:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 20:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
case 21:
$secArray = Array ('1','2','3','10','11','12','19','20','21');
break;
// END Sector 1
// BEGIN SECTOR 2
case 4:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 5:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 6:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 13:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 14:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 15:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 22:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 23:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
case 24:
$secArray = Array ('4','5','6','13','14','15','22','23','24');
break;
// END SECTOR 2
// BEGIN SECTOR 3
case 7:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 8:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 9:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 16:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 17:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 18:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 25:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 26:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
case 27:
$secArray = Array ('7','8','9','16','17','18','25','26','27');
break;
// END SECTOR 3
// BEGIN SECTOR 4
case 28:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 29:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 30:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 37:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 38:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 39:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 46:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 47:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
case 48:
$secArray = Array ('28','29','30','37','38','39','46','47','48');
break;
// END SECTOR 4
// BEGIN SECTOR 5
case 31:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 32:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 33:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 40:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 41:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 42:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 49:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 50:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
case 51:
$secArray = Array ('31','32','33','40','41','42','49','50','51');
break;
// END SECTOR 5
// BEGIN SECTOR 6
case 34:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 35:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 36:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 43:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 44:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 45:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 52:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 53:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
case 54:
$secArray = Array ('34','35','36','43','44','45','52','53','54');
break;
// END SECTOR 6
// BEGIN SECTOR 7
case 55:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 56:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 57:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 64:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 65:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 66:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 73:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 74:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
case 75:
$secArray = Array ('55','56','57','64','65','66','73','74','75');
break;
// END SECTOR 7
// BEGIN SECTOR 8
case 58:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 59:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 60:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 67:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 68:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 69:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 76:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 77:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
case 78:
$secArray = Array ('58','59','60','67','68','69','76','77','78');
break;
// END SECTOR 8
// BEGIN SECTOR 9
case 61:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 62:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 63:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 70:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 71:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 72:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 79:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 80:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
case 81:
$secArray = Array ('61','62','63','70','71','72','79','80','81');
break;
// END SECTOR 9
}
}
function printResults(){
global $solvedArray;
echo "";
}
function checkIfFinished(){
global $solvedArray;
$count = 81;
for ($i = 1; $i<=81; $i++){
if (is_array($solvedArray[$i])){
$count--;
}
}
return $count;
}
function checkValuesRemaining(){
global $solvedArray;
$counter = 0;
for ($box=1; $box<=81; $box++){
if (is_array($solvedArray[$box])){
for ($value = 0; $value <=8; $value++){
if ($solvedArray[$box][$value] != 0){
$counter++;
}
}
}
}
return $counter;
}
function printDebug(){
global $solvedArray;
// global $valuesArray;
// echo "currentBox = $currentBox : currentRow = $currentRow
";
// print_r($hsArray);
// echo "
";
// print_r($vsArray);
// echo "
";
for ($counter = 1; $counter <= 81; $counter++){
if (($counter % 9) + 7 == 14){
echo "Box $counter possible answers = ";
print_r($solvedArray[$counter]);
echo "
";
} else{
echo "Box $counter possible answers = ";
print_r($solvedArray[$counter]);
echo "
";
}
if ($counter % 9 == 0){
echo "
";
}
}
echo "
";
}
?>