var sudokufound = 0;
  
  function getbox(row, col) {
    return document.getElementById('tb' + row + col).value;
  }
  
  function setbox(row, col, value) {
    document.getElementById('tb' + row + col).value = value;
  }

  function getboxpossible(row, col) {
    return document.getElementById('tb' + row + col + 'mini').value;
  }

  function setboxpossible(row, col, value) {
    document.getElementById('tb' + row + col + 'mini').value = value;
  }
  
  function clearsudoku() {
    sudokufound = 0;
    for (x = 0; x <= 8; x++) {
      for (y = 0; y <= 8; y++) {
        setbox(x, y, '');
        setboxpossible(x, y, '');
      }
    }
  }
  
  function countfound() {
    found = 0;
    for (row = 0; row <= 8; row++) {
      for (col = 0; col <= 8; col++) {
        tmp = getbox(row, col);
         if (IsNumeric(tmp)) {
           found++;
         }
      }
    }
    return found;
  }

  
  
  
  function fillsudoku1() {
    clearsudoku();
  
    setbox(0, 2, 6);
    setbox(0, 3, 2);
    setbox(0, 6, 5);
    setbox(0, 7, 8);

    setbox(1, 2, 5);
    setbox(1, 3, 4);
    setbox(1, 5, 6);
    setbox(1, 7, 9);
    
    setbox(2, 4, 8);
    setbox(2, 8, 1);    
    
    setbox(3, 4, 7);

    setbox(4, 0, 7);
    setbox(4, 3, 8);
    setbox(4, 5, 2);    
    setbox(4, 8, 4);

    setbox(5, 4, 3);
    
    setbox(6, 0, 3);
    setbox(6, 4, 4);    
    
    setbox(7, 1, 5);
    setbox(7, 3, 3);
    setbox(7, 5, 9);
    setbox(7, 6, 1);

    setbox(8, 1, 6);
    setbox(8, 2, 1);
    setbox(8, 5, 5);
    setbox(8, 6, 8);
    
    
    sudokufound = countfound();
    }

    
    
  function fillsudoku2() {
    clearsudoku();
  
    setbox(0, 1, 5);
    setbox(0, 2, 3);
    setbox(0, 5, 4);
    setbox(0, 8, 6);

    setbox(1, 2, 4);
    setbox(1, 7, 8);
    setbox(1, 8, 2);
    
    setbox(2, 1, 9);
    setbox(2, 5, 6);
    setbox(2, 6, 3);    
    
    setbox(3, 0, 3);
    setbox(3, 2, 6);
    setbox(3, 4, 5);

    setbox(4, 3, 9);    
    setbox(4, 5, 2);

    setbox(5, 4, 3);
    setbox(5, 6, 1);
    setbox(5, 8, 4);    
    
    setbox(6, 2, 7);
    setbox(6, 3, 3);
    setbox(6, 7, 9);
    
    setbox(7, 0, 5);
    setbox(7, 1, 3);
    setbox(7, 6, 2);
    
    setbox(8, 0, 6);
    setbox(8, 3, 2);
    setbox(8, 6, 7);
    setbox(8, 7, 1);

    sudokufound = countfound();
    }
    
  function fillsudoku3() {
    clearsudoku();
  
    setbox(0, 2, 1);
    setbox(0, 7, 7);
    
    setbox(1, 2, 7);
    setbox(1, 3, 8);
    setbox(1, 4, 4);
    setbox(1, 6, 2);

    setbox(2, 1, 6);
    setbox(2, 8, 9);
    
    setbox(3, 0, 2);
    setbox(3, 2, 8);
    setbox(3, 4, 5);
    setbox(3, 6, 4);    
    setbox(3, 8, 3);    
    
    setbox(4, 1, 9);
    setbox(4, 7, 8);
    
    setbox(5, 0, 6);
    setbox(5, 2, 3);
    setbox(5, 4, 7);
    setbox(5, 6, 9);    
    setbox(5, 8, 2);    
    
    setbox(6, 0, 4);    
    setbox(6, 7, 9);    
    
    setbox(7, 2, 6);
    setbox(7, 4, 2);
    setbox(7, 5, 5);
    setbox(7, 6, 3);

    setbox(8, 1, 8);
    setbox(8, 6, 1);
    setbox(8, 7, 2);
    
    
    sudokufound = countfound();
    }


    
    
  function IsNumeric(strString)
  //  check for valid numeric strings	
  {
    var strValidChars = '0123456789';
    var strChar;
    var blnResult = true;

    if (strString.length == 0) return false;

    //  test strString consists of valid characters listed above
    for (i = 0; i < strString.length && blnResult == true; i++)
      {
      strChar = strString.charAt(i);
      if (strValidChars.indexOf(strChar) == -1)
         {
         blnResult = false;
         }
      }
    return blnResult;
  }



  //tjekker række for mulige
  function checkrow(row) {
    var tmpint;

    // tjek
    rowpossible = new String('123456789');
    for (tempcol = 0; tempcol <= 8; tempcol++) {
      tmpint = getbox(row, tempcol);
      if (IsNumeric(tmpint)) {
        rowpossible = rowpossible.replace(tmpint, '');
		
    		//opdater
    		for (temp2col = 0; temp2col <= 8; temp2col++) {
          if (getbox(row, temp2col) == '') {
            tempstr = getboxpossible(row, temp2col);
            if (tempstr == '') tempstr = rowpossible;
            tempstr = tempstr.replace(tmpint, '');
            setboxpossible(row, temp2col, tempstr);
          } else {
            setboxpossible(row, temp2col, '');
          }
        }
      }
    }
  }

  //tjekker kolonner for mulige
  function checkcol(col) {
    var tmpint;

    // tjek
    colpossible = new String('123456789');
    for (temprow = 0; temprow <= 8; temprow++) {
      tmpint = getbox(temprow, col);
      if (IsNumeric(tmpint)) {
        colpossible = colpossible.replace(tmpint, '');
		
    		//opdater
    		for (temp2row = 0; temp2row <= 8; temp2row++) {
          if (getbox(temp2row, col) == '') {
            tempstr = getboxpossible(temp2row, col);
            if (tempstr == '') tempstr = colpossible;
            tempstr = tempstr.replace(tmpint, '');
            setboxpossible(temp2row, col, tempstr);
          } else {
            setboxpossible(temp2row, col, '');
          }
        }
      }
    }
  }
  
  function getblockstartrow(block) {
    switch(block) {
      case 1:
        startrow = 0;
        break
      case 2:
        startrow = 0;
        break
      case 3:
        startrow = 0;
        break
      case 4:
        startrow = 3;
        break
      case 5:
        startrow = 3;
        break
      case 6:
        startrow = 3;
        break
      case 7:
        startrow = 6;
        break
      case 8:
        startrow = 6;
        break
      case 9:
        startrow = 6;
        break
    }
    
    return startrow;
  }
  
  function getblockstartcol(block) {
    switch(block) {
      case 1:
        startcol = 0;
        break
      case 2:
        startcol = 3;
        break
      case 3:
        startcol = 6;
        break
      case 4:
        startcol = 0;
        break
      case 5:
        startcol = 3;
        break
      case 6:
        startcol = 6;
        break
      case 7:
        startcol = 0;
        break
      case 8:
        startcol = 3;
        break
      case 9:
        startcol = 6;
        break
    }

    return startcol;
  }
  
  //tjek blokker for mulige
  function checkblock(block) {
    var startrow;
    startrow = getblockstartrow(block);
    var startcol;
    startcol = getblockstartcol(block);
    var tmpint;
    boxpossible = new String('123456789');
    
    //tjek
 		for (row = startrow; row <= (startrow + 2); row++) {
   		for (col = startcol; col <= (startcol + 2); col++) {
        tmpint = getbox(row, col);
        if (IsNumeric(tmpint)) {
          boxpossible = boxpossible.replace(tmpint, '');
          
          //opdater
       		for (row2 = startrow; row2 <= (startrow + 2); row2++) {
         		for (col2 = startcol; col2 <= (startcol + 2); col2++) {
              if (getbox(row2, col2) == '') {
                tempstr = getboxpossible(row2, col2);
                if (tempstr == '') tempstr = boxpossible;
                tempstr = tempstr.replace(tmpint, '');
                setboxpossible(row2, col2, tempstr);
              } else {
                setboxpossible(row2, col2, '');
              }
            }
          }
        }
      }
    }
  }
  
  function findsingles() {
    var singlecount = 0;
    
 		for (row = 0; row <= 8; row++) {
   		for (col = 0; col <= 8; col++) {
        thisboxpossible = getboxpossible(row, col);
        if (thisboxpossible.length == 1) {
          if (getbox(row, col) == '') {
            setbox(row, col, thisboxpossible);
            setboxpossible(row, col, '');
            singlecount++;
          }
        }
      }
    }
    
    return singlecount; 
  }
  


  function findblockpairs(block, row, col) {
    //checkblock(block);
    
    var startrow;
    startrow = getblockstartrow(block);
    var startcol;
    startcol = getblockstartcol(block);
    
    
    gofind = false;
    
    
    //hent alle mulige i block'en (så jeg kun skal tjekke DOM en gang)
    if (block != 'undefined') {
      var possibles = new Array();
      var boxno = 1;
      for (row = startrow; row <= (startrow + 2); row++) {
        for (col = startcol; col <= (startcol + 2); col++) {
          possibles[boxno] = getboxpossible(row, col);
          boxno++;
        }
      }
      gofind = true;
    }

    //row
    if (row != 'undefined') {
    }
    
    //col
    if (col != 'undefined') {
    }


    
    if (gofind) {
      //find alle de tal der optræder præcis to gange
      var twoInstances = new Array();
      var twoInstancesCount = 0;
      for (number = 1; number <= 9; number++) {
        numberCount = 0;
        for (boxno = 1; boxno <= 9; boxno++) {
          if (possibles[boxno].indexOf(number) != -1) {
            numberCount++;
          }
        }

        if (numberCount == 2) {
          twoInstances[twoInstancesCount] = number;
          twoInstancesCount++;
        }
      }
      
      //løb alle dobbelttal igennem
      var pairsNo1 = Array();
      var pairsNo2 = Array();
      var pairsCount = 0;
      for (i = 0; i < twoInstancesCount; i++) {
        //alert(twoInstances[i] + ' optræder 2 gange');
        
        //tjekker først om det her tal allerede er konstateret at være et par.
        checkThisNo = true;
        if (pairsCount > 0) {
          for (j = 0; j <= pairsCount; j++) {
            if (twoInstances[i] == pairsNo1[j] || twoInstances[i] == pairsNo2[j]) {
            checkThisNo = false;
            }
          }
        }
        
        if (checkThisNo) {
          //løb boxene igennem og find det første dobbelttal
          for (boxno = 1; boxno <= 9; boxno++) {
            if (possibles[boxno].indexOf(twoInstances[i]) != -1) {
              //det første dobbettal er i denne box
              //se om et andet dobbelttal er i samme box
              for (j = 0; j < twoInstancesCount; j++) {
                if (i != j) {
                  if (possibles[boxno].indexOf(twoInstances[j]) != -1) {
                    //alert(twoInstances[i] + ' og ' + twoInstances[j] + ' er i samme box - første gang');
                    //to dobbelttal i samme box... det skal ske to gange
                    //fortsæt med at løbe bokse igennem fra næste box
                    for (boxno2 = boxno+1; boxno2 <= 9; boxno2++) {
                      // er begge tal igen i samme box?
                      if (possibles[boxno2].indexOf(twoInstances[i]) != -1) {
                        if (possibles[boxno2].indexOf(twoInstances[j]) != -1) {
                        //vi har fundet et par...
                        //alert(twoInstances[i] + ' og ' + twoInstances[j] + ' er et par');
                        pairsNo1[pairsCount] = twoInstances[i];
                        pairsNo2[pairsCount] = twoInstances[j];
                        pairsCount++;
                        }
                      }
                    }
                  }
                }
              }
              boxno=10; //vi skal kun finde første tal en gang
            }
          }
        }
      }
      
      //find de boxe med parret i og fjern alle andre tal
      for (i = 0; i < pairsCount; i++) {
        //block
        if (block != 'undefined') {
          for (row = startrow; row <= (startrow + 2); row++) {
            for (col = startcol; col <= (startcol + 2); col++) {
              tmpstr = getboxpossible(row, col);
              if (tmpstr.indexOf(pairsNo1[pairsCount-1]) != -1) {
                //gå alle andre tal igennem
                for (j = 1; j <= 9; j++) {
                  if (j != pairsNo1[pairsCount-1] && j != pairsNo2[pairsCount-1]) {
                    tmpstr = tmpstr.replace(j, '');
                  }
                }
                setboxpossible(row, col, tmpstr);
              }
            }
          }
        }
        
        //row
        if (row != 'undefined') {
        }
        
        //col
        if (col != 'undefined') {
        }
        
      }
    }

  }  


  
  function findblocksingles(block) {
    checkblock(block);
    
    var startrow;
    startrow = getblockstartrow(block);
    var startcol;
    startcol = getblockstartcol(block);

    var singlecount = 0;
    
    for (i = 1; i <= 9; i++) {
      countinstances = 0;
      //tæl
   		for (row = startrow; row <= (startrow + 2); row++) {
     		for (col = startcol; col <= (startcol + 2); col++) {
          possibles = getboxpossible(row, col);
          if (possibles.indexOf(i) != -1) {
            countinstances++;
          }
        }
      }
      
      //ret
      if (countinstances == 1) {
     		for (row = startrow; row <= (startrow + 2); row++) {
       		for (col = startcol; col <= (startcol + 2); col++) {
            possibles = getboxpossible(row, col);
            if (possibles.indexOf(i) != -1) {
              setbox(row, col, i);
              setboxpossible(row, col, '');
              singlecount++;
            }
          }
        }
      }
    }

    return singlecount;
  }

  function findcolsingles(col) {
    checkcol(col);
    var singlecount = 0;

    // tæl
    for (i = 1; i <= 9; i++) {
      countinstances = 0;
      for (row = 0; row <= 8; row++) {
        possibles = getboxpossible(row, col);
        if (possibles.indexOf(i) != -1) {
          countinstances++;
        }
      }
      
      //ret
      if (countinstances == 1) {
        for (row = 0; row <= 8; row++) {
          possibles = getboxpossible(row, col);
          if (possibles.indexOf(i) != -1) {
            setbox(row, col, i);
            setboxpossible(row, col, '');
            singlecount++;
          }
        }
      }
    }

    return singlecount;
  }



  function findrowsingles(row) {
    checkrow(row);
    var singlecount = 0;

    // tæl
    for (i = 1; i <= 9; i++) {
      countinstances = 0;
      for (col = 0; col <= 8; col++) {
        possibles = getboxpossible(row, col);
        if (possibles.indexOf(i) != -1) {
          countinstances++;
        }
      }
      
      //ret
      if (countinstances == 1) {
        for (col = 0; col <= 8; col++) {
          possibles = getboxpossible(row, col);
          if (possibles.indexOf(i) != -1) {
            setbox(row, col, i);
            setboxpossible(row, col, '');
            singlecount++;
          }
        }
      }
    }

    return singlecount;
  }
  
  






  
  function sudokupass() {
 		for (row = 0; row <= 8; row++) {
      checkrow(row);
    }

 		for (col = 0; col <= 8; col++) {
      checkcol(col);
    }

 		for (box = 1; box <= 9; box++) {
      checkbox(box);
    }
    
    foundnow = findsingles()

    sudokufound = sudokufound + foundnow;
    alert('Fundet i alt: ' + sudokufound + '. Fundet nu: ' + foundnow);
  }


  function sudokupass2() {
    foundnow = 0;

 		for (row = 0; row <= 8; row++) {
      foundnow = foundnow + findrowsingles(row);
    }
    
    
 		for (col = 0; col <= 8; col++) {
      foundnow = foundnow + findcolsingles(col);
    }

 		for (block = 1; block <= 9; block++) {
      foundnow = foundnow + findblocksingles(block);
    }
    
    
    foundnow = foundnow + findsingles()
    
    sudokufound = sudokufound + foundnow;
    alert('Fundet i alt: ' + sudokufound + '. Fundet nu: ' + foundnow);
  }
  
  
  function findpairs() {
 		for (block = 1; block <= 9; block++) {
      findblockpairs(block);
    }
  }
  
  


function solve() {
  alert('hello world');
}